MongoDB - Guia Rápido

MongoDB é um banco de dados de plataforma cruzada orientado a documentos que fornece alto desempenho, alta disponibilidade e fácil escalabilidade. O MongoDB trabalha no conceito de coleção e documento.

Base de dados

O banco de dados é um contêiner físico para coleções. Cada banco de dados obtém seu próprio conjunto de arquivos no sistema de arquivos. Um único servidor MongoDB normalmente tem vários bancos de dados.

Coleção

Coleção é um grupo de documentos MongoDB. É o equivalente a uma tabela RDBMS. Existe uma coleção em um único banco de dados. As coleções não impõem um esquema. Os documentos de uma coleção podem ter campos diferentes. Normalmente, todos os documentos em uma coleção têm finalidades semelhantes ou relacionadas.

Documento

Um documento é um conjunto de pares de valores-chave. Os documentos possuem esquema dinâmico. O esquema dinâmico significa que os documentos na mesma coleção não precisam ter o mesmo conjunto de campos ou estrutura, e os campos comuns nos documentos de uma coleção podem conter diferentes tipos de dados.

A tabela a seguir mostra o relacionamento da terminologia RDBMS com o MongoDB.

RDBMS MongoDB
Base de dados Base de dados
Mesa Coleção
Tupla / Linha Documento
coluna Campo
Junção de mesa Documentos Embutidos
Chave primária Chave primária (chave padrão _id fornecida pelo próprio mongodb)
Servidor e cliente de banco de dados
Mysqld / Oracle Mongod
mysql / sqlplus Mongo

Documento de amostra

O exemplo a seguir mostra a estrutura do documento de um site de blog, que é simplesmente um par de valores-chave separados por vírgulas.

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100, 
   comments: [	
      {
         user:'user1',
         message: 'My first comment',
         dateCreated: new Date(2011,1,20,2,15),
         like: 0 
      },
      {
         user:'user2',
         message: 'My second comments',
         dateCreated: new Date(2011,1,25,7,45),
         like: 5
      }
   ]
}

_idé um número hexadecimal de 12 bytes que garante a exclusividade de cada documento. Você pode fornecer _id ao inserir o documento. Se você não fornecer, o MongoDB fornecerá uma id exclusiva para cada documento. Esses 12 bytes, os primeiros 4 bytes para o carimbo de data / hora atual, os próximos 3 bytes para a id da máquina, os próximos 2 bytes para a id do processo do servidor MongoDB e os 3 bytes restantes são simples VALORES incrementais.

Qualquer banco de dados relacional tem um design de esquema típico que mostra o número de tabelas e o relacionamento entre essas tabelas. Enquanto no MongoDB, não há conceito de relacionamento.

Vantagens do MongoDB sobre RDBMS

  • Schema less- MongoDB é um banco de dados de documentos no qual uma coleção contém diferentes documentos. O número de campos, o conteúdo e o tamanho do documento podem variar de um documento para outro.

  • A estrutura de um único objeto é clara.

  • Sem junções complexas.

  • Capacidade de consulta profunda. O MongoDB oferece suporte a consultas dinâmicas em documentos usando uma linguagem de consulta baseada em documentos que é quase tão poderosa quanto SQL.

  • Tuning.

  • Ease of scale-out - O MongoDB é fácil de escalar.

  • Não é necessária a conversão / mapeamento de objetos de aplicativo em objetos de banco de dados.

  • Usa memória interna para armazenar o conjunto de trabalho (em janelas), permitindo acesso mais rápido aos dados.

Por que usar o MongoDB?

  • Document Oriented Storage - Os dados são armazenados na forma de documentos de estilo JSON.

  • Índice em qualquer atributo

  • Replicação e alta disponibilidade

  • Auto-sharding

  • Consultas ricas

  • Atualizações rápidas no local

  • Suporte profissional por MongoDB

Onde usar o MongoDB?

  • Big Data
  • Gerenciamento e entrega de conteúdo
  • Infraestrutura Móvel e Social
  • Gerenciamento de dados do usuário
  • Hub de dados

Vamos agora ver como instalar o MongoDB no Windows.

Instale o MongoDB no Windows

Para instalar o MongoDB no Windows, primeiro baixe a versão mais recente do MongoDB em https://www.mongodb.org/downloads. Certifique-se de obter a versão correta do MongoDB, dependendo da sua versão do Windows. Para obter sua versão do Windows, abra o prompt de comando e execute o seguinte comando.

C:\>wmic os get osarchitecture
OSArchitecture
64-bit
C:\>

As versões de 32 bits do MongoDB suportam apenas bancos de dados menores que 2 GB e são adequadas apenas para fins de teste e avaliação.

Agora extraia o arquivo baixado na unidade c: \ ou em qualquer outro local. Certifique-se de que o nome da pasta extraída seja mongodb-win32-i386- [versão] ou mongodb-win32-x86_64- [versão]. Aqui [version] é a versão do download do MongoDB.

Em seguida, abra o prompt de comando e execute o seguinte comando.

C:\>move mongodb-win64-* mongodb
   1 dir(s) moved.
C:\>

Caso você tenha extraído o MongoDB em um local diferente, vá para esse caminho usando o comando cd FOLDER/DIR e agora execute o processo fornecido acima.

O MongoDB requer uma pasta de dados para armazenar seus arquivos. O local padrão para o diretório de dados MongoDB é c: \ data \ db. Portanto, você precisa criar esta pasta usando o Prompt de Comando. Execute a seguinte seqüência de comando.

C:\>md data
C:\md data\db

Se você tiver que instalar o MongoDB em um local diferente, será necessário especificar um caminho alternativo para \data\db definindo o caminho dbpath dentro mongod.exe. Para o mesmo, emita os seguintes comandos.

No prompt de comando, navegue até o diretório bin presente na pasta de instalação do MongoDB. Suponha que minha pasta de instalação sejaD:\set up\mongodb

C:\Users\XYZ>d:
D:\>cd "set up"
D:\set up>cd mongodb
D:\set up\mongodb>cd bin
D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data"

Isso vai mostrar waiting for connections mensagem na saída do console, que indica que o processo mongod.exe está sendo executado com êxito.

Agora, para executar o MongoDB, você precisa abrir outro prompt de comando e emitir o seguinte comando.

D:\set up\mongodb\bin>mongo.exe
MongoDB shell version: 2.4.6
connecting to: test
>db.test.save( { a: 1 } )
>db.test.find()
{ "_id" : ObjectId(5879b0f65a56a454), "a" : 1 }
>

Isso mostrará que o MongoDB foi instalado e executado com êxito. Da próxima vez, quando você executar o MongoDB, precisará emitir apenas comandos.

D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data" 
D:\set up\mongodb\bin>mongo.exe

Instale o MongoDB no Ubuntu

Execute o seguinte comando para importar a chave GPG pública do MongoDB -

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

Crie um arquivo /etc/apt/sources.list.d/mongodb.list usando o seguinte comando.

echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' 
   | sudo tee /etc/apt/sources.list.d/mongodb.list

Agora emita o seguinte comando para atualizar o repositório -

sudo apt-get update

Em seguida, instale o MongoDB usando o seguinte comando -

apt-get install mongodb-10gen = 2.2.3

Na instalação acima, 2.2.3 é a versão do MongoDB lançada atualmente. Certifique-se de instalar a versão mais recente sempre. Agora o MongoDB foi instalado com sucesso.

Inicie o MongoDB

sudo service mongodb start

Pare o MongoDB

sudo service mongodb stop

Reinicie o MongoDB

sudo service mongodb restart

Para usar o MongoDB, execute o seguinte comando.

mongo

Isso conectará você à instância do MongoDB em execução.

Ajuda do MongoDB

Para obter uma lista de comandos, digite db.help()no cliente MongoDB. Isso lhe dará uma lista de comandos conforme mostrado na imagem a seguir.

Estatísticas do MongoDB

Para obter estatísticas sobre o servidor MongoDB, digite o comando db.stats()no cliente MongoDB. Isso mostrará o nome do banco de dados, número de coleção e documentos no banco de dados. A saída do comando é mostrada na imagem a seguir.

Os dados no MongoDB têm um schema.documents flexível na mesma coleção. Eles não precisam ter o mesmo conjunto de campos ou estrutura, e os campos comuns nos documentos de uma coleção podem conter diferentes tipos de dados.

Algumas considerações ao projetar Schema no MongoDB

  • Projete seu esquema de acordo com os requisitos do usuário.

  • Combine objetos em um documento se você for usá-los juntos. Caso contrário, separe-os (mas certifique-se de que não haja necessidade de junções).

  • Duplique os dados (mas limitado) porque o espaço em disco é barato em comparação com o tempo de computação.

  • Faça junções durante a gravação, não na leitura.

  • Otimize seu esquema para os casos de uso mais frequentes.

  • Faça agregação complexa no esquema.

Exemplo

Suponha que um cliente precise de um design de banco de dados para seu blog / website e veja as diferenças entre o design de esquema RDBMS e MongoDB. O site possui os seguintes requisitos.

  • Cada postagem tem título, descrição e url exclusivos.
  • Cada postagem pode ter uma ou mais tags.
  • Cada postagem tem o nome de seu editor e o número total de curtidas.
  • Cada postagem tem comentários feitos pelos usuários junto com seu nome, mensagem, data e hora e curtidas.
  • Em cada postagem, pode haver zero ou mais comentários.

No esquema RDBMS, o design para os requisitos acima terá no mínimo três tabelas.

Enquanto estiver no esquema MongoDB, o design terá uma postagem de coleta e a seguinte estrutura -

{
   _id: POST_ID
   title: TITLE_OF_POST, 
   description: POST_DESCRIPTION,
   by: POST_BY,
   url: URL_OF_POST,
   tags: [TAG1, TAG2, TAG3],
   likes: TOTAL_LIKES, 
   comments: [	
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES 
      },
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES
      }
   ]
}

Portanto, ao mostrar os dados, no RDBMS você precisa juntar três tabelas e no MongoDB, os dados serão mostrados de apenas uma coleção.

Neste capítulo, veremos como criar um banco de dados no MongoDB.

O comando de uso

MongoDB use DATABASE_NAMEé usado para criar banco de dados. O comando criará um novo banco de dados se ele não existir, caso contrário, retornará o banco de dados existente.

Sintaxe

Sintaxe básica de use DATABASE declaração é a seguinte -

use DATABASE_NAME

Exemplo

Se você quiser usar um banco de dados com nome <mydb>, então use DATABASE declaração seria a seguinte -

>use mydb
switched to db mydb

Para verificar seu banco de dados selecionado atualmente, use o comando db

>db
mydb

Se você quiser verificar sua lista de bancos de dados, use o comando show dbs.

>show dbs
local     0.78125GB
test      0.23012GB

Seu banco de dados criado (mydb) não está presente na lista. Para exibir o banco de dados, você precisa inserir pelo menos um documento nele.

>db.movie.insert({"name":"tutorials point"})
>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB

No banco de dados do MongoDB padrão é test. Se você não criou nenhum banco de dados, as coleções serão armazenadas no banco de dados de teste.

Neste capítulo, veremos como eliminar um banco de dados usando o comando MongoDB.

Método dropDatabase ()

MongoDB db.dropDatabase() comando é usado para descartar um banco de dados existente.

Sintaxe

Sintaxe básica de dropDatabase() o comando é o seguinte -

db.dropDatabase()

Isso excluirá o banco de dados selecionado. Se você não selecionou nenhum banco de dados, o banco de dados de 'teste' será excluído.

Exemplo

Primeiro, verifique a lista de bancos de dados disponíveis usando o comando, show dbs.

>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB
>

Se você deseja deletar um novo banco de dados <mydb>, então dropDatabase() comando seria o seguinte -

>use mydb
switched to db mydb
>db.dropDatabase()
>{ "dropped" : "mydb", "ok" : 1 }
>

Agora verifique a lista de bancos de dados.

>show dbs
local      0.78125GB
test       0.23012GB
>

Neste capítulo, veremos como criar uma coleção usando MongoDB.

Método createCollection ()

MongoDB db.createCollection(name, options) é usado para criar a coleção.

Sintaxe

Sintaxe básica de createCollection() o comando é o seguinte -

db.createCollection(name, options)

No comando, name é o nome da coleção a ser criada. Options é um documento e é usado para especificar a configuração da coleção.

Parâmetro Tipo Descrição
Nome Corda Nome da coleção a ser criada
Opções Documento (Opcional) Especifique opções sobre o tamanho da memória e indexação

O parâmetro Options é opcional, portanto, você precisa especificar apenas o nome da coleção. A seguir está a lista de opções que você pode usar -

Campo Tipo Descrição
tampado boleano (Opcional) Se verdadeiro, ativa uma coleção limitada. A coleção limitada é uma coleção de tamanho fixo que sobrescreve automaticamente suas entradas mais antigas quando atinge seu tamanho máximo.If you specify true, you need to specify size parameter also.
autoIndexId boleano (Opcional) Se verdadeiro, cria o índice automaticamente em _id field.s O valor padrão é falso.
Tamanho número (Opcional) Especifica um tamanho máximo em bytes para uma coleção limitada. If capped is true, then you need to specify this field also.
max número (Opcional) Especifica o número máximo de documentos permitidos na coleção limitada.

Ao inserir o documento, o MongoDB primeiro verifica o campo de tamanho da coleção limitada e, em seguida, verifica o campo máximo.

Exemplos

Sintaxe básica de createCollection() método sem opções é o seguinte -

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>

Você pode verificar a coleção criada usando o comando show collections.

>show collections
mycollection
system.indexes

O exemplo a seguir mostra a sintaxe de createCollection() método com poucas opções importantes -

>db.createCollection("mycol", { capped : true, autoIndexId : true, size : 
   6142800, max : 10000 } )
{ "ok" : 1 }
>

No MongoDB, você não precisa criar uma coleção. O MongoDB cria a coleção automaticamente, quando você insere algum documento.

>db.tutorialspoint.insert({"name" : "tutorialspoint"})
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

Neste capítulo, veremos como eliminar uma coleção usando o MongoDB.

Método drop ()

MongoDB's db.collection.drop() é usado para descartar uma coleção do banco de dados.

Sintaxe

Sintaxe básica de drop() o comando é o seguinte -

db.COLLECTION_NAME.drop()

Exemplo

Primeiro, verifique as coleções disponíveis em seu banco de dados mydb.

>use mydb
switched to db mydb
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

Agora, largue a coleção com o nome mycollection.

>db.mycollection.drop()
true
>

Verifique novamente a lista de coleções no banco de dados.

>show collections
mycol
system.indexes
tutorialspoint
>

O método drop () retornará verdadeiro, se a coleção selecionada for descartada com sucesso, caso contrário, retornará falso.

MongoDB suporta muitos tipos de dados. Alguns deles são -

  • String- Este é o tipo de dados mais comumente usado para armazenar os dados. A string no MongoDB deve ser válida em UTF-8.

  • Integer- Este tipo é usado para armazenar um valor numérico. O número inteiro pode ser de 32 ou 64 bits, dependendo do seu servidor.

  • Boolean - Este tipo é usado para armazenar um valor booleano (verdadeiro / falso).

  • Double - Este tipo é usado para armazenar valores de ponto flutuante.

  • Min/ Max keys - Este tipo é usado para comparar um valor com os elementos BSON mais baixos e mais altos.

  • Arrays - Este tipo é usado para armazenar matrizes ou lista ou vários valores em uma chave.

  • Timestamp- ctimestamp. Isso pode ser útil para registrar quando um documento foi modificado ou adicionado.

  • Object - Este tipo de dados é usado para documentos incorporados.

  • Null - Este tipo é usado para armazenar um valor Nulo.

  • Symbol- Este tipo de dados é usado de forma idêntica a uma string; no entanto, geralmente é reservado para idiomas que usam um tipo de símbolo específico.

  • Date - Este tipo de dados é usado para armazenar a data ou hora atual no formato de hora UNIX. Você pode especificar sua própria data e hora criando o objeto Data e passando o dia, mês, ano para ele.

  • Object ID - Este tipo de dados é usado para armazenar o ID do documento.

  • Binary data - Este tipo de dados é usado para armazenar dados binários.

  • Code - Este tipo de dados é usado para armazenar o código JavaScript no documento.

  • Regular expression - Este tipo de dados é usado para armazenar expressões regulares.

Neste capítulo, aprenderemos como inserir documentos na coleção do MongoDB.

O Método insert ()

Para inserir dados na coleção do MongoDB, você precisa usar o MongoDB insert() ou save() método.

Sintaxe

A sintaxe básica de insert() o comando é o seguinte -

>db.COLLECTION_NAME.insert(document)

Exemplo

>db.mycol.insert({
   _id: ObjectId(7df78ad8902c),
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
})

Aqui mycolé o nome da nossa coleção, conforme criado no capítulo anterior. Se a coleção não existir no banco de dados, o MongoDB criará essa coleção e inserirá um documento nela.

No documento inserido, se não especificarmos o parâmetro _id, o MongoDB atribuirá um ObjectId exclusivo para este documento.

_id é um número hexadecimal de 12 bytes exclusivo para cada documento em uma coleção. 12 bytes são divididos da seguinte forma -

_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id, 
   3 bytes incrementer)

Para inserir vários documentos em uma única consulta, você pode passar uma matriz de documentos no comando insert ().

Exemplo

>db.post.insert([
   {
      title: 'MongoDB Overview', 
      description: 'MongoDB is no sql database',
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 100
   },
	
   {
      title: 'NoSQL Database', 
      description: "NoSQL database doesn't have tables",
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 20, 
      comments: [	
         {
            user:'user1',
            message: 'My first comment',
            dateCreated: new Date(2013,11,10,2,35),
            like: 0 
         }
      ]
   }
])

Para inserir o documento, você pode usar db.post.save(document)Além disso. Se você não especificar_id no documento então save() método funcionará da mesma forma que insert()método. Se você especificar _id, ele substituirá todos os dados do documento contendo _id conforme especificado no método save ().

Neste capítulo, aprenderemos como consultar documentos da coleção MongoDB.

O Método find ()

Para consultar dados da coleção do MongoDB, você precisa usar o MongoDB find() método.

Sintaxe

A sintaxe básica de find() método é o seguinte -

>db.COLLECTION_NAME.find()

find() método irá exibir todos os documentos de uma forma não estruturada.

Método pretty ()

Para exibir os resultados de forma formatada, você pode usar pretty() método.

Sintaxe

>db.mycol.find().pretty()

Exemplo

>db.mycol.find().pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

Além do método find (), existe findOne() método, que retorna apenas um documento.

RDBMS Where Clause Equivalents no MongoDB

Para consultar o documento com base em alguma condição, você pode usar as seguintes operações.

Operação Sintaxe Exemplo RDBMS Equivalente
Igualdade {<key>: <value>} db.mycol.find ({"by": "tutorials point"}). pretty () onde por = 'tutoriais apontam'
Menor que {<key>: {$ lt: <value>}} db.mycol.find ({"likes": {$ lt: 50}}). pretty () onde gosta <50
Menor do que igual {<key>: {$ lte: <value>}} db.mycol.find ({"likes": {$ lte: 50}}). pretty () onde gosta <= 50
Maior que {<key>: {$ gt: <value>}} db.mycol.find ({"likes": {$ gt: 50}}). pretty () onde curtir> 50
Maior que igual {<key>: {$ gte: <value>}} db.mycol.find ({"likes": {$ gte: 50}}). pretty () onde curtir> = 50
Diferente {<key>: {$ ne: <value>}} db.mycol.find ({"likes": {$ ne: 50}}). pretty () onde gosta! = 50

E no MongoDB

Sintaxe

No find() método, se você passar várias chaves separando-as por ',' o MongoDB o tratará como ANDdoença. A seguir está a sintaxe básica deAND -

>db.mycol.find(
   {
      $and: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

Exemplo

O exemplo a seguir mostrará todos os tutoriais escritos por 'tutorials point' e cujo título é 'Visão geral do MongoDB'.

>db.mycol.find({$and:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty() {
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}

Para o exemplo acima dado, equivalente onde a cláusula será ' where by = 'tutorials point' AND title = 'MongoDB Overview' '. Você pode passar qualquer número de pares de chave e valor na cláusula find.

OR no MongoDB

Sintaxe

Para consultar documentos com base na condição OR, você precisa usar $orpalavra-chave. A seguir está a sintaxe básica deOR -

>db.mycol.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

Exemplo

O exemplo a seguir mostrará todos os tutoriais escritos por 'ponto de tutorial' ou cujo título é 'Visão geral do MongoDB'.

>db.mycol.find({$or:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

Usando AND e OR juntos

Exemplo

O exemplo a seguir mostrará os documentos que têm curtidas maiores que 10 e cujo título é 'Visão geral do MongoDB' ou 'ponto de tutorial'. SQL equivalente onde a cláusula é'where likes>10 AND (by = 'tutorials point' OR title = 'MongoDB Overview')'

>db.mycol.find({"likes": {$gt:10}, $or: [{"by": "tutorials point"},
   {"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

MongoDB's update() e save()métodos são usados ​​para atualizar o documento em uma coleção. O método update () atualiza os valores no documento existente enquanto o método save () substitui o documento existente pelo documento passado no método save ().

Método MongoDB Update ()

O método update () atualiza os valores no documento existente.

Sintaxe

A sintaxe básica de update() método é o seguinte -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)

Exemplo

Considere que a coleção mycol tem os seguintes dados.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

O exemplo a seguir definirá o novo título 'Novo Tutorial do MongoDB' dos documentos cujo título é 'Visão geral do MongoDB'.

>db.mycol.update({'title':'MongoDB Overview'},{$set:{'title':'New MongoDB Tutorial'}})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"New MongoDB Tutorial"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

Por padrão, o MongoDB atualizará apenas um único documento. Para atualizar vários documentos, você precisa definir um parâmetro 'multi' como verdadeiro.

>db.mycol.update({'title':'MongoDB Overview'},
   {$set:{'title':'New MongoDB Tutorial'}},{multi:true})

Método MongoDB Save ()

o save() O método substitui o documento existente pelo novo documento passado no método save ().

Sintaxe

A sintaxe básica do MongoDB save() método é mostrado abaixo -

>db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Exemplo

O exemplo a seguir substituirá o documento pelo _id '5983548781331adf45ec5'.

>db.mycol.save(
   {
      "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
      "by":"Tutorials Point"
   }
)
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
   "by":"Tutorials Point"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

Neste capítulo, aprenderemos como excluir um documento usando o MongoDB.

O método remove ()

MongoDB's remove()método é usado para remover um documento da coleção. O método remove () aceita dois parâmetros. Um é o critério de exclusão e o segundo é a bandeira justOne.

  • deletion criteria - (Opcional) os critérios de exclusão de acordo com os documentos serão removidos.

  • justOne - (Opcional) se definido como verdadeiro ou 1, remova apenas um documento.

Sintaxe

Sintaxe básica de remove() método é o seguinte -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Exemplo

Considere que a coleção mycol tem os seguintes dados.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

O exemplo a seguir removerá todos os documentos cujo título é 'Visão geral do MongoDB'.

>db.mycol.remove({'title':'MongoDB Overview'})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

Remover apenas um

Se houver vários registros e você quiser excluir apenas o primeiro registro, defina justOne parâmetro em remove() método.

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

Remover todos os documentos

Se você não especificar os critérios de exclusão, o MongoDB excluirá documentos inteiros da coleção. This is equivalent of SQL's truncate command.

>db.mycol.remove({})
>db.mycol.find()
>

No MongoDB, projeção significa selecionar apenas os dados necessários, em vez de selecionar todos os dados de um documento. Se um documento tiver 5 campos e você precisar mostrar apenas 3, selecione apenas 3 campos deles.

O Método find ()

MongoDB's find()método, explicado em Documento de consulta MongoDB aceita o segundo parâmetro opcional que é a lista de campos que você deseja recuperar. No MongoDB, quando você executafind()método, ele exibe todos os campos de um documento. Para limitar isso, você precisa definir uma lista de campos com valor 1 ou 0. 1 é usado para mostrar o campo, enquanto 0 é usado para ocultar os campos.

Sintaxe

A sintaxe básica de find() método com projeção é o seguinte -

>db.COLLECTION_NAME.find({},{KEY:1})

Exemplo

Considere que a coleção mycol tem os seguintes dados -

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

O exemplo a seguir exibirá o título do documento durante a consulta ao documento.

>db.mycol.find({},{"title":1,_id:0})
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
{"title":"Tutorials Point Overview"}
>

Observe _id campo é sempre exibido durante a execução find() método, se você não quiser esse campo, você precisa defini-lo como 0.

Neste capítulo, aprenderemos como limitar registros usando MongoDB.

Método Limit ()

Para limitar os registros no MongoDB, você precisa usar limit()método. O método aceita um argumento de tipo de número, que é o número de documentos que você deseja exibir.

Sintaxe

A sintaxe básica de limit() método é o seguinte -

>db.COLLECTION_NAME.find().limit(NUMBER)

Exemplo

Considere que a coleção myycol possui os seguintes dados.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

O exemplo a seguir exibirá apenas dois documentos ao consultar o documento.

>db.mycol.find({},{"title":1,_id:0}).limit(2)
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
>

Se você não especificar o argumento de número em limit() então ele exibirá todos os documentos da coleção.

Método MongoDB Skip ()

Além do método limit (), há mais um método skip() que também aceita o argumento do tipo de número e é usado para pular o número de documentos.

Sintaxe

A sintaxe básica de skip() método é o seguinte -

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

Exemplo

O exemplo a seguir exibirá apenas o segundo documento.

>db.mycol.find({},{"title":1,_id:0}).limit(1).skip(1)
{"title":"NoSQL Overview"}
>

Observe que o valor padrão em skip() método é 0.

Neste capítulo, aprenderemos como classificar registros no MongoDB.

O método sort ()

Para classificar documentos no MongoDB, você precisa usar sort()método. O método aceita um documento que contém uma lista de campos junto com sua ordem de classificação. Para especificar a ordem de classificação, 1 e -1 são usados. 1 é usado para ordem crescente, enquanto -1 é usado para ordem decrescente.

Sintaxe

A sintaxe básica de sort() método é o seguinte -

>db.COLLECTION_NAME.find().sort({KEY:1})

Exemplo

Considere que a coleção myycol possui os seguintes dados.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

O exemplo a seguir exibirá os documentos classificados por título em ordem decrescente.

>db.mycol.find({},{"title":1,_id:0}).sort({"title":-1})
{"title":"Tutorials Point Overview"}
{"title":"NoSQL Overview"}
{"title":"MongoDB Overview"}
>

Observe, se você não especificar a preferência de classificação, então sort() método exibirá os documentos em ordem crescente.

Os índices suportam a resolução eficiente de consultas. Sem índices, o MongoDB deve verificar todos os documentos de uma coleção para selecionar os documentos que correspondem à instrução de consulta. Essa varredura é altamente ineficiente e exige que o MongoDB processe um grande volume de dados.

Os índices são estruturas de dados especiais, que armazenam uma pequena parte do conjunto de dados em uma forma fácil de percorrer. O índice armazena o valor de um campo específico ou conjunto de campos, ordenado pelo valor do campo conforme especificado no índice.

O método garantirIndex ()

Para criar um índice, você precisa usar o método verifyIndex () do MongoDB.

Sintaxe

A sintaxe básica de ensureIndex() método é o seguinte ().

>db.COLLECTION_NAME.ensureIndex({KEY:1})

Aqui, a chave é o nome do campo no qual você deseja criar o índice e 1 é para ordem crescente. Para criar o índice em ordem decrescente, você precisa usar -1.

Exemplo

>db.mycol.ensureIndex({"title":1})
>

Dentro ensureIndex() método você pode passar vários campos, para criar o índice em vários campos.

>db.mycol.ensureIndex({"title":1,"description":-1})
>

ensureIndex()método também aceita lista de opções (que são opcionais). A seguir está a lista -

Parâmetro Tipo Descrição
fundo boleano Constrói o índice em segundo plano para que a construção de um índice não bloqueie outras atividades do banco de dados. Especifique true para construir em segundo plano. o valor padrão éfalse.
único boleano Cria um índice exclusivo para que a coleção não aceite a inserção de documentos onde a chave ou chaves do índice correspondem a um valor existente no índice. Especifique true para criar um índice exclusivo. o valor padrão éfalse.
nome corda O nome do índice. Se não for especificado, o MongoDB gera um nome de índice concatenando os nomes dos campos indexados e a ordem de classificação.
dropDups boleano Cria um índice exclusivo em um campo que pode ter duplicatas. O MongoDB indexa apenas a primeira ocorrência de uma chave e remove todos os documentos da coleção que contêm ocorrências subsequentes dessa chave. Especifique true para criar um índice exclusivo. o valor padrão éfalse.
escasso boleano Se verdadeiro, o índice faz referência apenas a documentos com o campo especificado. Esses índices usam menos espaço, mas se comportam de maneira diferente em algumas situações (principalmente classificações). o valor padrão éfalse.
expireAfterSeconds inteiro Especifica um valor, em segundos, como um TTL para controlar por quanto tempo o MongoDB retém documentos nesta coleção.
v versão do índice O número da versão do índice. A versão do índice padrão depende da versão do MongoDB em execução ao criar o índice.
pesos documento O peso é um número que varia de 1 a 99.999 e denota a importância do campo em relação aos outros campos indexados em termos de pontuação.
idioma padrão corda Para um índice de texto, o idioma que determina a lista de palavras de parada e as regras para o lematizador e o tokenizer. o valor padrão éenglish.
language_override corda Para um índice de texto, especifique o nome do campo no documento que contém, o idioma para substituir o idioma padrão. O valor padrão é idioma.

As operações de agregação processam registros de dados e retornam resultados computados. As operações de agregação agrupam valores de vários documentos e podem executar uma variedade de operações nos dados agrupados para retornar um único resultado. Na contagem SQL (*) e com group by é equivalente à agregação mongodb.

O método aggregate ()

Para a agregação no MongoDB, você deve usar aggregate() método.

Sintaxe

Sintaxe básica de aggregate() método é o seguinte -

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

Exemplo

Na coleção, você tem os seguintes dados -

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

Agora, da coleção acima, se você deseja exibir uma lista informando quantos tutoriais são escritos por cada usuário, você usará o seguinte aggregate() método -

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "tutorials point",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

A consulta equivalente ao sql para o caso de uso acima será select by_user, count(*) from mycol group by by_user.

No exemplo acima, agrupamos os documentos por campo by_usere em cada ocorrência de by_user o valor anterior de soma é incrementado. A seguir está uma lista de expressões de agregação disponíveis.

Expressão Descrição Exemplo
$ soma Soma o valor definido de todos os documentos da coleção. db.mycol.aggregate ([{$ group: {_id: "$by_user", num_tutorial : {$soma: "$ likes"}}}])
$ médio Calcula a média de todos os valores fornecidos de todos os documentos da coleção. db.mycol.aggregate ([{$group : {_id : "$by_user ", num_tutorial: {$avg : "$gosta de "}}}])
$ min Obtém o mínimo dos valores correspondentes de todos os documentos da coleção. db.mycol.aggregate ([{$ group: {_id: "$by_user", num_tutorial : {$min: "$ likes"}}}])
$ max Obtém o máximo dos valores correspondentes de todos os documentos da coleção. db.mycol.aggregate ([{$group : {_id : "$by_user ", num_tutorial: {$max : "$gosta de "}}}])
$ push Insere o valor em uma matriz no documento resultante. db.mycol.aggregate ([{$ group: {_id: "$by_user", url : {$push: "$ url"}}}])
$ addToSet Insere o valor em uma matriz no documento resultante, mas não cria duplicatas. db.mycol.aggregate ([{$group : {_id : "$by_user ", url: {$addToSet : "$url "}}}])
$ primeiro Obtém o primeiro documento dos documentos de origem de acordo com o agrupamento. Normalmente, isso só faz sentido junto com algum estágio “$ sort” aplicado anteriormente. db.mycol.aggregate ([{$group : {_id : "$by_user ", first_url: {$first : "$url "}}}])
$ último Obtém o último documento dos documentos de origem de acordo com o agrupamento. Normalmente, isso só faz sentido junto com algum estágio “$ sort” aplicado anteriormente. db.mycol.aggregate ([{$group : {_id : "$by_user ", last_url: {$last : "$url "}}}])

Conceito de Pipeline

No comando UNIX, shell pipeline significa a possibilidade de executar uma operação em alguma entrada e usar a saída como entrada para o próximo comando e assim por diante. O MongoDB também suporta o mesmo conceito na estrutura de agregação. Há um conjunto de estágios possíveis e cada um deles é considerado um conjunto de documentos como uma entrada e produz um conjunto de documentos resultante (ou o documento JSON final resultante no final do pipeline). Isso pode então ser usado para o próximo estágio e assim por diante.

A seguir estão os estágios possíveis na estrutura de agregação -

  • $project - Usado para selecionar alguns campos específicos de uma coleção.

  • $match - Esta é uma operação de filtragem e, portanto, pode reduzir a quantidade de documentos que são dados como entrada para a próxima etapa.

  • $group - Isso faz a agregação real conforme discutido acima.

  • $sort - Classifica os documentos.

  • $skip - Com isso, é possível avançar na lista de documentos para uma determinada quantidade de documentos.

  • $limit - Isso limita a quantidade de documentos a serem examinados, pelo número fornecido a partir das posições atuais.

  • $unwind- Isso é usado para desenrolar documentos que estão usando matrizes. Ao usar uma matriz, os dados são meio que pré-unidos e esta operação será desfeita com isso para ter documentos individuais novamente. Assim, com esta etapa iremos aumentar a quantidade de documentos para a próxima etapa.

A replicação é o processo de sincronização de dados em vários servidores. A replicação fornece redundância e aumenta a disponibilidade de dados com várias cópias de dados em diferentes servidores de banco de dados. A replicação protege um banco de dados da perda de um único servidor. A replicação também permite a recuperação de falhas de hardware e interrupções de serviço. Com cópias adicionais dos dados, você pode dedicar uma para a recuperação de desastres, relatórios ou backup.

Por que replicação?

  • Para manter seus dados seguros
  • Alta (24 * 7) disponibilidade de dados
  • Recuperação de desastre
  • Sem tempo de inatividade para manutenção (como backups, reconstruções de índice, compactação)
  • Escala de leitura (cópias extras para leitura)
  • O conjunto de réplicas é transparente para o aplicativo

Como funciona a replicação no MongoDB

O MongoDB atinge a replicação pelo uso de um conjunto de réplicas. Um conjunto de réplicas é um grupo demongodinstâncias que hospedam o mesmo conjunto de dados. Em uma réplica, um nó é o nó primário que recebe todas as operações de gravação. Todas as outras instâncias, como secundárias, aplicam operações do primário para que tenham o mesmo conjunto de dados. O conjunto de réplicas pode ter apenas um nó primário.

  • O conjunto de réplicas é um grupo de dois ou mais nós (geralmente, no mínimo 3 nós são necessários).

  • Em um conjunto de réplicas, um nó é o nó primário e os nós restantes são secundários.

  • Todos os dados são replicados do nó primário para o secundário.

  • No momento do failover automático ou manutenção, a eleição estabelece para o primário e um novo nó primário é eleito.

  • Após a recuperação do nó com falha, ele se junta novamente ao conjunto de réplicas e funciona como um nó secundário.

Um diagrama típico de replicação do MongoDB é mostrado no qual o aplicativo cliente sempre interage com o nó primário e o nó primário, em seguida, replica os dados para os nós secundários.

Recursos do conjunto de réplicas

  • Um cluster de N nós
  • Qualquer nó pode ser primário
  • Todas as operações de gravação vão para o primário
  • Failover automático
  • Recuperação automática
  • Eleição de consenso das primárias

Configurar um conjunto de réplicas

Neste tutorial, converteremos a instância autônoma do MongoDB em um conjunto de réplicas. Para converter para um conjunto de réplicas, a seguir estão as etapas -

  • Desligue o servidor MongoDB já em execução.

  • Inicie o servidor MongoDB especificando a opção - replSet. A seguir está a sintaxe básica de --replSet -

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

Exemplo

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
  • Ele iniciará uma instância mongod com o nome rs0, na porta 27017.

  • Agora inicie o prompt de comando e conecte-se a esta instância do mongod.

  • No cliente Mongo, emita o comando rs.initiate() para iniciar um novo conjunto de réplicas.

  • Para verificar a configuração do conjunto de réplicas, emita o comando rs.conf(). Para verificar o status do conjunto de réplicas, emita o comandors.status().

Adicionar membros ao conjunto de réplicas

Para adicionar membros ao conjunto de réplicas, inicie as instâncias do mongod em várias máquinas. Agora inicie um cliente mongo e emita um comandors.add().

Sintaxe

A sintaxe básica de rs.add() o comando é o seguinte -

>rs.add(HOST_NAME:PORT)

Exemplo

Suponha que o nome da sua instância mongod seja mongod1.net e está funcionando na porta 27017. Para adicionar esta instância ao conjunto de réplicas, emita o comandors.add() no cliente Mongo.

>rs.add("mongod1.net:27017")
>

Você pode adicionar a instância mongod ao conjunto de réplicas apenas quando estiver conectado ao nó primário. Para verificar se você está conectado ao primário ou não, emita o comandodb.isMaster() no cliente mongo.

Sharding é o processo de armazenar registros de dados em várias máquinas e é a abordagem do MongoDB para atender às demandas de crescimento de dados. Conforme o tamanho dos dados aumenta, uma única máquina pode não ser suficiente para armazenar os dados nem fornecer uma taxa de transferência de leitura e gravação aceitável. A fragmentação resolve o problema com a escala horizontal. Com a fragmentação, você adiciona mais máquinas para dar suporte ao crescimento dos dados e às demandas de operações de leitura e gravação.

Por que fragmentar?

  • Na replicação, todas as gravações vão para o nó mestre
  • Consultas sensíveis à latência ainda vão para o mestre
  • O conjunto de réplicas único tem limitação de 12 nós
  • A memória não pode ser grande o suficiente quando o conjunto de dados ativo é grande
  • O disco local não é grande o suficiente
  • A escala vertical é muito cara

Sharding no MongoDB

O diagrama a seguir mostra a fragmentação no MongoDB usando cluster fragmentado.

No diagrama a seguir, existem três componentes principais -

  • Shards- Fragmentos são usados ​​para armazenar dados. Eles fornecem alta disponibilidade e consistência de dados. No ambiente de produção, cada shard é um conjunto de réplicas separado.

  • Config Servers- Os servidores de configuração armazenam os metadados do cluster. Esses dados contêm um mapeamento do conjunto de dados do cluster para os shards. O roteador de consulta usa esses metadados para direcionar operações para fragmentos específicos. No ambiente de produção, os clusters fragmentados têm exatamente 3 servidores de configuração.

  • Query Routers- Os roteadores de consulta são basicamente instâncias mongo, fazem interface com aplicativos cliente e operações diretas para o fragmento apropriado. O roteador de consulta processa e direciona as operações para shards e, em seguida, retorna os resultados para os clientes. Um cluster fragmentado pode conter mais de um roteador de consulta para dividir a carga de solicitação do cliente. Um cliente envia solicitações a um roteador de consulta. Geralmente, um cluster fragmentado tem muitos roteadores de consulta.

Neste capítulo, veremos como criar um backup no MongoDB.

Despejar dados do MongoDB

Para criar backup de banco de dados no MongoDB, você deve usar mongodumpcomando. Este comando irá despejar todos os dados do seu servidor no diretório de despejo. Existem muitas opções disponíveis pelas quais você pode limitar a quantidade de dados ou criar backup de seu servidor remoto.

Sintaxe

A sintaxe básica de mongodump o comando é o seguinte -

>mongodump

Exemplo

Inicie seu servidor mongod. Supondo que seu servidor mongod esteja em execução no host local e na porta 27017, abra um prompt de comando e vá para o diretório bin de sua instância mongodb e digite o comandomongodump

Considere que a coleção mycol tem os seguintes dados.

>mongodump

O comando se conectará ao servidor em execução em 127.0.0.1 e porto 27017 e voltar todos os dados do servidor para o diretório /bin/dump/. A seguir está a saída do comando -

A seguir está uma lista de opções disponíveis que podem ser usadas com o mongodump comando.

Sintaxe Descrição Exemplo
mongodump --host HOST_NAME --port PORT_NUMBER Este comando fará backup de todos os bancos de dados da instância mongod especificada. mongodump --host tutorialspoint.com --port 27017
mongodump --dbpath DB_PATH --out BACKUP_DIRECTORY Este comando fará backup apenas do banco de dados especificado no caminho especificado. mongodump --dbpath / data / db / --out / data / backup /
mongodump --collection COLLECTION --db DB_NAME Este comando fará backup apenas da coleção especificada do banco de dados especificado. mongodump --collection mycol --db test

Restaurar dados

Para restaurar dados de backup do MongoDB mongorestorecomando é usado. Este comando restaura todos os dados do diretório de backup.

Sintaxe

A sintaxe básica de mongorestore comando é -

>mongorestore

A seguir está a saída do comando -

Ao preparar uma implantação do MongoDB, você deve tentar entender como seu aplicativo se manterá na produção. É uma boa ideia desenvolver uma abordagem consistente e repetível para gerenciar seu ambiente de implementação para que você possa minimizar quaisquer surpresas quando estiver em produção.

A melhor abordagem incorpora a criação de protótipos de sua configuração, a realização de testes de carga, o monitoramento das principais métricas e o uso dessas informações para dimensionar sua configuração. A parte principal da abordagem é monitorar proativamente todo o seu sistema - isso o ajudará a entender como seu sistema de produção se manterá antes da implantação e a determinar onde você precisará adicionar capacidade. Ter uma visão dos picos potenciais no uso da memória, por exemplo, pode ajudar a apagar um incêndio de bloqueio de gravação antes de começar.

Para monitorar sua implantação, o MongoDB fornece alguns dos seguintes comandos -

Mongostat

Este comando verifica o status de todas as instâncias mongod em execução e retorna contadores de operações de banco de dados. Esses contadores incluem inserções, consultas, atualizações, exclusões e cursores. O comando também mostra quando você está atingindo falhas de página e mostra sua porcentagem de bloqueio. Isso significa que você está com pouca memória, atingindo a capacidade de gravação ou tem algum problema de desempenho.

Para executar o comando, inicie sua instância mongod. Em outro prompt de comando, vá parabin diretório de sua instalação mongodb e tipo mongostat.

D:\set up\mongodb\bin>mongostat

A seguir está a saída do comando -

Mongotop

Este comando rastreia e relata a atividade de leitura e gravação da instância do MongoDB em uma base de coleta. Por padrão,mongotopretorna informações a cada segundo, que você pode alterar de acordo. Você deve verificar se essa atividade de leitura e gravação corresponde à intenção do seu aplicativo e não está disparando muitas gravações no banco de dados por vez, lendo com muita frequência de um disco ou excedendo o tamanho do conjunto de trabalho.

Para executar o comando, inicie sua instância mongod. Em outro prompt de comando, vá parabin diretório de sua instalação mongodb e tipo mongotop.

D:\set up\mongodb\bin>mongotop

A seguir está a saída do comando -

Mudar mongotop comando para retornar informações com menos freqüência, especifique um número específico após o comando mongotop.

D:\set up\mongodb\bin>mongotop 30

O exemplo acima retornará valores a cada 30 segundos.

Além das ferramentas do MongoDB, a 10gen fornece um serviço de monitoramento hospedado gratuito, o MongoDB Management Service (MMS), que fornece um painel e oferece uma visão das métricas de todo o cluster.

Neste capítulo, aprenderemos como configurar o driver JDBC MongoDB.

Instalação

Antes de começar a usar o MongoDB em seus programas Java, você precisa ter certeza de ter o driver JDBC do MongoDB e o Java configurados na máquina. Você pode verificar o tutorial Java para instalação do Java em sua máquina. Agora, vamos verificar como configurar o driver JDBC do MongoDB.

  • Você precisa baixar o jar do caminho Download mongo.jar . Certifique-se de baixar a versão mais recente dele.

  • Você precisa incluir o mongo.jar em seu caminho de classe.

Conectar ao banco de dados

Para conectar o banco de dados, você precisa especificar o nome do banco de dados; se o banco de dados não existir, o MongoDB o criará automaticamente.

A seguir está o snippet de código para se conectar ao banco de dados -

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ConnectToDB { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
   
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Credentials ::"+ credential);     
   } 
}

Agora, vamos compilar e executar o programa acima para criar nosso banco de dados myDb conforme mostrado abaixo.

$javac ConnectToDB.java 
$java ConnectToDB

Ao ser executado, o programa acima fornece a seguinte saída.

Connected to the database successfully 
Credentials ::MongoCredential{
   mechanism = null, 
   userName = 'sampleUser', 
   source = 'myDb', 
   password = <hidden>, 
   mechanismProperties = {}
}

Crie uma coleção

Para criar uma coleção, createCollection() método de com.mongodb.client.MongoDatabase classe é usada.

A seguir está o snippet de código para criar uma coleção -

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class CreatingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      //Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      //Creating a collection 
      database.createCollection("sampleCollection"); 
      System.out.println("Collection created successfully"); 
   } 
}

Na compilação, o programa acima fornece o seguinte resultado -

Connected to the database successfully 
Collection created successfully

Obtendo / Selecionando uma Coleção

Para obter / selecionar uma coleção do banco de dados, getCollection() método de com.mongodb.client.MongoDatabase classe é usada.

A seguir está o programa para obter / selecionar uma coleção -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class selectingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collection created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("myCollection"); 
      System.out.println("Collection myCollection selected successfully"); 
   }
}

Na compilação, o programa acima fornece o seguinte resultado -

Connected to the database successfully 
Collection created successfully 
Collection myCollection selected successfully

Insira um Documento

Para inserir um documento no MongoDB, insert() método de com.mongodb.client.MongoCollection classe é usada.

A seguir está o snippet de código para inserir um documento -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class InsertingDocument { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection"); 
      System.out.println("Collection sampleCollection selected successfully");

      Document document = new Document("title", "MongoDB") 
      .append("id", 1)
      .append("description", "database") 
      .append("likes", 100) 
      .append("url", "http://www.tutorialspoint.com/mongodb/") 
      .append("by", "tutorials point");  
      collection.insertOne(document); 
      System.out.println("Document inserted successfully");     
   } 
}

Na compilação, o programa acima fornece o seguinte resultado -

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document inserted successfully

Recuperar todos os documentos

Para selecionar todos os documentos da coleção, find() método de com.mongodb.client.MongoCollectionclasse é usada. Este método retorna um cursor, portanto, você precisa iterar este cursor.

A seguir está o programa para selecionar todos os documentos -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class RetrievingAllDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential;
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 
    
      while (it.hasNext()) {  
         System.out.println(it.next());  
      i++; 
      }
   } 
}

Na compilação, o programa acima fornece o seguinte resultado -

Document{{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 100, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}  
Document{{
   _id = 7452239959673a32646baab8, 
   title = RethinkDB, 
   id = 2, 
   description = database, 
   likes = 200, 
   url = http://www.tutorialspoint.com/rethinkdb/, by = tutorials point
}}

Documento de atualização

Para atualizar um documento da coleção, updateOne() método de com.mongodb.client.MongoCollection classe é usada.

A seguir está o programa para selecionar o primeiro documento -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters; 
import com.mongodb.client.model.Updates; 

import java.util.Iterator; 
import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class UpdatingDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection myCollection selected successfully"); 

      collection.updateOne(Filters.eq("id", 1), Updates.set("likes", 150));       
      System.out.println("Document update successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println(it.next());  
         i++; 
      }     
   }  
}

Na compilação, o programa acima fornece o seguinte resultado -

Document update successfully... 
Document {{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 150, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}

Apagar um Documento

Para excluir um documento da coleção, você precisa usar o deleteOne() método do com.mongodb.client.MongoCollection classe.

A seguir está o programa para excluir um documento -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DeletingDocuments { 
   
   public static void main( String args[] ) {  
   
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 );
      
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Deleting the documents 
      collection.deleteOne(Filters.eq("id", 1)); 
      System.out.println("Document deleted successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println("Inserted Document: "+i);  
         System.out.println(it.next());  
         i++; 
      }       
   } 
}

Na compilação, o programa acima fornece o seguinte resultado -

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document deleted successfully...

Descartando uma coleção

Para eliminar uma coleção de um banco de dados, você precisa usar o drop() método do com.mongodb.client.MongoCollection classe.

A seguir está o programa para excluir uma coleção -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DropingCollection { 
   
   public static void main( String args[] ) {  

      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collections created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");

      // Dropping a Collection 
      collection.drop(); 
      System.out.println("Collection dropped successfully");
   } 
}

Na compilação, o programa acima fornece o seguinte resultado -

Connected to the database successfully 
Collection sampleCollection selected successfully 
Collection dropped successfully

Listando todas as coleções

Para listar todas as coleções em um banco de dados, você precisa usar o listCollectionNames() método do com.mongodb.client.MongoDatabase classe.

A seguir está o programa para listar todas as coleções de um banco de dados -

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ListOfCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 

      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Collection created successfully"); 
      for (String name : database.listCollectionNames()) { 
         System.out.println(name); 
      } 
   }
}

Na compilação, o programa acima fornece o seguinte resultado -

Connected to the database successfully 
Collection created successfully 
myCollection 
myCollection1 
myCollection5

Métodos MongoDB restantes save(), limit(), skip(), sort() etc. funcionam como explicado no tutorial subsequente.

Para usar o MongoDB com PHP, você precisa usar o driver MongoDB PHP. Baixe o driver do url Baixe o driver PHP . Certifique-se de baixar a versão mais recente dele. Agora descompacte o arquivo e coloque php_mongo.dll em seu diretório de extensão PHP ("ext" por padrão) e adicione a seguinte linha ao seu arquivo php.ini -

extension = php_mongo.dll

Faça uma conexão e selecione um banco de dados

Para fazer uma conexão, você precisa especificar o nome do banco de dados; se o banco de dados não existir, o MongoDB o criará automaticamente.

A seguir está o snippet de código para se conectar ao banco de dados -

<?php
   // connect to mongodb
   $m = new MongoClient();
	
   echo "Connection to database successfully";
   // select a database
   $db = $m->mydb;
	
   echo "Database mydb selected";
?>

Quando o programa for executado, ele produzirá o seguinte resultado -

Connection to database successfully
Database mydb selected

Crie uma coleção

A seguir está o snippet de código para criar uma coleção -

<?php
   // connect to mongodb
   $m = new MongoClient(); echo "Connection to database successfully"; // select a database $db = $m->mydb; echo "Database mydb selected"; $collection = $db->createCollection("mycol");
   echo "Collection created succsessfully";
?>

Quando o programa for executado, ele produzirá o seguinte resultado -

Connection to database successfully
Database mydb selected
Collection created succsessfully

Insira um Documento

Para inserir um documento no MongoDB, insert() método é usado.

A seguir está o snippet de código para inserir um documento -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
	
   $document = array( "title" => "MongoDB", "description" => "database", "likes" => 100, "url" => "http://www.tutorialspoint.com/mongodb/", "by" => "tutorials point" ); $collection->insert($document);
   echo "Document inserted successfully";
?>

Quando o programa for executado, ele produzirá o seguinte resultado -

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document inserted successfully

Encontre todos os documentos

Para selecionar todos os documentos da coleção, o método find () é usado.

A seguir está o snippet de código para selecionar todos os documentos -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   $cursor = $collection->find();
   // iterate cursor to display title of documents
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

Quando o programa for executado, ele produzirá o seguinte resultado -

Connection to database successfully
Database mydb selected
Collection selected succsessfully {
   "title": "MongoDB"
}

Atualizar um Documento

Para atualizar um documento, você precisa usar o método update ().

No exemplo a seguir, vamos atualizar o título do documento inserido para MongoDB Tutorial. A seguir está o snippet de código para atualizar um documento -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   // now update the document
   $collection->update(array("title"=>"MongoDB"), array('$set'=>array("title"=>"MongoDB Tutorial")));
   echo "Document updated successfully";
	
   // now display the updated document
   $cursor = $collection->find();
	
   // iterate cursor to display title of documents
   echo "Updated document";
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

Quando o programa for executado, ele produzirá o seguinte resultado -

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document updated successfully
Updated document {
   "title": "MongoDB Tutorial"
}

Apagar um Documento

Para excluir um documento, você precisa usar o método remove ().

No exemplo a seguir, removeremos os documentos que possuem o título MongoDB Tutorial. A seguir está o snippet de código para excluir um documento -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
   
   // now remove the document
   $collection->remove(array("title"=>"MongoDB Tutorial"),false); echo "Documents deleted successfully"; // now display the available documents $cursor = $collection->find(); // iterate cursor to display title of documents echo "Updated document"; foreach ($cursor as $document) { echo $document["title"] . "\n";
   }
?>

Quando o programa for executado, ele produzirá o seguinte resultado -

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Documents deleted successfully

No exemplo acima, o segundo parâmetro é do tipo booleano e usado para justOne Campo de remove() método.

Métodos MongoDB restantes findOne(), save(), limit(), skip(), sort() etc. funciona como explicado acima.

Os relacionamentos no MongoDB representam como vários documentos estão logicamente relacionados entre si. Relacionamentos podem ser modelados viaEmbedded e Referencedabordagens. Essas relações podem ser 1: 1, 1: N, N: 1 ou N: N.

Vamos considerar o caso de armazenamento de endereços para usuários. Portanto, um usuário pode ter vários endereços, tornando este um relacionamento 1: N.

A seguir está o exemplo de estrutura de documento de user documento -

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "name": "Tom Hanks",
   "contact": "987654321",
   "dob": "01-01-1991"
}

A seguir está o exemplo de estrutura de documento de address documento -

{
   "_id":ObjectId("52ffc4a5d85242602e000000"),
   "building": "22 A, Indiana Apt",
   "pincode": 123456,
   "city": "Los Angeles",
   "state": "California"
}

Modelando Relacionamentos Embutidos

Na abordagem embutida, iremos embutir o documento de endereço dentro do documento do usuário.

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address": [
      {
         "building": "22 A, Indiana Apt",
         "pincode": 123456,
         "city": "Los Angeles",
         "state": "California"
      },
      {
         "building": "170 A, Acropolis Apt",
         "pincode": 456789,
         "city": "Chicago",
         "state": "Illinois"
      }
   ]
}

Essa abordagem mantém todos os dados relacionados em um único documento, o que facilita a recuperação e a manutenção. Todo o documento pode ser recuperado em uma única consulta, como -

>db.users.findOne({"name":"Tom Benzamin"},{"address":1})

Observe que na consulta acima, db e users são o banco de dados e a coleção, respectivamente.

A desvantagem é que, se o documento incorporado continuar crescendo muito, pode afetar o desempenho de leitura / gravação.

Modelagem de Relacionamentos Referenciados

Esta é a abordagem para projetar relacionamento normalizado. Nesta abordagem, os documentos de usuário e endereço serão mantidos separadamente, mas o documento do usuário conterá um campo que fará referência ao documento de endereçoid campo.

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc4a5d85242602e000000"),
      ObjectId("52ffc4a5d85242602e000001")
   ]
}

Conforme mostrado acima, o documento do usuário contém o campo array address_idsque contém ObjectIds de endereços correspondentes. Usando esses ObjectIds, podemos consultar os documentos de endereço e obter detalhes de endereço a partir deles. Com esta abordagem, precisaremos de duas consultas: primeiro, para buscar oaddress_ids campos de user documento e segundo para buscar esses endereços de address coleção.

>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})

Como visto no último capítulo de relacionamentos do MongoDB, para implementar uma estrutura de banco de dados normalizada no MongoDB, usamos o conceito de Referenced Relationships também conhecido como Manual Referencesno qual armazenamos manualmente o id do documento referenciado dentro de outro documento. No entanto, nos casos em que um documento contém referências de coleções diferentes, podemos usarMongoDB DBRefs.

DBRefs vs referências manuais

Como um cenário de exemplo, onde usaríamos DBRefs em vez de referências manuais, considere um banco de dados onde estamos armazenando diferentes tipos de endereços (casa, escritório, correspondência, etc.) em coleções diferentes (endereço_home, endereço_escritório, endereço_mailing, etc). Agora, quando umuserO documento da coleção faz referência a um endereço, ele também precisa especificar qual coleção procurar com base no tipo de endereço. Em tais cenários onde um documento faz referência a documentos de muitas coleções, devemos usar DBRefs.

Usando DBRefs

Existem três campos em DBRefs -

  • $ref - Este campo especifica a coleção do documento referenciado

  • $id - Este campo especifica o campo _id do documento referenciado

  • $db - Este é um campo opcional e contém o nome do banco de dados em que o documento referenciado se encontra

Considere um exemplo de documento do usuário com o campo DBRef address conforme mostrado no snippet de código -

{
   "_id":ObjectId("53402597d852426020000002"),
   "address": {
   "$ref": "address_home", "$id": ObjectId("534009e4d852427820000002"),
   "$db": "tutorialspoint"},
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin"
}

o address O campo DBRef aqui especifica que o documento de endereço referenciado está em address_home coleção sob tutorialspoint banco de dados e tem um id de 534009e4d852427820000002.

O código a seguir procura dinamicamente na coleção especificada por $ref parâmetro (address_home no nosso caso) para um documento com id conforme especificado por $id parâmetro em DBRef.

>var user = db.users.findOne({"name":"Tom Benzamin"})
>var dbRef = user.address
>db[dbRef.$ref].findOne({"_id":(dbRef.$id)})

O código acima retorna o seguinte documento de endereço presente em address_home coleção -

{
   "_id" : ObjectId("534009e4d852427820000002"),
   "building" : "22 A, Indiana Apt",
   "pincode" : 123456,
   "city" : "Los Angeles",
   "state" : "California"
}

Neste capítulo, aprenderemos sobre as consultas cobertas.

O que é uma consulta coberta?

De acordo com a documentação oficial do MongoDB, uma consulta coberta é uma consulta na qual -

  • Todos os campos da consulta fazem parte de um índice.
  • Todos os campos retornados na consulta estão no mesmo índice.

Como todos os campos presentes na consulta fazem parte de um índice, o MongoDB corresponde às condições da consulta e retorna o resultado usando o mesmo índice, sem realmente olhar dentro dos documentos. Como os índices estão presentes na RAM, a busca de dados de índices é muito mais rápida em comparação com a busca de dados por digitalização de documentos.

Usando consultas cobertas

Para testar as consultas cobertas, considere o seguinte documento no users coleção -

{
   "_id": ObjectId("53402597d852426020000002"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "gender": "M",
   "name": "Tom Benzamin",
   "user_name": "tombenzamin"
}

Vamos primeiro criar um índice composto para o users coleção nos campos gender e user_name usando a seguinte consulta -

>db.users.ensureIndex({gender:1,user_name:1})

Agora, este índice cobrirá a seguinte consulta -

>db.users.find({gender:"M"},{user_name:1,_id:0})

Isso quer dizer que para a consulta acima, o MongoDB não iria procurar nos documentos do banco de dados. Em vez disso, ele buscaria os dados necessários de dados indexados, o que é muito rápido.

Como nosso índice não inclui _id, nós o excluímos explicitamente do conjunto de resultados de nossa consulta, pois o MongoDB, por padrão, retorna o campo _id em cada consulta. Portanto, a seguinte consulta não teria sido coberta dentro do índice criado acima -

>db.users.find({gender:"M"},{user_name:1})

Por último, lembre-se de que um índice não pode cobrir uma consulta se -

  • Qualquer um dos campos indexados é uma matriz
  • Qualquer um dos campos indexados é um subdocumento

A análise de consultas é um aspecto muito importante para medir a eficácia do design do banco de dados e da indexação. Vamos aprender sobre os usados ​​com freqüência$explain e $hint consultas.

Usando $ explain

o $explainoperador fornece informações sobre a consulta, índices usados ​​em uma consulta e outras estatísticas. É muito útil ao analisar como seus índices são otimizados.

No último capítulo, já havíamos criado um índice para o users coleção em campos gender e user_name usando a seguinte consulta -

>db.users.ensureIndex({gender:1,user_name:1})

Agora vamos usar $explain na seguinte consulta -

>db.users.find({gender:"M"},{user_name:1,_id:0}).explain()

A consulta explain () acima retorna o seguinte resultado analisado -

{
   "cursor" : "BtreeCursor gender_1_user_name_1",
   "isMultiKey" : false,
   "n" : 1,
   "nscannedObjects" : 0,
   "nscanned" : 1,
   "nscannedObjectsAllPlans" : 0,
   "nscannedAllPlans" : 1,
   "scanAndOrder" : false,
   "indexOnly" : true,
   "nYields" : 0,
   "nChunkSkips" : 0,
   "millis" : 0,
   "indexBounds" : {
      "gender" : [
         [
            "M",
            "M"
         ]
      ],
      "user_name" : [
         [
            {
               "$minElement" : 1 }, { "$maxElement" : 1
            }
         ]
      ]
   }
}

Vamos agora olhar para os campos neste conjunto de resultados -

  • O verdadeiro valor de indexOnly indica que esta consulta usou indexação.

  • o cursorcampo especifica o tipo de cursor usado. O tipo BTreeCursor indica que um índice foi usado e também fornece o nome do índice usado. BasicCursor indica que uma varredura completa foi feita sem usar nenhum índice.

  • n indica o número de documentos correspondentes retornados.

  • nscannedObjects indica o número total de documentos digitalizados.

  • nscanned indica o número total de documentos ou entradas de índice digitalizadas.

Usando $ hint

o $hintoperador força o otimizador de consulta a usar o índice especificado para executar uma consulta. Isso é particularmente útil quando você deseja testar o desempenho de uma consulta com índices diferentes. Por exemplo, a consulta a seguir especifica o índice nos camposgender e user_name a ser usado para esta consulta -

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})

Para analisar a consulta acima usando $ explain -

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1}).explain()

Dados de modelo para operações atômicas

A abordagem recomendada para manter a atomicidade seria manter todas as informações relacionadas, que são frequentemente atualizadas juntas em um único documento usando embedded documents. Isso garantiria que todas as atualizações de um único documento fossem atômicas.

Considere o seguinte documento de produtos -

{
   "_id":1,
   "product_name": "Samsung S3",
   "category": "mobiles",
   "product_total": 5,
   "product_available": 3,
   "product_bought_by": [
      {
         "customer": "john",
         "date": "7-Jan-2014"
      },
      {
         "customer": "mark",
         "date": "8-Jan-2014"
      }
   ]
}

Neste documento, incorporamos as informações do cliente que compra o produto no product_bought_bycampo. Agora, sempre que um novo cliente comprar o produto, primeiro verificaremos se o produto ainda está disponível usandoproduct_availablecampo. Se disponível, reduziremos o valor do campo product_available, bem como inseriremos o novo documento incorporado do cliente no campo product_bought_by. Nós vamos usarfindAndModify comando para esta funcionalidade porque pesquisa e atualiza o documento ao mesmo tempo.

>db.products.findAndModify({ 
   query:{_id:2,product_available:{$gt:0}}, 
   update:{ 
      $inc:{product_available:-1}, $push:{product_bought_by:{customer:"rob",date:"9-Jan-2014"}} 
   }    
})

Nossa abordagem de documento incorporado e usando a consulta findAndModify garante que as informações de compra do produto sejam atualizadas apenas se o produto estiver disponível. E toda essa transação estando na mesma consulta, é atômica.

Em contraste com isso, considere o cenário em que podemos ter mantido a disponibilidade do produto e as informações sobre quem comprou o produto, separadamente. Nesse caso, primeiro verificaremos se o produto está disponível usando a primeira consulta. Então, na segunda consulta, vamos atualizar as informações de compra. Porém, é possível que entre as execuções dessas duas consultas, algum outro usuário tenha adquirido o produto e ele não esteja mais disponível. Sem saber disso, nossa segunda consulta atualizará as informações de compra com base no resultado de nossa primeira consulta. Isso tornará o banco de dados inconsistente porque vendemos um produto que não está disponível.

Considere o seguinte documento do users coleção -

{
   "address": {
      "city": "Los Angeles",
      "state": "California",
      "pincode": "123"
   },
   "tags": [
      "music",
      "cricket",
      "blogs"
   ],
   "name": "Tom Benzamin"
}

O documento acima contém um address sub-document e um tags array.

Campos de matriz de indexação

Suponha que desejamos pesquisar documentos do usuário com base nas tags do usuário. Para isso, vamos criar um índice no array de tags da coleção.

A criação de um índice na matriz, por sua vez, cria entradas de índice separadas para cada um de seus campos. Portanto, em nosso caso, quando criamos um índice na matriz de tags, índices separados serão criados para seus valores music, cricket e blogs.

Para criar um índice na matriz de tags, use o seguinte código -

>db.users.ensureIndex({"tags":1})

Depois de criar o índice, podemos pesquisar no campo de tags da coleção assim -

>db.users.find({tags:"cricket"})

Para verificar se a indexação adequada é usada, use o seguinte explain comando -

>db.users.find({tags:"cricket"}).explain()

O comando acima resultou em "cursor": "BtreeCursor tags_1" que confirma que a indexação adequada é usada.

Indexando campos de subdocumento

Suponha que desejamos pesquisar documentos com base nos campos de cidade, estado e código PIN. Como todos esses campos fazem parte do campo do subdocumento de endereço, criaremos um índice em todos os campos do subdocumento.

Para criar um índice em todos os três campos do subdocumento, use o seguinte código -

>db.users.ensureIndex({"address.city":1,"address.state":1,"address.pincode":1})

Uma vez que o índice é criado, podemos pesquisar qualquer um dos campos do sub-documento utilizando este índice da seguinte maneira -

>db.users.find({"address.city":"Los Angeles"})

Lembre-se de que a expressão da consulta deve seguir a ordem do índice especificado. Portanto, o índice criado acima suportaria as seguintes consultas -

>db.users.find({"address.city":"Los Angeles","address.state":"California"})

Também suportará a seguinte consulta -

>db.users.find({"address.city":"LosAngeles","address.state":"California",
   "address.pincode":"123"})

Neste capítulo, aprenderemos sobre as limitações de indexação e seus outros componentes.

Extra Overhead

Cada índice ocupa algum espaço e também causa uma sobrecarga em cada inserção, atualização e exclusão. Portanto, se você raramente usa sua coleção para operações de leitura, faz sentido não usar índices.

Uso de RAM

Como os índices são armazenados na RAM, você deve se certificar de que o tamanho total do índice não exceda o limite da RAM. Se o tamanho total aumentar o tamanho da RAM, ele começará a excluir alguns índices, causando perda de desempenho.

Limitações de consulta

A indexação não pode ser usada em consultas que usam -

  • Expressões regulares ou operadores de negação como $nin, $não, etc.
  • Operadores aritméticos como $ mod, etc.
  • cláusula $ where

Portanto, é sempre aconselhável verificar o uso do índice para suas consultas.

Limites de chave de índice

A partir da versão 2.6, o MongoDB não criará um índice se o valor do campo de índice existente exceder o limite da chave do índice.

Inserindo documentos que excedem o limite da chave do índice

O MongoDB não inserirá nenhum documento em uma coleção indexada se o valor do campo indexado deste documento exceder o limite da chave de índice. O mesmo acontece com os utilitários mongorestore e mongoimport.

Faixas máximas

  • Uma coleção não pode ter mais de 64 índices.
  • O comprimento do nome do índice não pode ser maior que 125 caracteres.
  • Um índice composto pode ter no máximo 31 campos indexados.

Temos usado o Id de objeto do MongoDB em todos os capítulos anteriores. Neste capítulo, vamos entender a estrutura de ObjectId.

A ObjectId é um tipo BSON de 12 bytes com a seguinte estrutura -

  • Os primeiros 4 bytes que representam os segundos desde a época unix
  • Os próximos 3 bytes são o identificador da máquina
  • Os próximos 2 bytes consistem em process id
  • Os últimos 3 bytes são um valor de contador aleatório

MongoDB usa ObjectIds como o valor padrão de _idcampo de cada documento, que é gerado durante a criação de qualquer documento. A combinação complexa de ObjectId torna todos os campos _id únicos.

Criando Novo ObjectId

Para gerar um novo ObjectId, use o seguinte código -

>newObjectId = ObjectId()

A instrução acima retornou o seguinte id gerado exclusivamente -

ObjectId("5349b4ddd2781d08c09890f3")

Em vez de MongoDB gerar o ObjectId, você também pode fornecer uma id de 12 bytes -

>myObjectId = ObjectId("5349b4ddd2781d08c09890f4")

Criação de carimbo de data / hora de um documento

Como o _id ObjectId por padrão armazena o carimbo de data / hora de 4 bytes, na maioria dos casos você não precisa armazenar o horário de criação de nenhum documento. Você pode buscar a hora de criação de um documento usando o método getTimestamp -

>ObjectId("5349b4ddd2781d08c09890f4").getTimestamp()

Isso retornará a hora de criação deste documento no formato de data ISO -

ISODate("2014-04-12T21:49:17Z")

Convertendo ObjectId em String

Em alguns casos, você pode precisar do valor de ObjectId em um formato de string. Para converter ObjectId em string, use o seguinte código -

>newObjectId.str

O código acima retornará o formato da string do Guid -

5349b4ddd2781d08c09890f3

De acordo com a documentação do MongoDB, Map-reduceé um paradigma de processamento de dados para condensar grandes volumes de dados em resultados agregados úteis. MongoDB usamapReducecomando para operações de redução de mapa. MapReduce é geralmente usado para processar grandes conjuntos de dados.

Comando MapReduce

A seguir está a sintaxe do comando mapReduce básico -

>db.collection.mapReduce(
   function() {emit(key,value);},  //map function
   function(key,values) {return reduceFunction}, {   //reduce function
      out: collection,
      query: document,
      sort: document,
      limit: number
   }
)

A função de redução de mapa primeiro consulta a coleção e, em seguida, mapeia os documentos de resultado para emitir pares de valores-chave, que são então reduzidos com base nas chaves que têm vários valores.

Na sintaxe acima -

  • map é uma função javascript que mapeia um valor com uma chave e emite um par de valor-chave

  • reduce é uma função javascript que reduz ou agrupa todos os documentos com a mesma chave

  • out especifica a localização do resultado da consulta de redução de mapa

  • query especifica os critérios de seleção opcionais para a seleção de documentos

  • sort especifica os critérios de classificação opcionais

  • limit especifica o número máximo opcional de documentos a serem retornados

Usando MapReduce

Considere a seguinte estrutura de documento, armazenando postagens de usuários. O documento armazena user_name do usuário e o status da postagem.

{
   "post_text": "tutorialspoint is an awesome website for tutorials",
   "user_name": "mark",
   "status":"active"
}

Agora, vamos usar uma função mapReduce em nosso posts coleção para selecionar todas as postagens ativas, agrupá-las com base em user_name e, em seguida, contar o número de postagens de cada usuário usando o seguinte código -

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
	
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
)

A consulta mapReduce acima produz o seguinte resultado -

{
   "result" : "post_total",
   "timeMillis" : 9,
   "counts" : {
      "input" : 4,
      "emit" : 4,
      "reduce" : 2,
      "output" : 2
   },
   "ok" : 1,
}

O resultado mostra que um total de 4 documentos corresponderam à consulta (status: "ativo"), a função de mapa emitiu 4 documentos com pares de chave-valor e, finalmente, a função de redução agrupou documentos mapeados com as mesmas chaves em 2.

Para ver o resultado desta consulta mapReduce, use o operador find -

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
	
).find()

A consulta acima fornece o seguinte resultado que indica que ambos os usuários tom e mark tem duas postagens em estados ativos -

{ "_id" : "tom", "value" : 2 }
{ "_id" : "mark", "value" : 2 }

De maneira semelhante, as consultas MapReduce podem ser usadas para construir grandes consultas de agregação complexas. O uso de funções Javascript personalizadas faz uso do MapReduce, que é muito flexível e poderoso.

A partir da versão 2.4, o MongoDB passou a oferecer suporte a índices de texto para pesquisar dentro do conteúdo da string. oText Search usa técnicas de lematização para procurar palavras especificadas nos campos de string, eliminando palavras de interrupção de lematização, como a, an, the, etc. Atualmente, o MongoDB oferece suporte a cerca de 15 idiomas.

Habilitando Pesquisa de Texto

Inicialmente, a Pesquisa de texto era um recurso experimental, mas a partir da versão 2.6, a configuração é habilitada por padrão. Mas se você estiver usando a versão anterior do MongoDB, deverá habilitar a pesquisa de texto com o seguinte código -

>db.adminCommand({setParameter:true,textSearchEnabled:true})

Criação de índice de texto

Considere o seguinte documento em posts coleção contendo o texto da postagem e suas tags -

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

Vamos criar um índice de texto no campo post_text para que possamos pesquisar dentro do texto de nossas postagens -

>db.posts.ensureIndex({post_text:"text"})

Usando o Índice de Texto

Agora que criamos o índice de texto no campo post_text, vamos pesquisar por todos os posts que contêm a palavra tutorialspoint em seu texto.

>db.posts.find({$text:{$search:"tutorialspoint"}})

O comando acima retornou os seguintes documentos de resultado com a palavra tutorialspoint no texto da postagem -

{ 
   "_id" : ObjectId("53493d14d852429c10000002"), 
   "post_text" : "enjoy the mongodb articles on tutorialspoint", 
   "tags" : [ "mongodb", "tutorialspoint" ]
}
{
   "_id" : ObjectId("53493d1fd852429c10000003"), 
   "post_text" : "writing tutorials on mongodb",
   "tags" : [ "mongodb", "tutorial" ] 
}

Se você estiver usando versões antigas do MongoDB, terá que usar o seguinte comando -

>db.posts.runCommand("text",{search:" tutorialspoint "})

O uso da Pesquisa de texto melhora muito a eficiência da pesquisa em comparação à pesquisa normal.

Excluindo Índice de Texto

Para excluir um índice de texto existente, primeiro encontre o nome do índice usando a seguinte consulta -

>db.posts.getIndexes()

Depois de obter o nome do seu índice da consulta acima, execute o seguinte comando. Aqui,post_text_text é o nome do índice.

>db.posts.dropIndex("post_text_text")

Expressões regulares são freqüentemente usadas em todos os idiomas para pesquisar um padrão ou palavra em qualquer string. O MongoDB também fornece funcionalidade de expressão regular para correspondência de padrões de string usando o$regexoperador. MongoDB usa PCRE (Perl Compatible Regular Expression) como linguagem de expressão regular.

Ao contrário da pesquisa de texto, não precisamos fazer nenhuma configuração ou comando para usar expressões regulares.

Considere a seguinte estrutura de documento em posts coleção contendo o texto da postagem e suas tags -

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

Usando expressão regex

A seguinte consulta regex procura por todos os posts contendo string tutorialspoint nele -

>db.posts.find({post_text:{$regex:"tutorialspoint"}})

A mesma consulta também pode ser escrita como -

>db.posts.find({post_text:/tutorialspoint/})

Usando expressão regex com diferenciação de maiúsculas e minúsculas

Para tornar a pesquisa insensível a maiúsculas e minúsculas, usamos o $options parâmetro com valor $i. O seguinte comando irá procurar por strings com a palavratutorialspoint, independentemente do caso menor ou capital -

>db.posts.find({post_text:{$regex:"tutorialspoint",$options:"$i"}})

Um dos resultados retornados desta consulta é o seguinte documento que contém a palavra tutorialspoint em casos diferentes -

{
   "_id" : ObjectId("53493d37d852429c10000004"),
   "post_text" : "hey! this is my post on TutorialsPoint", 
   "tags" : [ "tutorialspoint" ]
}

Usando regex para elementos de matriz

Também podemos usar o conceito de regex no campo array. Isso é particularmente importante quando implementamos a funcionalidade de tags. Portanto, se você deseja pesquisar todos os posts que têm tags começando com a palavra tutorial (tanto tutorial ou tutoriais ou tutorialpoint ou tutorialphp), você pode usar o seguinte código -

>db.posts.find({tags:{$regex:"tutorial"}})

Otimizando Consultas de Expressão Regular

  • Se os campos do documento forem indexed, a consulta usará valores indexados para corresponder à expressão regular. Isso torna a pesquisa muito rápida em comparação com a expressão regular que examina a coleção inteira.

  • Se a expressão regular for um prefix expression, todas as correspondências devem começar com certos caracteres de string. Por exemplo, se a expressão regex é^tut, então a consulta deve procurar apenas as strings que começam com tut.

RockMongo é uma ferramenta de administração do MongoDB com a qual você pode gerenciar seu servidor, bancos de dados, coleções, documentos, índices e muito mais. Ele fornece uma maneira muito fácil de ler, escrever e criar documentos. É semelhante à ferramenta PHPMyAdmin para PHP e MySQL.

Baixando RockMongo

Você pode baixar a última versão do RockMongo aqui: https://github.com/iwind/rockmongo

Instalando RockMongo

Depois de baixado, você pode descompactar o pacote na pasta raiz do servidor e renomear a pasta extraída para rockmongo. Abra qualquer navegador da web e acesse oindex.phppágina da pasta rockmongo. Digite admin / admin como nome de usuário / senha respectivamente.

Trabalhando com RockMongo

Agora veremos algumas operações básicas que você pode realizar com o RockMongo.

Criando Novo Banco de Dados

Para criar um novo banco de dados, clique Databasesaba. CliqueCreate New Database. Na próxima tela, forneça o nome do novo banco de dados e clique emCreate. Você verá um novo banco de dados sendo adicionado no painel esquerdo.

Criando nova coleção

Para criar uma nova coleção dentro de um banco de dados, clique no banco de dados no painel esquerdo. Clique noNew Collectionlink no topo. Forneça o nome obrigatório da coleção. Não se preocupe com os outros campos de Is Capped, Size e Max. Clique emCreate. Uma nova coleção será criada e você poderá vê-la no painel esquerdo.

Criando Novo Documento

Para criar um novo documento, clique na coleção na qual deseja adicionar documentos. Ao clicar em uma coleção, você poderá ver todos os documentos dessa coleção listados ali. Para criar um novo documento, clique noInsertlink no topo. Você pode inserir os dados do documento em formato JSON ou array e clicar emSave.

Exportar / importar dados

Para importar / exportar dados de qualquer coleção, clique na coleção e, em seguida, clique em Export/Importlink no painel superior. Siga as próximas instruções para exportar seus dados em um formato zip e, em seguida, importe o mesmo arquivo zip para importar os dados de volta.

GridFSé a especificação do MongoDB para armazenar e recuperar arquivos grandes, como imagens, arquivos de áudio, arquivos de vídeo, etc. É uma espécie de sistema de arquivos para armazenar arquivos, mas seus dados são armazenados nas coleções do MongoDB. O GridFS tem a capacidade de armazenar arquivos ainda maiores do que seu limite de tamanho de documento de 16 MB.

GridFS divide um arquivo em blocos e armazena cada bloco de dados em um documento separado, cada um com tamanho máximo de 255k.

GridFS por padrão usa duas coleções fs.files e fs.chunkspara armazenar os metadados do arquivo e os pedaços. Cada pedaço é identificado por seu campo _id ObjectId exclusivo. O fs.files serve como um documento pai. ofiles_id campo no documento fs.chunks vincula o trecho a seu pai.

A seguir está um documento de amostra da coleção fs.files -

{
   "filename": "test.txt",
   "chunkSize": NumberInt(261120),
   "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
   "md5": "7b762939321e146569b07f72c62cca4f",
   "length": NumberInt(646)
}

O documento especifica o nome do arquivo, o tamanho do bloco, a data de upload e o comprimento.

A seguir está um documento de amostra do documento fs.chunks -

{
   "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
   "n": NumberInt(0),
   "data": "Mongo Binary Data"
}

Adicionando arquivos ao GridFS

Agora, vamos armazenar um arquivo mp3 usando GridFS usando o putcomando. Para isso, vamos usar omongofiles.exe utilitário presente na pasta bin da pasta de instalação do MongoDB.

Abra seu prompt de comando, navegue até mongofiles.exe na pasta bin da pasta de instalação do MongoDB e digite o seguinte código -

>mongofiles.exe -d gridfs put song.mp3

Aqui, gridfsé o nome do banco de dados no qual o arquivo será armazenado. Se o banco de dados não estiver presente, o MongoDB criará automaticamente um novo documento na hora. Song.mp3 é o nome do arquivo carregado. Para ver o documento do arquivo no banco de dados, você pode usar find query -

>db.fs.files.find()

O comando acima retornou o seguinte documento -

{
   _id: ObjectId('534a811bf8b4aa4d33fdf94d'), 
   filename: "song.mp3", 
   chunkSize: 261120, 
   uploadDate: new Date(1397391643474), md5: "e4f53379c909f7bed2e9d631e15c1c41",
   length: 10401959 
}

Também podemos ver todos os pedaços presentes na coleção fs.chunks relacionados ao arquivo armazenado com o código a seguir, usando o ID do documento retornado na consulta anterior -

>db.fs.chunks.find({files_id:ObjectId('534a811bf8b4aa4d33fdf94d')})

No meu caso, a consulta retornou 40 documentos, o que significa que todo o documento mp3 foi dividido em 40 blocos de dados.

Capped collectionssão coleções circulares de tamanho fixo que seguem a ordem de inserção para oferecer suporte a alto desempenho para criar, ler e excluir operações. Por circular, significa que quando o tamanho fixo alocado para a coleção se esgotar, ele começará a deletar o documento mais antigo da coleção sem fornecer nenhum comando explícito.

As coleções limitadas restringem as atualizações aos documentos se a atualização resultar no aumento do tamanho do documento. Como as coleções limitadas armazenam documentos na ordem do armazenamento em disco, isso garante que o tamanho do documento não aumente o tamanho alocado no disco. Coletas limitadas são melhores para armazenar informações de log, dados de cache ou quaisquer outros dados de alto volume.

Criação de coleção limitada

Para criar uma coleção limitada, usamos o comando createCollection normal, mas com capped opção como true e especificando o tamanho máximo da coleção em bytes.

>db.createCollection("cappedLogCollection",{capped:true,size:10000})

Além do tamanho da coleção, também podemos limitar o número de documentos na coleção usando o max parâmetro -

>db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})

Se você deseja verificar se uma coleção é limitada ou não, use o seguinte isCapped comando -

>db.cappedLogCollection.isCapped()

Se houver uma coleção existente que você planeja converter para limitada, você pode fazer isso com o seguinte código -

>db.runCommand({"convertToCapped":"posts",size:10000})

Este código converteria nossa coleção existente posts para uma coleção limitada.

Consultando coleção limitada

Por padrão, uma consulta de localização em uma coleção limitada exibirá os resultados no pedido de inserção. Mas se você quiser que os documentos sejam recuperados na ordem inversa, use osort comando conforme mostrado no código a seguir -

>db.cappedLogCollection.find().sort({$natural:-1})

Existem alguns outros pontos importantes em relação às coleções limitadas que vale a pena conhecer -

  • Não podemos excluir documentos de uma coleção limitada.

  • Não há índices padrão presentes em uma coleção limitada, nem mesmo no campo _id.

  • Ao inserir um novo documento, o MongoDB não precisa realmente procurar um lugar para acomodar o novo documento no disco. Ele pode inserir cegamente o novo documento no final da coleção. Isso torna as operações de inserção em coleções limitadas muito rápidas.

  • Da mesma forma, ao ler documentos, o MongoDB retorna os documentos na mesma ordem em que estão presentes no disco. Isso torna a operação de leitura muito rápida.

O MongoDB não tem funcionalidade de incremento automático pronta para uso, como bancos de dados SQL. Por padrão, ele usa o ObjectId de 12 bytes para o_idcampo como a chave primária para identificar exclusivamente os documentos. No entanto, pode haver cenários em que podemos querer que o campo _id tenha algum valor de incremento automático diferente de ObjectId.

Uma vez que este não é um recurso padrão no MongoDB, vamos atingir essa funcionalidade programaticamente usando um counters coleção conforme sugerido pela documentação do MongoDB.

Usando a coleção de contador

Considere o seguinte productsdocumento. Queremos que o campo _id seja umauto-incremented integer sequence começando de 1,2,3,4 até n.

{
  "_id":1,
  "product_name": "Apple iPhone",
  "category": "mobiles"
}

Para isso, crie um counters coleção, que controlará o último valor da sequência para todos os campos da sequência.

>db.createCollection("counters")

Agora, vamos inserir o seguinte documento na coleção de contadores com productid como sua chave -

{
  "_id":"productid",
  "sequence_value": 0
}

O campo sequence_value acompanha o último valor da sequência.

Use o seguinte código para inserir este documento de sequência na coleção de contadores -

>db.counters.insert({_id:"productid",sequence_value:0})

Criação de função Javascript

Agora, vamos criar uma função getNextSequenceValueque terá o nome da sequência como sua entrada, incrementará o número da sequência em 1 e retornará o número da sequência atualizado. Em nosso caso, o nome da sequência éproductid.

>function getNextSequenceValue(sequenceName){

   var sequenceDocument = db.counters.findAndModify({
      query:{_id: sequenceName },
      update: {$inc:{sequence_value:1}},
      new:true
   });
	
   return sequenceDocument.sequence_value;
}

Usando a função Javascript

Agora usaremos a função getNextSequenceValue ao criar um novo documento e atribuir o valor de sequência retornado como o campo _id do documento.

Insira dois documentos de amostra usando o seguinte código -

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Apple iPhone",
   "category":"mobiles"
})

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Samsung S3",
   "category":"mobiles"
})

Como você pode ver, usamos a função getNextSequenceValue para definir o valor do campo _id.

Para verificar a funcionalidade, vamos buscar os documentos usando o comando find -

>db.products.find()

A consulta acima retornou os seguintes documentos com o campo _id auto-incrementado -

{ "_id" : 1, "product_name" : "Apple iPhone", "category" : "mobiles"}

{ "_id" : 2, "product_name" : "Samsung S3", "category" : "mobiles" }