Return to Video

Using Indexes - Data Wranging with MongoDB

  • 0:00 - 0:01
    Muito bem. Agora, quero mostrar uma
  • 0:01 - 0:07
    grande coleção e o efeito que a indexação pode ter no desempenho. Agora,
  • 0:07 - 0:10
    nossa coleção de tweets é relativamente pequena. Portanto, em vez de
  • 0:10 - 0:13
    revisitar o conjunto de dados OpenStreetMap, do qual você deve se lembrar da
  • 0:13 - 0:16
    lição anterior, isso também servirá como uma boa transição
  • 0:16 - 0:19
    para a próxima lição que é um projeto que usa os dados do OpenStreet
  • 0:19 - 0:22
    Map. Portanto, para este exemplo, vou trabalhar no
  • 0:22 - 0:25
    shell do MongoDB, e o banco de dados em que esses dados estão armazenados
  • 0:25 - 0:28
    é o banco de dados OSM. Portanto, mudo para usar
  • 0:28 - 0:33
    isso e, em seguida, vamos examinar a aparência dos
  • 0:33 - 0:34
    documentos nesse banco de dados e para fazer isso,
  • 0:34 - 0:37
    vamos apenas executar um find de tudo. Ok. Em seguida, se
  • 0:37 - 0:40
    rolarmos para cima, você verá qual é a aparência desses
  • 0:40 - 0:44
    documentos. Há informações sobre locais, latitude/longitude. Portanto, todos os dados desta
  • 0:44 - 0:48
    coleção está ligada a um local específico. E uma coisa que
  • 0:48 - 0:50
    eu quero apontar é que alguns dos documentos
  • 0:50 - 0:53
    nesta coleção têm um campo TG. E isso
  • 0:53 - 0:55
    é a abreviação para tag. Se você se lembrar, examinamos
  • 0:55 - 1:00
    anteriormente a forma como locais específicos são marcados de tempos
  • 1:00 - 1:03
    em tempos dentro desse conjunto de dados específico. E, nesta coleção, a maneira
  • 1:03 - 1:06
    como essas tags funcionam é... há um
  • 1:06 - 1:10
    campo de tag que tem valor de array e cada um dos
  • 1:10 - 1:13
    valores individuais nesse array são um subdocumento com um
  • 1:13 - 1:16
    campo "k" e "v". Muito semelhante ao que vimos na
  • 1:16 - 1:18
    versão XML deste conjunto de dados. Agora, o motivo pelo qual os dados
  • 1:18 - 1:22
    são representados desta maneira é porque poderia haver várias tags,
  • 1:22 - 1:25
    todas com o mesmo tipo de chave. Portanto, armazená-los em um
  • 1:25 - 1:28
    array desta maneira, nos dá a habilidade de fazer isso sem
  • 1:28 - 1:32
    uma tag ser gravada sobre a outra quando as colocamos no MongoDB.
  • 1:32 - 1:35
    Uma alternativa seria fazer isto ser um nome de campo
  • 1:35 - 1:38
    aqui, e este ser o valor desse campo. Ok.
  • 1:38 - 1:41
    Algo que eu quero apontar sobre este conjunto de dados é que há
  • 1:41 - 1:46
    mais de sete milhões de documentos nesta coleção específica. Nós acabamos
  • 1:46 - 1:50
    de falar sobre indexação, e sobre como os índices podem melhorar o desempenho. Vamos
  • 1:50 - 1:53
    examinar uma consulta e a quantidade de tempo
  • 1:53 - 1:54
    necessária para essa consulta retornar. Neste momento, eu não tenho
  • 1:54 - 1:58
    um índice neste campo de tag. Vamos fazer uma consulta
  • 1:58 - 2:00
    e ver como é o nosso desempenho. Esta coleção específica que
  • 2:00 - 2:03
    carreguei aqui, na verdade, tem todos os dados do OpenStreetMap da
  • 2:03 - 2:06
    cidade de Chicago novamente. E o que estou fazendo aqui é consultar
  • 2:06 - 2:12
    todos os nós ou todos os locais geográficos que foram marcados com o
  • 2:12 - 2:17
    nome Giordanos que é uma famosa cadeia de pizzarias de Chicago. Se você fizer essa consulta,
  • 2:17 - 2:20
    [BLANK_AUDIO]
  • 2:20 - 2:22
    poderá ver que ela demora um pouco para
  • 2:22 - 2:24
    retornar. Vamos fazer a versão pretty desta consulta.
  • 2:24 - 2:26
    [BLANK_AUDIO]
  • 2:26 - 2:28
    Ok. Dois segundos, certo? Para a consulta
  • 2:28 - 2:31
    retornar. Se estivermos fazendo uma única consulta,
  • 2:31 - 2:34
    [SOUND] isso não será um problema. O fato é que,
  • 2:34 - 2:39
    na maioria dos aplicativos, fazemos muitas consultas. Em alguns aplicativos,
  • 2:39 - 2:41
    centenas ou talvez milhares ou dezenas de milhares de
  • 2:41 - 2:45
    consultas em um período muito curto de tempo. Portanto, esperar
  • 2:45 - 2:48
    dois segundos para uma consulta retornar, considerando a
  • 2:48 - 2:52
    carga que isso coloca sobre o servidor do banco de dados e todas aquelas consultas simultâneas
  • 2:52 - 2:54
    ocorrendo ao mesmo tempo, simplesmente não funciona
  • 2:54 - 2:57
    para nossos aplicativos. Isso mata nosso aplicativo, como mencionei
  • 2:57 - 3:01
    anteriormente. Portanto, se criarmos um índice nesta coleção,
  • 3:01 - 3:04
    nosso desempenho melhorará significativamente porque em vez de fazer um
  • 3:04 - 3:07
    exame da tabela, como vimos anteriormente, posso simplesmente ir diretamente para
  • 3:07 - 3:10
    o local no disco onde esses documentos específicos que correspondem à minha
  • 3:10 - 3:14
    consulta estão localizados. Agora, ir muito além de onde já estamos
  • 3:14 - 3:17
    com a indexação está além do escopo desta aula. Portanto,
  • 3:17 - 3:20
    vou apenas, essencialmente, introduzir índices a você
  • 3:20 - 3:23
    aqui. E incentivo você a examinar a documentação do MongoDB
  • 3:23 - 3:26
    ou dar uma olhar nos cursos gratuitos online
  • 3:26 - 3:30
    que oferecemos em university.mongodb.com, para ver as notas do instrutor para
  • 3:30 - 3:33
    obter um tratamento abrangente de todos esses tópicos que
  • 3:33 - 3:36
    discutimos em relação ao Mongo DB, inclusive indexação. Ok.
  • 3:36 - 3:38
    Vamos criar meu índice. E a maneira como faço
  • 3:38 - 3:42
    isso é especificando o campo no qual desejo que o
  • 3:42 - 3:45
    índice seja criado. E faço isso simplesmente dizendo,
  • 3:45 - 3:48
    suponha que há um índice no
  • 3:48 - 3:54
    campo tg na coleção nodes. Certo? Novamente,
  • 3:54 - 3:56
    há mais de sete milhões de documentos nessa coleção, portanto, isso vai
  • 3:56 - 3:58
    levar algum tempo para retornar. Vai demorar um
  • 3:58 - 4:01
    pouco para cria o índice. Se tivéssemos criado o
  • 4:01 - 4:03
    índice no início, quando estávamos carregando os dados na
  • 4:03 - 4:07
    coleção, eles teriam sido atualizados com cada gravação no
  • 4:07 - 4:10
    banco de dados. Mas, neste caso, estamos criando o índice depois
  • 4:10 - 4:11
    que carregamos todos os dados para que eu possa explicar
  • 4:11 - 4:15
    este exemplo. Portanto, vamos pular no vídeo até o
  • 4:15 - 4:17
    ponto onde o índice está realmente criado. Isso vai levar
  • 4:17 - 4:21
    alguns minutos. Certo. Agora, com o índice criado, vamos executar
  • 4:21 - 4:24
    essa consulta novamente e examinar a diferença no desempenho. Foi intimidante.
  • 4:24 - 4:29
    Realmente. Obtivemos nossos documentos de volta imediatamente. E isso ilustra
  • 4:29 - 4:33
    as diferenças do desempenho em relação a usar um índice versus não usar um índice.
Tytuł:
Using Indexes - Data Wranging with MongoDB
Video Language:
English
Team:
Udacity
Projekt:
UD032: Data Wrangling with MongoDB
Duration:
04:34

Portuguese, Brazilian subtitles

Revisions Compare revisions