Mongo DBNotes For Professionals

Machine Translated by Google
MongoDBGenericName
Notas para Profissionais MongoDB®
Notas para Profissionais
mais de 60 páginas
de dicas e truques profissionais
GoalKicker.com Livros Isenção de

responsabilidade Este é um livro gratuito não-social criado para fins educacionais e
gratuitos de programação não está associado a grupos ou empresas ociais do MongoDB®.
Todas as marcas comerciais e marcas registradas são
de propriedade de seus respectivos proprietários
Conteúdo
Sobre ................................................ ................................................ ................................................ ............................. 1
Capítulo 1: Introdução ao MongoDB ....................................... ................................................ .......... 2
Seção 1.1: Execução de um arquivo JavaScript no MongoDB ....................................... ................................................ ... 2 Seção
1.2: Tornando a saída de find legível no shell Seção 1.3: ................................................ .......................................... 2
Termos complementares ................................................ ................................................ ......................... 3
Seção 1.4: Instalação ................................................ ................................................ ............................................. 3
Seção 1.5: Comandos básicos no shell mongo ................................................ ................................................ ........ 6
Seção 1.6: Olá, mundo ................................................ ................................................ ................................................ 6
Capítulo 2: Operação CRUD ....................................... ................................................ ......................................... 7
Seção 2.1: Criar ................................................ ................................................ ................................................ ... 7
Seção 2.2: Atualização ....................................... ................................................ ................................................ ..... 7 Seção 2.3:
Excluir ................................................ ................................................ ................................................ ... 8
Seção 2.4: Leia ................................................ ................................................ ................................................ ..... 8
Seção 2.5: Atualização de documentos incorporados ................................................ ................................................ ...... 9
Seção 2.6: Mais operadores de atualização ............................... ................................................ ................................ 10 Seção 2.7:
Parâmetro "multi" ao atualizar vários documentos ................................................ ..................... 10
Capítulo 3: Obtendo informações do banco de dados
................................................ ................................................ . 11
Seção 3.1: Listar todas as coleções no banco de dados ................................................ ................................................ ........... 11
Seção 3.2: Listar todos os bancos de dados ................................................ ................................................ ................................ 11
Capítulo 4: Consulta de dados (primeiros passos) ....................................... ......................................... 12 Seção 4.1 :

Localizar() .............................................. ................................................ ................................................ ..... 12 Seção 4.2:
FindOne() ..................................... ................................................ ................................................ ......... 12 Seção 4.3: limite, pule,
classifique e conte os resultados do método find() Seção 4.4: Documento de ................................................ ............. 12
consulta - usando condições AND, OR e IN Seção 4.5: método find() com ................................................ ..................... 14
projeção ................................................ ................................................ ............ 16 Seção 4.6: Método Find() com
projeção ....................... ................................................ ................................ 16 Capítulo 5: Atualizar
operadores ........... ................................................ ................................................ .............. 18
Seção 5.1: Operador $set para atualizar campo(s) especificado(s) no(s) documento(s) .............................. ................................ 18
Capítulo 6: Upserts e inserções ................................................ ................................................ ....................... 20
Seção 6.1: Inserir um documento
................................................ ................................................ ............................. 20
Capítulo 7: Coleções ................................................ ................................................ .......................................... 21
Seção 7.1: Criar uma coleção ................................................ ................................................ ............................. 21
Seção 7.2: Coleta suspensa ................................................ ................................................ ......................................... 22
Capítulo 8: Agregação ....................................... ................................................ ......................................... 23
Seção 8.1: Contagem ................................................ ................................................ ................................................ .. 23
Seção 8.2: Soma ................................................ ................................................ ................................................ .... 23
Seção 8.3: Média .............................................. ................................................ ................................................ 24 Seção 8.4:
Operações com arrays ....................................... ................................................ ............................. 25 Seção 8.5: Agregar exemplos
de consulta úteis para trabalho e aprendizado ........ ................................................ ....... 25
Seção 8.6: Correspondência ................................................ ................................................ ................................................ . 29
Seção 8.7: Obter dados de ................................................ ................................................ ................................ 30
amostra Seção 8.8: Remover documentos que possuem um campo duplicado em uma coleção (dedupe) ....................... ......................
30 Seção 8.9: Left Outer Join com agregação ( $Lookup) ............... ................................................ .................... 30 Seção 8.10:
Agregação de servidores ....................... ................................................ ................................................ .. 31 Seção 8.11: Agregação
em um método de servidor Seção 8.12: Exemplo de ................................................ ................................................ ...... 31
Java e Spring .............................. ................................................ ................................ 32
Capítulo 9: Índices ................................................ ................................................ ................................................ 34

Seção 9.1: Noções básicas de criação de índice ................................................ ................................................ .......................... 34
Seção 9.2: Eliminando/excluindo um índice ................................................ ................................................ ............. 36
Seção 9.3: Índices esparsos e índices parciais Seção ................................................ ................................................ .. 36
9.4: Obter índices de uma coleção ................................................ ................................................ ................. 37
Seção 9.5: Composto ...................................... ................................................ ......................................... 38 Seção 9.6 : Índice exclusivo
Seção 9.7: Campo único Seção ................................................ ................................................ ......................................... 38
9.8: Excluir ................................................ ................................................ ......................................... 38
................................................ ................................................ ................................................ . 38
Seção 9.9: Lista ................................................ ................................................ ................................................ ...... 39
Capítulo 10: Operações em massa .............................. ................................................ ................................ 40
Seção 10.1: Convertendo um campo para outro tipo e atualizando toda a coleção em massa ............................. 40
Capítulo 11: Índice 2dsphere ................................................ ................................................ ................................ 43
Seção 11.1: Criar um índice 2dsphere ................................................ ................................................ ..................... 43

Capítulo 12: Mecanismos de armazenamento conectáveis ....................................... ................................................ ............
44
Seção 12.1: WiredTiger .............................................. ................................................ ......................................... 44

Seção 12.2: MMAP ................................................ ................................................ ................................................ 44
Seção 12.3: Na memória ....................................... ................................................ ......................................... 44 Seção 12.4 :
mongo-rocks .............................................. ................................................ ......................................... 44
Seção 12.5: Fusão-io ................................................ ................................................ ................................................ 44
Seção 12.6: TokuMX ................................................ ................................................ ............................................. 45
Capítulo 13: Driver Java ................................................ ................................................ ......................................... 46
Seção 13.1: Buscar dados de coleta com condição ................................................ ................................................ 46
Seção 13.2: Criar um usuário de banco de dados ................................................ ................................................ ..................... 46
Seção 13.3: Criar um cursor ajustável ................................................ ................................................ ..................... 46
Capítulo 14: Driver Python ................................................ ................................................ ................................. 48
Seção 14.1: Conecte-se ao MongoDB usando pymongo ....................................... ................................................ .... 48 Seção 14.2:
Consultas PyMongo ...................................... ................................................ ......................................... 48 Seção 14.3: Atualizar
todos os documentos em uma coleção usando o PyMongo .............................................. ......................... 49
Capítulo 15: Mongo como fragmentos ................................................ ................................................ .......................... 50
Seção 15.1: Configuração do ambiente de fragmentação ....................................... ................................................ .................. 50
Capítulo 16: Replicação ........................... ................................................ ................................................ ............. 51
Seção 16.1: Configuração básica com três nós ................................................ ................................................ 51
Capítulo 17: Mongo como um conjunto de ................................................ ................................................ ............. 53
réplicas Seção 17.1: Mongodb como um ................................................ ................................................ ................ 53

conjunto de réplicas Seção 17.2: Verifique os estados ................................................ ................................................ 54
do conjunto de réplicas do MongoDB Capítulo 18: MongoDB - Configurar um ReplicaSet para oferecer suporte a TLS/
SSL ............. ................................ 56 Seção 18.1: Como configurar um ReplicaSet para suportar TLS/
SSL? ................................................ ....................... 56 Seção 18.2: Como conectar seu cliente (Mongo Shell) a um
ReplicaSet? ................................................ .......... 58 Capítulo 19: Mecanismos de Autenticação no MongoDB .............................. .....................
Seção 19.1: Mecanismos de Autenticação ................................................ ................................................ ............. 60
Capítulo 20: Modelo de autorização do MongoDB ................................................ ............................................. 61
Seção 20.1: Funções incorporadas ................................................ ................................................ ......................................... 61
Capítulo 21: Configuração .............................................. ................................................ ......................................... 62
Seção 21.1: Iniciando o mongo com um arquivo de configuração específico ................................................ ......................................... 63
Capítulo 22: Fazendo backup e restaurando dados Seção ................................................ ............................................. 64
22.1: Mongodump básico da instância mongod padrão local Seção 22.2: ................................................ ..................... 64
Mongorestore básico do dump mongod padrão local ....................... ................................................ 64
Seção 22.3: mongoimport com JSON ................................................ ................................................ ................. 64

Seção 22.4: mongoimport com CSV ................................................ ................................................ ..................... 65
Capítulo 23: Atualizando a versão do MongoDB
................................................ ................................................ . 66
Seção 23.1: Atualizando para 3.4 no Ubuntu 16.04 usando apt ....................................... ......................................... 66
Créditos ................................................ ................................................ ................................................ ....................... 67
você pode gostar ................................................ ................................................ ................................................ .. 69
Sobre
Sinta-se à vontade para compartilhar este PDF com qualquer pessoa

gratuitamente, a versão mais recente deste livro pode ser baixada em:
https://goalkicker.com/MongoDBBook
Este livro do MongoDB® Notes for Professionals é compilado da Stack Overflow

Documentation, o conteúdo é escrito pelas pessoas bonitas do Stack Overflow.
O conteúdo do texto é liberado sob Creative Commons BY-SA, veja os créditos no final deste
livro, quem contribuiu para os vários capítulos. As imagens podem ter direitos autorais de seus
respectivos proprietários, a menos que especificado de outra forma
Este é um livro gratuito não oficial criado para fins educacionais e não é afiliado a grupos
ou empresas oficiais do MongoDB® nem ao Stack Overflow. Todas as marcas comerciais e
marcas registradas são de propriedade de seus respectivos
proprietários de empresas
As informações apresentadas neste livro não são garantidas como corretas ou precisas,
use por sua conta e risco
Envie comentários e correções para web@petercv.com
GoalKicker.com MongoDB® Notes for Professionals 1

Capítulo 1: Introdução ao MongoDB

Data de lançamento da
versão 3.6.1 2017-12-26
3.4 29/11/2016
3.2 2015-12-08
3.0 03/03/2015
2.6 2014-04-08
2.4 19/03/2013
2.2 29/08/2012
2.0 2011-09-12
1.8 16/03/2011
1.6 31-08-2010
1.4 2010-03-25
1.2 2009-12-10
Seção 1.1: Execução de um arquivo JavaScript no MongoDB

./mongo localhost:27017/mydb myjsfile.js
Explicação: Esta operação executa o script myjsfile.js em um shell mongo que se conecta ao banco de dados mydb na instância mongod acessível
por meio da interface localhost na porta 27017. localhost:27017 não é obrigatório, pois é a porta padrão que o mongodb usa.
Além disso, você pode executar um arquivo .js no console mongo .
>load("meujsfile.js")
Seção 1.2: Tornando a saída de find legível no shell

Adicionamos três registros ao nosso teste de coleção como:
> db.test.insert({"chave":"valor1","chave2":"Val2","chave3":"val3"})
WriteResult({ "nInserted" : 1 }) >
db.test.insert({"chave":"valor2","chave2":"Val21","chave3":"val31"})
WriteResult({ "nInserted" : 1 }) >
db.test.insert({"key":"value3","key2":"Val22","key3":"val33"})
WriteResult({ "nInserted" : 1 })
Se os virmos via find, eles parecerão muito feios.
> db.test.find()
{ "_id" : ObjectId("5790c5cecae25b3d38c3c7ae"), "key" : "value1", "key2" : "Val2 ", "key3" : "val3" }
{ "_id" : ObjectId
("5790c5d9cae25b3d38c3c7af"), "key" : "value2", "key2" : "Val2 1", "key3" : "val31" } { "_id" :
ObjectId("5790c5e9cae25b3d38c3c7b0"), "key" : "value3" , "key2" : "Val2 2", "key3" : "val33" }
Para contornar isso e torná-los legíveis, use a função pretty() .
> db.test.find().pretty()

{
"_id" : ObjectId("5790c5cecae25b3d38c3c7ae"), "chave" :
"valor1", "chave2" :
"Val2", "chave3" :
"val3"
}{
"_id" : ObjectId("5790c5d9cae25b3d38c3c7af"), "chave" :
"Val21", "chave3" :
"val31"
}{
"_id" : ObjectId("5790c5e9cae25b3d38c3c7b0"), "chave" :
"Val22", "chave3" :
"val33"
}
>
Seção 1.3: Termos Complementares

Termos SQL Termos do MongoDB
banco de dados banco de dados
Mesa Coleção
Entidade / Documento de Linha

Coluna Chave / Campo
Tabela Unir documentos incorporados

Chave Primária Chave Primária (Chave padrão _id fornecida pelo próprio mongodb)
Seção 1.4: Instalação
Para instalar o MongoDB, siga os passos abaixo:
Para Mac OS:
Existem duas opções para Mac OS: instalação manual ou homebrew.

Instalando com homebrew:
Digite o seguinte comando no terminal: $ brew
install mongodb
Instalando manualmente:
Baixe a versão mais recente aqui. Certifique-se de que está baixando o arquivo apropriado, especialmente verifique se o
tipo do seu sistema operacional é de 32 ou 64 bits. O arquivo baixado está no formato tgz.
Vá para o diretório onde este arquivo foi baixado. Em seguida digite o seguinte comando:
$ tar xvf mongodb-osx-xyz.tgz
Em vez de xyz, haveria algumas informações de versão e tipo de sistema. A pasta extraída teria o
mesmo nome do arquivo tgz . Dentro da pasta, haveria uma subpasta chamada bin que conteria
vários arquivos binários junto com mongod e mongo.
Por padrão, o servidor mantém os dados na pasta /data/db. Então, temos que criar esse diretório e, em seguida,

execute o servidor com os seguintes comandos:
$ sudo bash
# mkdir -p / data/ db #
chmod 777 / data #
chmod 777 / data/ db # exit
Para iniciar o servidor, o seguinte comando deve ser dado a partir do local atual:
$ ./mongod
Ele iniciaria o servidor na porta 27017 por padrão.
Para iniciar o cliente, um novo terminal deve ser aberto com o mesmo diretório de antes. Em seguida, o seguinte
comando iniciaria o cliente e se conectaria ao servidor.
$ ./mongo
Por padrão, ele se conecta ao banco de dados de teste . Se você vir a linha conectando-se a: test. Então você instalou
o MongoDB com sucesso. Parabéns! Agora, você pode testar o Hello World para ficar mais confiante.
Para Windows:
Baixe a versão mais recente aqui. Certifique-se de que está baixando o arquivo apropriado, especialmente verifique se o tipo do
seu sistema operacional é de 32 ou 64 bits.
O arquivo binário baixado tem extensão exe. Executá-lo. Ele solicitará um assistente de instalação.
Clique em Avançar.
Aceite o contrato de licença e clique em Avançar.
Selecione Instalação completa .
Clique em Instalar. Pode abrir uma janela para solicitar a permissão do administrador. Clique em Sim.
Após a instalação clique em Concluir.
Agora, o mongodb está instalado no caminho C:/Program Files/MongoDB/Server/3.2/bin. Ao invés da versão 3.2, pode haver
alguma outra versão para o seu caso. O nome do caminho seria alterado de acordo.
bin diretório contém vários arquivos binários junto com mongod e mongo. Para executá-lo de outra pasta, você pode adicionar o
caminho no caminho do sistema. Para fazer:
Clique com o botão direito em Meu computador e selecione Propriedades.
Clique em Configuração avançada do sistema no painel esquerdo.

Clique em Variáveis de ambiente... na guia Avançado .
Selecione Caminho na seção Variáveis do sistema e clique em Editar....

Antes do Windows 10, acrescente um ponto e vírgula e cole o caminho fornecido acima. No Windows 10, há um botão
Novo para adicionar um novo caminho.
Clique em OK para salvar as alterações.
Agora, crie uma pasta chamada data tendo uma subpasta chamada db onde você deseja executar o servidor.
Inicie o prompt de comando a partir deles. Mudando o caminho em cmd ou clicando em Abrir janela de comando aqui , que
ficará visível após clicar com o botão direito do mouse no espaço vazio da pasta GUI pressionando

as teclas Shift e Ctrl juntas.
Escreva o comando para iniciar o servidor:
> mongod
Ele iniciaria o servidor na porta 27017 por padrão.
Abra outro prompt de comando e digite o seguinte para iniciar o cliente:
> mongo
Por padrão, ele se conecta ao banco de dados de teste . Se você vir a linha conectando-se a: test. Então você instalou o MongoDB
com sucesso. Parabéns! Agora, você pode testar o Hello World para ficar mais confiante.
Para Linux: Quase igual ao Mac OS, exceto que algum comando equivalente é necessário.
Para distribuições baseadas em Debian (usando apt-

get): Importe a chave do Repositório MongoDB.
$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv EA312927 gpg: Número total
processado: 1\ importado: 1 (RSA: 1) gpg:
Adicione o repositório à lista de pacotes no Ubuntu 16.04.
$ echo "deb http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/

sources.list.d/mongodb-org-3.2.list
no Ubuntu 14.04.
$ echo "deb http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/

sources.list.d/mongodb-org-3.2.list
Atualizar lista de pacotes.
$ sudo apt-get update
Instale o MongoDB.
$ sudo apt-get install mongodb-org
Para distribuições baseadas em Red Hat (usando yum):
use um editor de texto de sua preferência.
$ vi /etc/yum.repos.d/mongodb-org-3.4.repo
Cole o seguinte texto.
[mongodb-org-3.4]
name=Repositório MongoDB
baseurl=https:// repo.mongodb.org/ yum/ redhat/ $releasever/ mongodb-org/ 3.4/ x86_64/ gpgcheck=1
habilitado=1
gpgkey=https:// www.mongodb.org/ static/ pgp/ server-3.4.asc
Atualizar lista de pacotes.
atualização $ sudo yum
Instalar o MongoDB
$ sudo yum install mongodb-org

Seção 1.5: Comandos básicos no shell mongo

Mostrar todos os bancos de dados disponíveis:
mostrar dbs;
Selecione um banco de dados específico para acessar, por exemplo, mydb. Isso criará mydb se ainda não existir:
usar mydb;
Mostrar todas as coleções no banco de dados (certifique-se de selecionar uma primeiro, veja acima):
mostrar coleções;
Mostrar todas as funções que podem ser usadas com o banco de dados:
db.mydb.help();
Para verificar seu banco de dados atualmente selecionado, use o comando db
> db
meudb
O comando db.dropDatabase() é usado para descartar um banco de dados existente.
db.dropDatabase()
Seção 1.6: Olá, mundo
Após o processo de instalação, as seguintes linhas devem ser inseridas no shell mongo (terminal do cliente).
> db.world.insert({ "speech" : "Hello World!" }); > cur =

db.world.find();x=cur.next();print(x["fala"]);
Olá Mundo!
Explicação:
Na primeira linha, inserimos um documento emparelhado { key : value } no teste de banco de dados padrão e na coleção chamada
world.
Na segunda linha, recuperamos os dados que acabamos de inserir. Os dados recuperados são mantidos em uma variável javascript
chamada cur. Então, pela função next() , recuperamos o primeiro e único documento e o mantemos em outra variável js chamada x. Em
seguida, imprimiu o valor do documento fornecendo a chave.

Capítulo 2: Operação CRUD

Seção 2.1: Criar
db.people.insert({nome: 'Tom', idade: 28});
Ou
db.people.save({nome: 'Tom', idade: 28});
A diferença com salvar é que se o documento passado contiver um campo _id , se já existir um documento com esse _id ele será atualizado ao invés
de ser adicionado como novo.
Dois novos métodos para inserir documentos em uma coleção, no MongoDB 3.2.x:
Use insertOne para inserir apenas um registro:
db.people.insertOne({nome: 'Tom', idade: 28});
Use insertMany para inserir vários registros:
db.people.insertMany([{nome: 'Tom', idade: 28},{nome: 'John', idade: 25}, {nome: 'Kathy', idade: 23}])
Observe que inserir é realçado como obsoleto em todos os drivers de idioma oficial desde a versão 3.0. A distinção completa é que os métodos de
shell realmente ficaram para trás dos outros drivers na implementação do método. A mesma coisa se aplica a todos os outros métodos CRUD
Seção 2.2: Atualização

Atualize todo o objeto:
db.people.update({nome: 'Tom'}, {idade: 29, nome: 'Tom'})
// Novo no MongoDB 3.2

db.people.updateOne({nome: 'Tom'},{idade: 29, nome: 'Tom'}) //Substituirá apenas o primeiro documento correspondente.
db.people.updateMany({nome: 'Tom'},{idade: 29, nome: 'Tom'}) //Substituirá todos os documentos correspondentes.
Ou apenas atualize um único campo de um documento. Neste caso idade:
db.people.update({nome: 'Tom'}, {$set: {idade: 29}})
Você também pode atualizar vários documentos simultaneamente adicionando um terceiro parâmetro. Esta consulta atualizará todos
os documentos em que o nome for igual a Tom:
db.people.update({nome: 'Tom'}, {$set: {idade: 29}}, {multi: verdadeiro})

db.people.updateOne({name: 'Tom'},{$set:{age: 30}) //Atualizará apenas o primeiro documento correspondente.
db.people.updateMany({name: 'Tom'},{$set:{age: 30}}) //Atualizará todos os documentos correspondentes.
Se um novo campo estiver chegando para atualização, esse campo será adicionado ao documento.

db.people.updateMany({nome: 'Tom'},{$set:{idade: 30, salário:50000}})// O documento também terá o campo `salário`.
Se for necessário substituir um documento,
db.collection.replaceOne({nome:'Tom'}, {nome:'Lakmal',idade:25,endereço:'Sri Lanka'})
pode ser usado.
Nota: Os campos que você usa para identificar o objeto serão salvos no documento atualizado. Os campos que não forem definidos na seção de
atualização serão removidos do documento.
Seção 2.3: Excluir
Exclui todos os documentos correspondentes ao parâmetro de consulta:

db.people.deleteMany({name: 'Tom'})
// Todas as versões
db.people.remove({name: 'Tom'})
Ou apenas um

db.people.deleteOne({name: 'Tom'})
// Todas as versões
db.people.remove({name: 'Tom'}, true)
Método remove() do MongoDB . Se você executar este comando sem nenhum argumento ou sem argumento vazio, todos os documentos serão
removidos da coleção.
db.pessoas.remove();
ou
db.pessoas.remove({});
Seção 2.4: Leia
Consulte todos os documentos na coleção de pessoas que possuem um campo de nome com o valor 'Tom':
db.pessoas.find({nome: 'Tom'})
Ou apenas o primeiro:
db.people.findOne({nome: 'Tom'})
Você também pode especificar quais campos retornar passando um parâmetro de seleção de campo. O seguinte excluirá o campo _id e incluirá apenas
o campo age :
db.people.find({nome: 'Tom'}, {_id: 0, idade: 1})

Observação: por padrão, o campo _id será retornado, mesmo que você não solicite. Se você não quiser obter o _id de volta, basta seguir o exemplo
anterior e solicitar que o _id seja excluído especificando _id: 0 (ou _id: false). , cidade, etc
db.people.find({'address.country': 'US'})
& especifique o campo também se necessário
db.people.find({'address.country': 'US'}, {'name': true, 'address.city': true})Lembre-se que o resultado tem um método
`.pretty()` que bastante- imprime o JSON resultante:
db.pessoas.find().pretty()
Seção 2.5: Atualização de documentos incorporados

Para o seguinte esquema:
{nome: 'Tom', idade: 28, marcas: [50, 60, 70]}
Atualize as marcas de Tom para 55, onde as marcas são 50 (use o operador posicional $):
db.people.update({nome: "Tom", marcas: 50}, {"$set": {"marcas.$": 55}})
Para o seguinte esquema:
{nome: 'Tom', idade: 28, notas: [{assunto: "Inglês", notas: 90},{assunto: "Matemática", notas: 100}, {assunto:
"Calculações", notas: 20}] }
Atualize as marcas de inglês de Tom para 85:
db.people.update({name: "Tom", "marks.subject": "Inglês"},{"$set":{"marks.$.marks": 85}})
Explicando o exemplo acima:
Usando {name: "Tom", "marks.subject": "English"} você obterá a posição do objeto na matriz de marcas, onde o assunto é o inglês. Em "marks.
$.marks", $ é usado para atualizar nessa posição do array de marcas
Atualizar valores em uma matriz
O operador posicional $ identifica um elemento em uma matriz para atualizar sem especificar explicitamente a posição do elemento na matriz.
Considere uma coleção de alunos com os seguintes documentos:
{ "_id" : 1, "notas" : { "_id" : [ 80, 85, 90 ] } [ 88,

2, "notas" : { "_id" : 3, "notas" : 90, 92 ] } [ 85, 100,
90 ] }
Para atualizar 80 para 82 na matriz de notas no primeiro documento, use o operador posicional $ se você não souber a posição do elemento na
matriz:
db.students.update( { _id:
1, notas: 80 }, { $set:
{ "grades.$" : 82 } }

Seção 2.6: Mais operadores de atualização

Você pode usar outros operadores além de $set ao atualizar um documento. O operador $push permite que você coloque um valor
em um array, neste caso adicionaremos um novo apelido ao array de apelidos .
db.people.update({nome: 'Tom'}, {$push: {apelidos: 'Tommy'}})

// Isso adiciona a string 'Tommy' no array de apelidos no documento de Tom.
O operador $pull é o oposto de $push, você pode extrair itens específicos de arrays.
db.people.update({nome: 'Tom'}, {$pull: {apelidos: 'Tommy'}})

// Isso remove a string 'Tommy' do array de apelidos no documento de Tom.
O operador $pop permite remover o primeiro ou o último valor de uma matriz. Digamos que o documento de Tom tenha uma
propriedade chamada brothers que tem o valor ['Marie', 'Bob', 'Kevin', 'Alex'].
db.people.update({nome: 'Tom'}, {$pop: {irmãos: -1}})

// Isso removerá o primeiro valor da matriz de irmãos, que é 'Marie' neste caso.
db.people.update({nome: 'Tom'}, {$pop: {irmãos: 1}})

// Isso removerá o último valor da matriz de irmãos, que é 'Alex' neste caso.
Seção 2.7: Parâmetro "multi" ao atualizar vários documentos
Para atualizar vários documentos em uma coleção, defina a opção multi como true.
db.collection.update(
consulta,
atualização,
{
upsert: booleano,
multi: booleano,
writeConcern: documento
}
)
multi é opcional. Se definido como true, atualiza vários documentos que atendem aos critérios de consulta. Se definido como falso,
atualiza um documento. O valor padrão é falso.
db.mycol.find() { "_id" : ObjectId(598354878df45ec5), "title":"Visão geral do MongoDB"} { "_id" :

ObjectId(59835487adf45ec6), "title":"Visão geral do NoSQL"} { "_id" : ObjectId(59835487adf45ec7),
"title":"Visão geral do ponto de tutoriais"}
db.mycol.update({'title':'Visão geral do MongoDB'}, {$set:{'title':'Novo tutorial do MongoDB'}},{multi:true})

Capítulo 3: Obtendo informações do banco de dados

Seção 3.1: Listar todas as coleções no banco de dados
mostrar coleções
ou
mostrar tabelas
ou
db.getCollectionNames()
Seção 3.2: Listar todos os bancos de dados
mostrar dbs
ou
db.adminCommand('listDatabases')
ou
db.getMongo().getDBNames()

Capítulo 4: Consultando Dados (Obtendo

Iniciado)
Exemplos de consultas básicas
Seção 4.1: Localizar()

recuperar todos os documentos em uma coleção
db.collection.find({});
recuperar documentos em uma coleção usando uma condição (semelhante a WHERE no MYSQL)
db.collection.find({chave: valor}); exemplo
db.users.find({email:"sample@email.com"});
recuperar documentos em uma coleção usando condições booleanas (operadores de consulta)
// E
db.collection.find( { $e:
[ { chave:
valor }, { chave: valor } ]
})
// OU
db.collection.find( { $or:
[ { chave:
valor }, { chave: valor } ]
})
// NÃO
db.inventory.find( { chave: { $não: valor } } )
mais operações booleanas e exemplos podem ser encontrados aqui
NOTA: find() continuará procurando na coleção mesmo se uma correspondência de documento for considerada , Portanto, é
ineficiente quando usada em uma coleção grande , no entanto, modelando cuidadosamente seus dados e/ou usando índices, você pode
aumentar a eficiência de find()
Seção 4.2: FindOne()

db.collection.findOne({});
a funcionalidade de consulta é semelhante a find(), mas isso encerrará a execução no momento em que encontrar um documento que corresponda
à sua condição , se usado com um objeto vazio, ele buscará o primeiro documento e o retornará. findOne() mongodb api
documentação
Seção 4.3: limite, pule, classifique e conte os resultados do método find()
Semelhante aos métodos de agregação, também pelo método find() você tem a possibilidade de limitar, pular, classificar e contar os resultados.
Digamos que temos a seguinte coleção:

db.test.insertMany([ {nome:"Qualquer", idade:"21",

status:"ocupado"}, {nome:"Tony", idade:"25",
status:"ocupado"}, {nome: "Bobby", idade:"28",
status:"online"}, {nome:"Sonny", idade:"28",
status:"ausente"}, {nome:"Cher", idade:"20", estado:"online"}
])
Para listar a coleção:
db.test.find({})
Retornará:
{ "_id" : ObjectId("592516d7fbd5b591f53237b0"), "name" : "Qualquer", "idade" : "21", "status" : "ocupado" } { "_id" :

ObjectId("592516d7fbd5b591f53237b1"), "nome " : "Tony", "idade" : "25", "status" : "ocupado" } { "_id" :
ObjectId("592516d7fbd5b591f53237b2"), "nome" : "Bobby", "idade" : "28", "status" : "online" } { "_id" :
ObjectId("592516d7fbd5b591f53237b3"), "name" : "Filho", "idade" : "28", "status" : "ausente" } { "_id" : ObjectId

("592516d7fbd5b591f53237b4"), "nome" : "Cher", "idade" : "20", "status" : "online" }
Para pular os 3 primeiros documentos:
db.test.find({}).skip(3)
Retornará:
{ "_id" : ObjectId("592516d7fbd5b591f53237b3"), "name" : "Sonny", "idade" : "28", "status" : "ausente" } { "_id" :

ObjectId("592516d7fbd5b591f53237b4"), "nome " : "Cher", "idade" : "20", "status" : "online" }
Para classificar de forma descendente pelo nome do campo:
db.test.find({}).sort({ "nome" : -1})
Retornará:
{ "_id" : ObjectId("592516d7fbd5b591f53237b1"), "nome" : "Tony", "idade" : "25", "status" : "ocupado" } { "_id" :

ObjectId("592516d7fbd5b591f53237b3"), "nome " : "Sonny", "idade" : "28", "status" : "ausente" } { "_id" :
ObjectId("592516d7fbd5b591f53237b4"), "nome" : "Cher", "idade" : "20", "status" : "online" } { "_id" :
ObjectId("592516d7fbd5b591f53237b2"), "name" : "Bobby", "age" : "28", "status" : "online" } { "_id" : ObjectId
("592516d7fbd5b591f53237b0"), "nome" : "Qualquer", "idade" : "21", "status" : "ocupado" }
Se você quiser classificar em ordem crescente, basta substituir -1 por 1
Para contar os resultados:
db.test.find({}).count()
Retornará:

Também são permitidas combinações destes métodos. Por exemplo, obtenha 2 documentos da coleção classificada decrescente,
ignorando o primeiro 1:
db.test.find({}).sort({ "nome" : -1}).skip(1).limit(2)
Retornará:
{ "_id" : ObjectId("592516d7fbd5b591f53237b3"), "name" : "Sonny", "idade" : "28", "status" : "ausente" } { "_id" :

ObjectId("592516d7fbd5b591f53237b4"), "nome " : "Cher", "idade" : "20", "status" : "online" }
Seção 4.4: Documento de consulta - usando condições

AND, OR e IN
Todos os documentos do acervo dos alunos .
> db.students.find().pretty();
{
"_id" : ObjectId("58f29a694117d1b7af126dca"),
"studentNo" : 1,
"firstName" : "Prosen",
"lastName" : "Ghosh",
"idade" : 25
}{
"_id" : ObjectId("58f29a694117d1b7af126dcb"),
"studentNo" : 2,
"firstName" : "Rajib",
"lastName" : "Ghosh",
"idade" : 25
}{
"_id" : ObjectId("58f29a694117d1b7af126dcc"),
"studentNo" : 3,
"firstName" : "Rizve",
"lastName" : "Amin",
"idade" : 23
}{
"_id" : ObjectId("58f29a694117d1b7af126dcd"),
"studentNo" : 4,
"firstName" : "Jabed",
"lastName" : "Bangali",
"idade" : 25
}{
"_id" : ObjectId("58f29a694117d1b7af126dce"),
"studentNo" : 5,
"firstName" : "Gm",
"lastName" : "Anik",
"idade" : 23
}
Consulta mySql semelhante ao comando acima.
SELECIONE * DE alunos;

db.students.find({firstName:"Prosen"});
{ "_id" : ObjectId("58f2547804951ad51ad206f5"), "studentNo" : "1", "firstName" : "Prosen", "lastName" : "Ghosh", "age" :

"23" }
SELECT * FROM alunos WHERE primeiroNome = "Prosen";
E Consultas
db.students.find({ "firstName":
"Prosen",
"age": { "$gte": 23
}
});
{ "_id" : ObjectId("58f29a694117d1b7af126dca"), "studentNo" : 1, "firstName" : "Prosen", "lastName"

: "Ghosh", "idade" : 25 }
SELECT * FROM alunos WHERE primeiroNome = "Prosen" E idade >= 23
Ou consultas
db.students.find({ "$or":
[{ "firstName":
"Prosen" }, { "age": { "$gte":
23
}
}]
});

: "Ghosh", "age" : 25 } { "_id" :
ObjectId("58f29a694117d1b7af126dcb"), "studentNo" : 2, "firstName" : "Rajib", "lastName"
: "Ghosh", "age" : 25 } { "_id" :
ObjectId("58f29a694117d1b7af126dcc"), "studentNo" : 3, "firstName" : "Rizve", "lastName"
: "Amin", "age" : 23 } { "_id" :
ObjectId("58f29a694117d1b7af126dcd"), "studentNo" : 4, "firstName" : "Jabed", "lastName"
: "Bangali", "age" : 25 } { "_id" :
ObjectId("58f29a694117d1b7af126dce"), "studentNo" : 5, "firstName" : "Gm", "lastName" :
"Anik", "idade" : 23 }
SELECT * FROM alunos WHERE primeiroNome = "Prosen" OU idade >= 23
E OR Consultas
db.students.find({

firstName : "Prosen", $or :

[ {idade :
23}, {idade :
25}
]
});

: "Ghosh", "idade" : 25 }
SELECT * FROM alunos WHERE primeiroNome = "Prosen" E idade = 23 OU idade = 25;
Consultas IN Essas consultas podem melhorar o uso múltiplo de consultas OR
db.students.find(lastName:{$in:["Ghosh", "Amin"]})

: "Ghosh", "age" : 25 } { "_id" :
ObjectId("58f29a694117d1b7af126dcb"), "studentNo" : 2, "firstName" : "Rajib", "lastName"
: "Ghosh", "age" : 25 } { "_id" :
ObjectId("58f29a694117d1b7af126dcc"), "studentNo" : 3, "firstName" : "Rizve", "lastName"
: "Amin", "idade" : 23 }
Consulta mySql semelhante ao comando acima
SELECT * FROM alunos WHERE sobrenome IN ('Ghosh', 'Amin')
Seção 4.5: método find() com projeção

A sintaxe básica do método find() com projeção é a seguinte
> db.COLLECTION_NAME.find({},{KEY:1});
Se você deseja mostrar todos os documentos sem o campo de idade, o comando é o seguinte
db.pessoas.find({},{idade : 0});
Se você deseja mostrar todos os documentos no campo idade, o comando é o seguinte
Seção 4.6: Método Find() com projeção

No MongoDB, projeção significa selecionar apenas os dados necessários, em vez de selecionar todos os dados de um documento.
A sintaxe básica do método find() com projeção é a seguinte
> db.COLLECTION_NAME.find({},{KEY:1});
Se você deseja mostrar todos os documentos sem o campo de idade, o comando é o seguinte
> db.pessoas.find({},{idade:0});

Se você quiser mostrar apenas o campo de idade, o comando é o seguinte
> db.pessoas.find({},{idade:1});
Nota: o campo _id é sempre exibido durante a execução do método find() , se você não quiser este campo, então você precisa definir
como 0.
> db.people.find({},{nome:1,_id:0});
Observação: 1 é usado para mostrar o campo enquanto 0 é usado para ocultar os campos.

Capítulo 5: Operadores de atualização

de significado Parâmetros
fieldName O campo será atualizado :{name: 'Tom'} targetValue O
valor será atribuído ao campo:{name: 'Tom'}
Seção 5.1: Operador $set para atualizar campo(s) especificado(s)

no(s) documento(s)
I.Visão geral
Uma diferença significativa entre MongoDB e RDBMS é que o MongoDB tem muitos tipos de operadores. Um deles é o operador de atualização, que
é usado em instruções de atualização.
II.O que acontece se não usarmos operadores de atualização?
Suponha que temos uma coleção de alunos para armazenar as informações dos alunos (exibição de tabela):
Um dia você consegue um emprego que precisa mudar o gênero de Tom de "M" para "F". Isso é fácil, certo? Então você escreve a declaração abaixo
muito rapidamente com base em sua experiência com RDBMS:
db.student.update( {nome:
'Tom'}, // critérios de consulta {sexo:
'F'} // ação de atualização
);
Vamos ver qual é o resultado:
Perdemos a idade e o nome de Tom! A partir deste exemplo, podemos saber que todo o documento será substituído se não houver nenhum
operador de atualização na instrução de atualização. Este é o comportamento padrão do MongoDB.

3. Operador $set
Se quisermos alterar apenas o campo 'sexo' no documento de Tom, podemos usar $set para especificar qual(is) campo(s) queremos atualizar:
db.student.update( {name:
'Tom'}, // critério de consulta {$set: {sex:
'F'}} // ação de atualização
);
O valor de $set é um objeto, seus campos representam os campos que você deseja atualizar nos documentos e os valores desses campos são os valores
de destino.
Então, o resultado está correto agora:
Além disso, se você quiser alterar 'sexo' e 'idade' ao mesmo tempo, poderá anexá-los a $set :
db.student.update( {name:
'Tom'}, // critério de consulta {$set: {sexo:
'F', idade: 40}} // ação de atualização
);

Capítulo 6: Upserts e inserções

Seção 6.1: Inserir um documento
_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 forneceu, o MongoDB fornece um ID exclusivo para cada documento. Esses 12 bytes, os primeiros 4
bytes para o registro de data e hora atual, os próximos 3 bytes para a identificação da máquina, os próximos 2 bytes para a
identificação do processo do servidor mongodb e os 3 bytes restantes são valores incrementais simples.
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'], curtidas: 100 })
Aqui mycol é um nome de coleção, se a coleção não existir no banco de dados, o MongoDB criará essa coleção e inserirá o
documento nela. No documento inserido, se não especificarmos o parâmetro _id , o MongoDB atribuirá um ObjectId exclusivo para
este documento.

Capítulo 7: Coleções
Seção 7.1: Criar uma coleção
Primeiro selecione ou crie um banco de dados.
> use mydb

mudado para db mydb
Usando o método db.createCollection("yourCollectionName"), você pode criar uma Coleção explicitamente.
> db.createCollection("newCollection1") { "ok" : 1 }
Usando o comando show collections, veja todas as coleções no banco de dados.
> mostrar coleções

newCollection1
system.indexes
>
O método db.createCollection() tem os seguintes parâmetros:
Cadeia de caracteres do tipo de Descrição

nome parâmetro O nome da coleção a ser criada.
Opcional. Opções de configuração para criar uma coleção limitada ou para pré-alocar espaço no documento de
opções de uma nova coleção.
O exemplo a seguir mostra a sintaxe do método createCollection() com algumas opções importantes
>db.createCollection("newCollection4", {capped :true, autoIndexId : true, size : 6142800, max : 10000}) { "ok" : 1 }
As operações db.collection.insert() e db.collection.createIndex() criam suas respectivas coleções, caso ainda não existam.
> db.newCollection2.insert({nome : "XXX"}) >

db.newCollection3.createIndex({accountNo : 1})
Agora, mostre todas as coleções usando o comando show collections

novaColeção1
novaColeção2
newCollection3
newCollection4
system.indexes
Se você quiser ver o documento inserido, use o comando find() .
> db.newCollection2.find() { "_id" :

ObjectId("58f26876cabafaeb509e9c1f"), "name" : "XXX" }

Seção 7.2: Coleta suspensa

O db.collection.drop() do MongoDB é usado para descartar uma coleção do banco de dados.
Primeiro, verifique as coleções disponíveis em seu banco de dados mydb.
> use mydb

mudado para db mydb

novaColeção1
novaColeção2
novaColeção3
system.indexes
Agora elimine a coleção com o nome newCollection1.
> db.newCollection1.drop()
verdadeiro
Nota: Se a coleta for descartada com sucesso, o método retornará true, caso contrário, retornará false.
Verifique novamente a lista de coleções no banco de dados.

newCollection2
newCollection3
system.indexes
Referência: MongoDB drop() Método.

Capítulo 8: Agregação
Matriz de Detalhes
pipeline de parâmetro (uma sequência de operações ou estágios de agregação de
dados) documento de opções (opcional, disponível somente se o pipeline estiver presente como uma matriz)
As operações de agregação processam registros de dados e retornam resultados calculados. As operações de agregação agrupam valores de
vários documentos e podem executar várias operações nos dados agrupados para retornar um único resultado. O MongoDB fornece três
maneiras de executar a agregação: o pipeline de agregação, a função map-reduce e os métodos de agregação de propósito único.
Do manual do Mongo https:// docs.mongodb.com/ manual/ aggregation/
Seção 8.1: Contagem
Como você obtém o número de transações de débito e crédito? Uma maneira de fazer isso é usando a função count () conforme abaixo.
> db.transactions.count({cr_dr : "D"});
ou
> db.transactions.find({cr_dr : "D"}).length();
Mas e se você não souber os valores possíveis de cr_dr antecipadamente. Aqui a estrutura de agregação vem para jogar. Consulte a consulta
agregada abaixo.
> db.transactions.aggregate( [
{
$group :
{ _id : '$cr_dr', // agrupa por tipo de transação
// Adiciona 1 para cada documento à contagem para este tipo de transação count : {$sum : 1}
}
}
]
);
E o resultado é
{
"_id" : "C",
"contagem" : 3
}{
"_id" : "D",
"contagem" : 5
}
Seção 8.2: Soma
Como obter a soma da quantidade? Veja a consulta agregada abaixo.

> db.transactions.aggregate(
[
{
$group : { _id :
'$cr_dr', count :
{$sum : 1}, //conta o número totalAmount : {$sum : '$amount'}
// soma o valor
}
}
]
);
E o resultado é
{
"_id" : "C",
"count" : 3,0,
"totalAmount" : 120,0
}{
"_id" : "D",
"count" : 5,0,
}
Outra versão que soma valor e taxa.
> db.transactions.aggregate( [
{
$group : { _id :
'$cr_dr', count :
{$sum : 1}, totalAmount :
{$sum : { $sum : ['$amount', '$fee']}}
}
}
]
);
E o resultado é
{
"_id" : "C",
"count" : 3,0,
}{
"_id" : "D",
"count" : 5,0,
}
Seção 8.3: Média

Como obter o valor médio das transações de débito e crédito?
> db.transactions.aggregate(
[
{

$group :
{ _id : '$cr_dr', // agrupa por tipo de transação (débito ou crédito) count : {$sum : 1}, //
número de transações para cada tipo totalAmount : {$sum : { $sum : ['$amount',
'$fee']}}, // soma averageAmount : {$avg : { $sum : ['$amount', '$fee']}} // média
}
}
]
)
O resultado é
{
"_id" : "C", // Valores para transações de crédito "count" : 3.0,
"totalAmount" :
128.0, "averageAmount" :
40.0
}{
"_id" : "D", // Valores para transações de débito "count" : 5.0,
"totalAmount" :
422.0, "averageAmount" :
82.0
}
Seção 8.4: Operações com arrays

Quando você quiser trabalhar com as entradas de dados em arrays, primeiro você precisa descontrair a matriz. A operação unwind cria um
documento para cada entrada na matriz. Quando você tiver muitos documentos com grandes matrizes, verá uma explosão no número de
documentos.
{ "_id" : 1, "item" : "myItem1", tamanhos: [ "S", "M", "L"] } { "_id" : 2, "item" :

"myItem2", tamanhos: [ " XS", "M", "XL"] }
db.inventory.aggregate( [ { $unwind : "$sizes" }] )
Um aviso importante é que quando um documento não contém o array ele será perdido. A partir do mongo 3.2, há uma opção de desenrolamento
"preserveNullAndEmptyArrays" adicionada. Esta opção garante que o documento seja preservado quando o array estiver ausente.
{ "_id" : 1, "item" : "myItem1", tamanhos: [ "S", "M", "L"] } { "_id" : 2, "item" :

"myItem2", tamanhos: [ " XS", "M", "XL"] } { "_id" : 3, "item" : "meuItem3" }
db.inventory.aggregate( [ { $unwind : { path: "$sizes", includeArrayIndex: "arrayIndex" } }] )
Seção 8.5: Exemplos de consultas agregadas úteis para trabalho

e aprendizado
A agregação é usada para executar operações complexas de pesquisa de dados na consulta mongo, que não podem ser feitas na consulta
"localizar" normal.
Crie alguns dados fictícios:
db.employees.insert({"name":"Adma","dept":"Admin","languages":["alemão","francês","inglês","hindi"] ,"idade": 30 , "totalExp":10});
db.employees.insert({"name":"Anna","dept":"Admin","languages":["english","hindi"],"age":35,

"totalExp":11});
db.employees.insert({"name":"Bob","dept":"Instalações","idiomas":["inglês","hindi"],"idade":36, "totalExp":14} ) ;
db.employees.insert({"name":"Cathy","dept":"Instalações","idiomas":["hindi"],"idade":31, "totalExp":4}) ;
db.employees.insert({"name":"Mike","dept":"HR","languages":["english", "hindi ", "spanish"],"age":26,

"totalExp" :3});
db.employees.insert({"name":"Jenny","dept":"HR","languages":["english", "hindi ", "spanish"],"age":25,
"totalExp" :3});
Exemplos por tema:
1. Correspondência: Usado para corresponder documentos (como a cláusula where do SQL)
db.employees.aggregate([{$match:{dept:"Admin"}}]); Saída:
{ "_id" :
ObjectId("54982fac2e9b4b54ec384a0d"), "name" : "Adma", "dept" : "Admin", "idiomas" : "alemão", "francês", "inglês", "hindi" ] , [
"age" : 30, "totalExp" : 10 } { "_id" : ObjectId("54982fc92e9b4b54ec384a0e"), "name" : "Anna",
"dept" : "Admin", "languages" : "english", " hindi" ], "idade" : 35, "totalExp" : 11 } [
2. Projeto: Usado para preencher o(s) valor(es) de campo específico(s)
estágio do projeto incluirá o campo _id automaticamente, a menos que você especifique para desabilitar.
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1}}]); Saída: { "_id" :
ObjectId("54982fac2e9b4b54ec384a0d"), "name" : "Adma", "dept" : "Admin" } { "_id" :

ObjectId("54982fc92e9b4b54ec384a0e"), "name" : "Anna", "depto" : "Administrador" }
db.employees.aggregate({$project: {'_id':0, 'name': 1}})

Saída:
{ "nome" : "Adma" }
{ "nome" : "Anna" }
{ "nome" : "Bob" }
{ "nome" : "Cathy" }
{ "nome" : "Mike" }
{ "nome " : "Jenny" }
3. Group: $group é usado para agrupar documentos por campo específico, aqui os documentos são agrupados pelo valor do campo "dept".
Outro recurso útil é que você pode agrupar por nulo, o que significa que todos os documentos serão agregados em um.
db.employees.aggregate([{$group:{"_id":"$dept"}}]);
{ "_id" : "HR" }
{ "_id" : "Instalações" }
{ "_id" : "Administrador" }
db.employees.aggregate([{$group:{"_id":null, "totalAge":{$sum:"$age"}}}]); Saída: { "_id" : null,
"noOfEmployee" : 183 }
4. Sum: $sum é usado para contar ou somar os valores dentro de um grupo.
db.employees.aggregate([{$group:{"_id":"$dept", "noOfDept":{$sum:1}}}]); Saída:

{ "_id" : "HR", "noOfDept" : 2 } { "_id" :

"Instalações", "noOfDept" : 2 } { "_id" : "Admin",
"noOfDept" : 2 }
5. Média: Calcula a média do valor do campo específico por grupo.
db.employees.aggregate([{$group:{"_id":"$dept", "noOfEmployee":{$sum:1}, "avgExp":

{$avg:"$totalExp"}}}]); Saída: { "_id" :
"HR",
"noOfEmployee" : 2, "totalExp" : 3 } { "_id" : "Instalações",
"noOfEmployee" : 2, "totalExp" : 9 } { "_id" : " Admin", "noOfEmployee" : 2,
"totalExp" : 10,5 }
6. Mínimo: Encontra o valor mínimo de um campo em cada grupo.
db.employees.aggregate([{$group:{"_id":"$dept", "noOfEmployee":{$sum:1}, "minExp":

{$min:"$totalExp"}}}]); Saída: { "_id" :
"HR",
"totalExp" : 10 }
7. Máximo: Encontra o valor máximo de um campo em cada grupo.
db.employees.aggregate([{$group:{"_id":"$dept", "noOfEmployee":{$sum:1}, "maxExp":

{$max:"$totalExp"}}}]); Saída: { "_id" :
"HR",
"totalExp" : 11 }
8. Obtendo o valor do campo específico do primeiro e do último documento de cada grupo: Funciona bem quando o resultado do
documento é classificado.
db.employees.aggregate([{$group:{"_id":"$age", "lasts":{$last:"$name"}, "firsts":

{$first:"$name"}}} ]); Output: { "_id" :
25,
"lasts" : "Jenny", "firsts" : "Jenny" } { "_id" : 26, "lasts" : "Mike", "firsts" :
"Mike" } { " _id" : 35, "lasts" : "Cathy", "firsts" : "Anna" } { "_id" : 30,
"lasts" : "Adma", "firsts" : "Adma" }
9. Mínimo com máximo:
db.employees.aggregate([{$group:{"_id":"$dept", "noOfEmployee":{$sum:1}, "maxExp":

{$max:"$totalExp"}, "minExp": {$min: "$totalExp"}}}]); Saída: { "_id" : "HR",
"noOfEmployee" : 2, "maxExp" : 3, "minExp" : 3 } { "_id" : "Instalações",

"noOfEmployee" : 2, "maxExp" : 14, "minExp" : 4 } { "_id" : "Admin", "noOfEmployee" : 2,
"maxExp" : 11, "minExp" : 10 }
10. Push e addToSet: Push adiciona o valor de um campo de cada documento do grupo a um array usado para projetar dados em formato
array, addToSet é semelhante a push mas omite valores duplicados.
db.employees.aggregate([{$group:{"_id":"dept", "arrPush":{$push:"$age"}, "arrSet": {$addToSet:"$age"}}}] );

Saída:

{ "_id" : "depto", "arrPush" : [ 30, 35, 35, 35, 26, 25 ], "arrSet" : [ 25, 26, 35, 30 ] }
11. Unwind: Usado para criar vários documentos na memória para cada valor no campo de tipo de matriz especificado, então podemos fazer mais
agregações com base nesses valores.
db.employees.aggregate([{$match:{"name":"Adma"}}, {$unwind:"$languages"}]); Output: { "_id" :
ObjectId("54982fac2e9b4b54ec384a0d"), "name" : "Adma", "dept" : "HR", "idiomas" : "german", "age" : 30, "totalExp" :
10 } { "_id" : ObjectId("54982fac2e9b4b54ec384a0d"),
"name" : "Adma", "dept" : "HR", "idiomas" : "francês", "idade" : 30, "totalExp" : 10 } { " _id" :
ObjectId("54982fac2e9b4b54ec384a0d"), "name" :
"Adma", "dept" : "HR", "languages" : "english", "age" : 30, "totalExp" : 10 } { "_id" : ObjectId("54982fac2e9b4b54ec384a0d"),
"name" : "Adma", "dept" : "HR", "languages" :
"hindi", "age" : 30, "totalExp" : 10 }
12. Classificação:
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1}}, {$sort: {name: 1}}] ); Saída: { "_id" :
ObjectId("57ff3e553dedf0228d4862ac"), "name" : "Adma", "dept" : "Admin" } { "_id" :

ObjectId("57ff3e5e3dedf0228d4862ad"), "name" : "Anna", "depto" : "Administrador" }
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1}}, {$sort: {name: -1}} ]); Saída: { "_id" :
ObjectId("57ff3e5e3dedf0228d4862ad"), "name" : "Anna", "dept" : "Admin" } { "_id" :

ObjectId("57ff3e553dedf0228d4862ac"), "name" : "Adma", "depto" : "Administrador" }
13. Pular:
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1}}, {$sort: {name: -1}} , {$skip:1}]); Saída:

{ "_id" :
ObjectId("57ff3e553dedf0228d4862ac"), "name" : "Adma", "dept" : "Admin" }
14. Limite:
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1}}, {$sort: {name: -1}} , {$limit:1}]); Saída:
{ "_id" : ObjectId("57ff3e5e3dedf0228d4862ad"), "name" : "Anna", "dept" : "Admin" }
15. Operador de comparação na projeção:
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1, age: {$gt: ["$age", 30 ]}}}]); Saída: { "_id" :
ObjectId("57ff3e553dedf0228d4862ac"), "name" : "Adma", "dept" : "Admin", "idade" : false } { "_id" :

ObjectId("57ff3e5e3dedf0228d4862ad"), "nome " : "Anna", "dept" : "Administrador", "idade" : verdadeiro }
16. Operador de comparação na correspondência:
db.employees.aggregate([{$match:{dept:"Admin", idade: {$gt:30}}}, {$project:{"name":1, "dept":1}}]);
Saída:

{ "_id" : ObjectId("57ff3e5e3dedf0228d4862ad"), "name" : "Anna", "dept" : "Admin" }
Lista de operadores de comparação: $cmp, $eq, $gt, $gte, $lt, $lte e $ne
17. Operador de agregação booleano em projeção:
db.employees.aggregate([{$match:{dept:"Admin"}}, {$project:{"name":1, "dept":1, age: { $and: [ { $gt: [ " $idade", 30 ] }, { $lt:

[ "$idade", 36 ] } ] }}}]);
Output:
{ "_id" : ObjectId("57ff3e553dedf0228d4862ac"), "name" : "Adma", "dept" : "Admin", "age" : false }
{ "_id" : ObjectId("57ff3e5e3dedf0228d4862ad"), "name" : "Anna", "dept" : "Admin", "age" : true }
18. Operador de agregação booleana na correspondência:
db.employees.aggregate([{$match:{dept:"Admin", $and: [{age: { $gt: 30 }}, {age: {$lt: 36 }} ] }}, {$project :{"nome":1, "depto":1,
idade: { $e: [ { $gt: [ "$idade", 30 ] }, { $lt: [ "$idade", 36 ] } ] } }}]); Saída: { "_id" : ObjectId("57ff3e5e3dedf0228d4862ad"),
"name" :
"Anna", "dept" : "Admin", "age" : true }
Lista de operadores de agregação booleana: $and, $or e $not.
Referência completa: https://docs.mongodb.com/v3.2/reference/operator/aggregation/
Seção 8.6: Correspondência
Como escrever uma consulta para obter todos os departamentos em que a idade média dos funcionários que ganham menos ou $ 70.000
é maior ou igual a 35?
Para isso, precisamos escrever uma consulta para corresponder aos funcionários que têm um salário menor ou igual a US$ 70.000. Em
seguida, adicione o estágio agregado para agrupar os funcionários por departamento. Em seguida, adicione um acumulador com um campo chamado,
por exemplo, average_age para encontrar a idade média por departamento usando o $avg acumulador e abaixo dos agregados $match e $group
existentes, adicione outro agregado $match para que possamos recuperar apenas resultados com um average_age que é maior ou igual a 35.
db.employees.aggregate([ {"$match":
{"salary": {"$lte": 70000}}}, {"$group": {"_id": "$dept",
"average_age": { "$média":
"$idade"} }
},
{"$match": {"average_age": {"$gte": 35}}} ])
O resultado é:
{
"_id": "IT",
"average_age": 31
}{
"_id": "Atendimento ao Cliente",

"idade_média": 34,5
}{
"_id": "Finanças",
"average_age": 32,5
}
Seção 8.7: obter dados de amostra

Para obter dados aleatórios de determinada coleção, consulte a agregação $sample .
db.emplyees.aggregate({ $sample: { tamanho:1 } })
onde tamanho representa o número de itens a serem selecionados.
Seção 8.8: Remover documentos que possuem um campo

duplicado em uma coleção (dedupe)
Observe que a opção allowDiskUse: true é opcional, mas ajudará a atenuar os problemas de falta de memória, pois essa agregação pode ser uma operação
que consome muita memória se o tamanho da sua coleção for grande - portanto, recomendo sempre usá-la.
var duplicatas = [];
db.transactions.aggregate([ { $group:
{ _id: { cr_dr:
"$cr_dr"}, dups: { "$addToSet":
"$_id" }, contagem: { "$sum": 1 }
} }, { $match:
{ count: { "$gt":
1 } }} ],allowDiskUse:
true} ) .result .forEach(function(doc)

{ doc.dups.shift(); doc.dups.forEach ( function(dupId){ duplicatas.push(dupId);
}
) }) // printjson(duplicados);
// Remova todas as duplicatas de uma só

vez db.transactions.remove({_id:{$in:duplicates}})
Seção 8.9: Junção externa esquerda com agregação ($Lookup)

deixe col_1 = db.collection('col_1'); deixe
col_2 = db.collection('col_2');
col_1 .aggregate([ { $match:
{ "_id": 1 } }, {
$lookup:
{ from: "col_2",
localField: "id",

ForeignField: "id", como:

"new_document"
}
}
],função (err, resultado)
{ res.send(resultado);
});
Este recurso foi lançado recentemente no mongodb versão 3.2 com os , que dá ao usuário um estágio para ingressar em uma coleção
atributos correspondentes de outra coleção
Documentação do Mongodb $ LookUp
Seção 8.10: Agregação de servidores

A solução de Andrew Mao. Consultas de agregação média no Meteor
Meteor.publish("someAggregation", function (args) {

var sub = este; //
Isso funciona para Meteor 0.6.5 var
db = MongoInternals.defaultRemoteCollectionDriver().mongo.db;
// Seus argumentos para a agregação do Mongo. Faça como quiser. var pipeline =
[ { $match:
doSomethingWith(args) }, { $group: {
_id: whatWeAreGroupingWith(args),
contagem: { $soma: 1 }
}}
];
db.collection("server_collection_name").aggregate( pipeline, // É necessário

encapsular
o retorno de chamada para que seja chamado em uma Fibra.
Meteor.bindEnvironment(
função(erro, resultado) {
// Adicione cada um dos resultados à assinatura.
_.each(resultado, função(e) {
// Gera um id descartável aleatório para documentos agregados
sub.added("client_collection_name", Random.id(), { key:
e._id.somethingOfInterest,
contagem: e.contagem
});
});
sub.pronto();
},
function(error)
"
{ Meteor._debug( "Erro ao fazer agregação: + erro);
}
)
);
});
Seção 8.11: Agregação em um método de servidor

Outra maneira de fazer agregações é usando Mongo.Collection#rawCollection()
Isso só pode ser executado no servidor.

Aqui está um exemplo que você pode usar no Meteor 1.3 e superior:
Meteor.methods({ 'aggregateUsers'(someId)
{ const collection = MyCollection.rawCollection() const
agregado = Meteor.wrapAsync(collection.aggregate, collection)
const match = { age: { $gte: 25 } } const

group = { _id:'$age', totalUsers: { $sum: 1 } }
resultados const =
agregado([ { $match:
match }, { $group: group }
])
resultados de retorno
}
})
Seção 8.12: Exemplo de Java e Spring

Este é um código de exemplo para criar e executar a consulta agregada no MongoDB usando Spring Data.
tente
{ MongoClient mongo = new MongoClient(); DB
db = mongo.getDB("so");
DBCollection coll = db.getCollection("funcionários");
// Equivalente a $match
DBObject matchFields = new BasicDBObject();
matchFields.put("depto", "Admin");
DBObject match = new BasicDBObject("$match", matchFields);
// Equivalente a $project
DBObject projectFields = new BasicDBObject();
projectFields.put("_id", 1);
projectFields.put("nome", 1);
projectFields.put("depto", 1);
projectFields.put("totalExp", 1);
projectFields.put("idade", 1);
projectFields.put("idiomas", 1); DBObject
project = new BasicDBObject("$project", projectFields);
// Equivalente a $group
DBObject groupFields = new BasicDBObject("_id", "$dept");
groupFields.put("ageSet", new BasicDBObject("$addToSet", "$age")); DBObject
employeeDocProjection = new BasicDBObject("$addToSet", novo
BasicDBObject("totalExp", "$totalExp").append("idade", "$idade").append("idiomas",
"$idiomas").append("dept", "$dept").append( "nome", "$nome"));
groupFields.put("docs", employeeDocProjection); DBObject
group = new BasicDBObject("$group", groupFields);
// Classificar resultados por idade

DBObject sort = new BasicDBObject("$sort", new BasicDBObject("idade", 1));
List<DBObject> agregaçãoList = new ArrayList<>();

aggregationList.add(correspondência);
agregaçãoList.add(projeto);
agregaçãoList.add(grupo);
aggregationList.add(sort);

AggregationOutput output = coll.aggregate(aggregationList);
for (resultado DBObject : output.results()) {

BasicDBList EmployeesList = (BasicDBList) result.get("docs");
BasicDBObject employeeDoc = (BasicDBObject) employeeList.get(0); String
nome = employeeDoc.get("nome").toString();
System.out.println(nome);
} }catch (Exceção ex){

ex.printStackTrace();
}
Consulte o valor "resultSet" no formato JSON para entender o formato de saída:
[{
"_id": "Admin",
"ageSet": [35.0, 30.0],
"docs":
[{ "totalExp": 11.0,
"age": 35.0,
"languages": ["english", "hindi"], "dept":
"Admin", "name":
"Anna" },
{ "totalExp": 10.0, "age":

30.0,
"languages": ["alemão", "francês", "inglês", "hindi" ], "dept": "Admin",
"nome": "Adma"
}]
}]
O "resultSet" contém uma entrada para cada grupo, "ageSet" contém a lista de idade de cada funcionário desse grupo, "_id" contém
o valor do campo que está sendo utilizado para agrupamento e "docs" contém os dados de cada funcionário desse grupo que
pode ser usado em nosso próprio código e interface do usuário.

Capítulo 9: Índices
Seção 9.1: Noções básicas de criação de índice
Veja a coleção de transações abaixo.
> db.transactions.insert({ cr_dr : "D", valor : 100, taxa : 2}); >

db.transactions.insert({ cr_dr : "C", valor : 100, taxa : 2}); > db.transactions.insert({ cr_dr :
"C", valor : 10, taxa : 2}); > db.transactions.insert({ cr_dr : "D", valor : 100, taxa : 4});
> db.transactions.insert({ cr_dr : "D", valor : 10, taxa : 2}); >
db.transactions.insert({ cr_dr : "C", valor : 10, taxa : 4}); > db.transactions.insert({ cr_dr :
"D", valor : 100, taxa : 2});
As funções getIndexes() mostrarão todos os índices disponíveis para uma coleção.
db.transactions.getIndexes();
Vamos ver a saída da declaração acima.
[
{
"v" : 1,
"chave" :
{ "_id" : 1
},
"name" : "_id_",
"ns" : "documentation_db.transactions"
}
]
Já existe um índice para coleta de transações. Isso ocorre porque o MongoDB cria um índice exclusivo no campo _id durante a criação de uma
coleção. O índice _id impede que os clientes insiram dois documentos com o mesmo valor para o campo _id . Você não pode descartar esse índice
no campo _id .
Agora vamos adicionar um índice para o campo cr_dr;
db.transactions.createIndex({ cr_dr : 1 });
O resultado da execução do índice é o seguinte.
{
"createdCollectionAutomatically" : falso,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2, "ok" :
1
}
O createdCollectionAutomatically indica se a operação criou uma coleção. Se uma coleção não existir, o MongoDB criará a coleção
como parte da operação de indexação.
Vamos executar db.transactions.getIndexes(); de novo.

{
"v" : 1,
"chave" :
{ "_id" : 1
},
"name" : "_id_",
},
{
"v" : 1,
"chave" :
{ "cr_dr" : 1
},
"name" : "cr_dr_1",
}
]
Agora você vê que a coleção de transações tem dois índices. Índice _id padrão e cr_dr_1 que criamos. O nome é atribuído pelo
MongoDB. Você pode definir seu próprio nome como abaixo.
db.transactions.createIndex({ cr_dr : -1 },{name : "index on cr_dr desc"})
Agora db.transactions.getIndexes(); lhe dará três índices.
[
{
"v" : 1,
"chave" :
{ "_id" : 1
},
"name" : "_id_",
},
{
"v" : 1,
"chave" :
{ "cr_dr" : 1
},
"name" : "cr_dr_1",
},
{
"v" : 1,
"chave" :
{ "cr_dr" : -1
},
"name" : "index on cr_dr desc", "ns" :
"documentation_db.transactions"
}
]
Ao criar o índice { cr_dr : -1 } 1 significa que o índice estará em ordem crescente e -1 em ordem decrescente .
Versão 2.4
índices de hash
Os índices também podem ser definidos como hash. Isso é mais eficaz em consultas de igualdade, mas não é eficiente para
consultas de intervalo; no entanto, você pode definir índices hash e ascendentes/descendentes no mesmo campo.

> db.transactions.createIndex({ cr_dr : "hashed" });
> db.transactions.getIndexes( [
{
"v" : 1,
"chave" :
{ "_id" : 1
},
"name" : "_id_",
},
{
"v" : 1,
"chave" :
{ "cr_dr" : "hashed"
},
"name" : "cr_dr_hashed", "ns" :
}
]
Seção 9.2: Descartando/Excluindo um Índice

Se o nome do índice for conhecido,
db.collection.dropIndex('name_of_index');
Se o nome do índice não for conhecido,
db.collection.dropIndex( { 'name_of_field' : -1 } );
Seção 9.3: índices esparsos e índices parciais

Índices esparsos:
Isso pode ser particularmente útil para campos opcionais, mas que também devem ser exclusivos.
{ "_id" : "john@example.com", "nickname" : "Johnnie" } { "_id" :

"jane@example.com" } { "_id" :
"julia@example.com", "nickname" : "Jules"} { "_id" :
"jack@example.com" }
Como duas entradas não têm "apelido" especificado e a indexação tratará os campos não especificados como nulos, a criação do índice falharia com 2 documentos
com 'nulo', portanto:
db.scores.createIndex( { apelido: 1 } , { exclusivo: verdadeiro, esparso: verdadeiro } )
permitirá que você ainda tenha apelidos 'nulos'.
Índices esparsos são mais compactos, pois ignoram/ignoram documentos que não especificam esse campo. Portanto, se você tiver uma coleção em que apenas
menos de 10% dos documentos especifiquem esse campo, poderá criar índices muito menores - aproveitando melhor a memória limitada se quiser fazer consultas
como:
db.scores.find({'apelido': 'Johnnie'})

Índices parciais:
Os índices parciais representam um superconjunto da funcionalidade oferecida pelos índices esparsos e devem ser preferidos aos
índices esparsos. (Novo na versão 3.2)
Índices parciais determinam as entradas de índice com base no filtro especificado.
db.restaurants.createIndex( { cozinha:
1 },
{ parcialFilterExpression: { rating: { $gt: 5 } } }
)
Se a classificação for superior a 5, a culinária será indexada. Sim, podemos especificar uma propriedade a ser indexada com base no valor de outras
propriedades também.
Diferença entre índices esparsos e parciais:
Índices esparsos selecionam documentos para indexar apenas com base na existência do campo indexado ou, para índices compostos, na existência
dos campos indexados.
Índices parciais determinam as entradas de índice com base no filtro especificado. O filtro pode incluir campos diferentes das chaves de índice e pode
especificar condições diferentes de apenas uma verificação de existência.
Ainda assim, um índice parcial pode implementar o mesmo comportamento de um índice esparso
Por exemplo:
db.contacts.createIndex( { nome:
1 },
{ parcialFilterExpression: { nome: { $existe: verdadeiro } } }
)
Observação: a opção parcialFilterExpression e a opção esparsa não podem ser especificadas ao mesmo tempo.
Seção 9.4: Obter índices de uma coleção
db.collection.getIndexes();
Saída
[
{
"v" : 1,
"chave" :
{ "_id" : 1
},
"name" : "_id_",
},
{
"v" : 1,
"chave" :
{ "cr_dr" : 1
},

"name" : "cr_dr_1",
},
{
"v" : 1,
"chave" :
{ "cr_dr" : -1
},
"name" : "index on cr_dr desc", "ns" :
}
]
Seção 9.5: Composto

db.people.createIndex({nome: 1, idade: -1})
Isso cria um índice em vários campos, neste caso nos campos de nome e idade . Será ascendente em nome e descendente
em idade.
Nesse tipo de índice, a ordem de classificação é relevante, pois determinará se o índice pode suportar uma operação de classificação
ou não. A classificação reversa é suportada em qualquer prefixo de um índice composto, desde que a classificação esteja na direção de
classificação reversa para todas as chaves na classificação. Caso contrário, a classificação de índices compostos precisa corresponder à
ordem do índice.
A ordem dos campos também é importante, neste caso o índice será ordenado primeiro por nome, e dentro de cada valor de nome, ordenado
pelos valores do campo idade . Isso permite que o índice seja usado por consultas no campo nome ou no nome e idade, mas não apenas na
idade .
Seção 9.6: Índice Único

db.collection.createIndex( { "user_id": 1 }, { exclusivo: verdadeiro } )
impõe exclusividade no índice definido (simples ou composto). A construção do índice falhará se a coleção já contiver valores
duplicados; a indexação também falhará com várias entradas sem o campo (uma vez que todas serão indexadas com o valor
nulo) , a menos que sparse: true seja especificado.
Seção 9.7: Campo único

db.pessoas.createIndex({nome: 1})
Isso cria um índice de campo único ascendente no nome do campo.
Nesse tipo de índice, a ordem de classificação é irrelevante, porque o mongo pode percorrer o índice em ambas as direções.
Seção 9.8: Excluir
Para descartar um índice, você pode usar o nome do índice
db.people.dropIndex("nameIndex")
Ou o documento de especificação do índice
db.pessoas.dropIndex({nome: 1})

Seção 9.9: Lista
db.pessoas.getIndexes()
Isso retornará uma matriz de documentos, cada um descrevendo um índice na coleção de pessoas

Capítulo 10: Operações em massa

Seção 10.1: Convertendo um campo para outro tipo e
atualizando toda a coleção em massa
Normalmente, quando se deseja alterar um tipo de campo para outro, por exemplo, a coleção original pode ter campos "numéricos"
ou "data" salvos como strings:
{
"nome": "Alice",
"salário": "57871",
"dob": "1986-08-21"
},
{
"nome": "Bob",
"salário": "48974",
"dob": "1990-11-04"
}
O objetivo seria atualizar uma enorme coleção como a acima para
{
"nome": "Alice",
"salário": 57871,
"dob": ISODate("1986-08-21T00:00:00.000Z")
},
{
"nome": "Bob",
"salário": 48974,
"dob": ISODate("1990-11-04T00:00:00.000Z")
}
Para dados relativamente pequenos, pode-se alcançar o acima iterando a coleção usando um instantâneo com o método
forEach() do cursor e atualizando cada documento da seguinte forma:
db.test.find({ "salary": { "$exists": true, "$type": 2 }, "dob":

{ "$exists": true, "$type": 2 }
}).snapshot().forEach(função(doc){
var newSalary = parseInt(doc.salary), newDob
= new ISODate(doc.dob);
db.test.updateOne( { "_id":
doc._id }, { "$set":
{ "salary": newSalary, "dob": newDob } }
);
});
Embora isso seja ideal para pequenas coleções, o desempenho com grandes coleções é bastante reduzido, pois percorrer um
grande conjunto de dados e enviar cada operação de atualização por solicitação ao servidor incorre em uma penalidade
computacional.
O Massa() A API ajuda e melhora muito o desempenho, pois as operações de gravação são enviadas ao servidor apenas
uma vez em massa. A eficiência é alcançada porque o método não envia todas as solicitações de gravação para o servidor (como
acontece com a instrução de atualização atual dentro do forEach() loop), mas apenas uma vez a cada 1.000 solicitações,
tornando as atualizações mais eficientes e rápidas do que atualmente.

Usando o mesmo conceito acima com o forEach() loop para criar os lotes, podemos atualizar a coleção em massa da seguinte maneira.
Nesta demonstração, o método Bulk() A API disponível nas versões do MongoDB >= 2.6 e < 3.2 usa o initializeUnorderedBulkOp()
método para executar em paralelo, bem como em uma ordem não determinística, as operações de gravação nos lotes.
Ele atualiza todos os documentos na coleção de clientes alterando os campos salario e dob para valores numéricos e de data e
hora , respectivamente:
var bulk = db.test.initializeUnorderedBulkOp(), contador =

0; // contador para acompanhar o tamanho da atualização do lote
db.test.find({ "salary": { "$exists": true, "$type": 2 }, "dob":

}).snapshot().forEach(função(doc){
var newSalary = parseInt(doc.salary), newDob
= new ISODate(doc.dob);
bulk.find({ "_id": doc._id }).updateOne({
"$set": { "salário": novoSalário, "dob": novoDob }
});
contador++; // incrementa contador if

(counter % 1000 == 0) {
bulk.execute(); // Executa a cada 1.000 operações e reinicializa a cada 1.000 atualizações
declarações
bulk = db.test.initializeUnorderedBulkOp();
}
});
O próximo exemplo se aplica ao novo MongoDB versão 3.2 , que desde então desativou o Bulk() API e forneceu um conjunto mais
recente de APIs usando bulkWrite().
Ele usa os mesmos cursores acima, mas cria os arrays com as operações em massa usando o mesmo forEach() cursor
para enviar cada documento de gravação em massa para a matriz. Como os comandos de gravação não podem aceitar
mais de 1.000 operações, é necessário agrupar operações para ter no máximo 1.000 operações e reinicializar a matriz
quando o loop atingir a iteração 1.000:
var cursor = db.test.find({

"salary": { "$exists": true, "$type": 2 }, "dob":
}),
bulkUpdateOps = [];
cursor.snapshot().forEach(function(doc){ var
newSalary = parseInt(doc.salary), newDob =
new ISODate(doc.dob);
bulkUpdateOps.push({ "updateOne": { "filter":

{ "_id ": doc._id }, "update": { "$set": { "salary": newSalary, "dob": newDob } }
}
});
if (bulkUpdateOps.length === 1000)

{ db.test.bulkWrite(bulkUpdateOps);
bulkUpdateOps = [];
}
});

if (bulkUpdateOps.length > 0) { db.test.bulkWrite(bulkUpdateOps); }

Capítulo 11: Índice 2dsphere

Seção 11.1: Criar um índice 2dsphere
O método db.collection.createIndex() é usado para criar um índice 2dsphere . O projeto de um índice 2dsphere :
db.collection.createIndex( { <campo de localização> : "2dsphere" } )
Aqui, o campo de localização é a chave e 2dsphere é o tipo do índice. No exemplo a seguir vamos criar um índice 2dsphre na
coleção de lugares .
db.places.insert( {
loc : { type: "Point", coordenadas: [ -73.97, 40.77 ] }, nome: "Central

Park", categoria : "Parks" })
A operação a seguir criará o índice 2dsphere no campo loc da coleção de locais .
db.places.createIndex( { loc : "2dsphere" } )

Capítulo 12: Mecanismos de armazenamento conectáveis

Seção 12.1: WiredTiger
WiredTiger suporta árvores LSM para armazenar índices. As árvores LSM são mais rápidas para operações de gravação quando você precisa gravar grandes cargas de
trabalho de inserções aleatórias.
No WiredTiger, não há atualizações no local. Se você precisar atualizar um elemento de um documento, um novo documento será inserido enquanto o documento antigo
será excluído.
O WiredTiger também oferece simultaneidade em nível de documento. Ele assume que duas operações de gravação não afetarão o mesmo documento, mas se afetarem,
uma operação será rebobinada e executada posteriormente. Isso é um grande aumento de desempenho se os retrocessos forem raros.
O WiredTiger oferece suporte aos algoritmos Snappy e zLib para compactação de dados e índices no sistema de arquivos. Snappy é o padrão. É menos intensivo em
CPU, mas tem uma taxa de compactação menor que o zLib.
Como usar o mecanismo WiredTiger
mongod --storageEngine wiredTiger --dbpath <newWiredTigerDBPath>
Observação:
1. Depois do mongodb 3.2, o mecanismo padrão é o WiredTiger. 2.
newWiredTigerDBPath não deve conter dados de outro mecanismo de armazenamento. Para migrar seus dados, você deve
despejá-los e reimportá-los no novo mecanismo de armazenamento.
mongodump --out <exportDataDestination> mongod

--storageEngine wiredTiger --dbpath <newWiredTigerDBPath> mongorestore
<exportDataDestination>
Seção 12.2: MMAP
MMAP é um mecanismo de armazenamento conectável que recebeu o nome do comando mmap() do Linux. Ele mapeia os arquivos para a memória virtual e otimiza as
chamadas de leitura. Se você tem um arquivo grande, mas precisa ler apenas uma pequena parte dele, mmap() é muito mais rápido do que uma chamada read() que
traria o arquivo inteiro para a memória.
Uma desvantagem é que você não pode ter duas chamadas de gravação sendo processadas em paralelo para a mesma coleção. Portanto, o MMAP possui bloqueio
no nível da coleção (e não no nível do documento, como o WiredTiger oferece). Esse bloqueio de coleção é necessário porque um índice MMAP pode fazer referência a
vários documentos e, se esses documentos pudessem ser atualizados simultaneamente, o índice seria inconsistente.
Seção 12.3: Na memória

Todos os dados são armazenados na memória (RAM) para leitura/acesso mais rápido.
Seção 12.4: mongo-rochas

Um mecanismo de chave-valor criado para integrar-se ao RocksDB do Facebook.
Seção 12.5: Fusão-io
Um mecanismo de armazenamento criado pela SanDisk que permite ignorar a camada do sistema de arquivos do sistema operacional e gravar diretamente

o dispositivo de armazenamento.
Seção 12.6: TokuMX
Um mecanismo de armazenamento criado pela Percona que usa índices de árvore fractal.

Capítulo 13: Driver Java

Seção 13.1: Buscar dados de coleta com condição
Para obter dados da coleção testcollection no banco de dados testdb onde name=dev
import org.bson.Document;
importar com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection; import
com.mongodb.client.MongoCursor; import
com.mongodb.client.MongoDatabase;
MongoClient mongoClient = new MongoClient(new ServerAddress("localhost", 27017)); MongoDatabase

db = mongoClient.getDatabase("testdb"); Coleção
MongoCollection<Documento> = db.getCollection("testcollection");
BasicDBObject searchQuery = new BasicDBObject();

searchQuery.put("nome","dev");
MongoCursor<Documento> cursor = collection.find(searchQuery).iterator(); tente { while
(cursor.hasNext())
{ System.out.println(cursor.next().toJson());
} } finalmente
{ cursor.close();
}
Seção 13.2: Criar um usuário de banco de dados
Para criar um usuário dev com senha password123
MongoClient mongo = new MongoClient("localhost", 27017);

MongoDatabase db = mongo.getDatabase("testDB");
Map<String, Object> commandArguments = new BasicDBObject();
commandArguments.put("createUser", "dev");
commandArguments.put("pwd", "senha123"); String[]
funções = { "readWrite" };
commandArguments.put("funções", funções);
Comando BasicDBObject = new BasicDBObject(commandArguments);
db.runCommand(comando);
Seção 13.3: Criar um cursor ajustável
find(consulta).projection(campos).cursorType(CursorType.TailableAwait).iterator();
Esse código se aplica à classe MongoCollection .
CursorType é uma enumeração e possui os seguintes valores:
Ajustável
TailableAwait
Correspondente aos tipos DBCursor addOption Bytes antigos (<3.0):

Bytes.QUERYOPTION_TAILABLE
Bytes.QUERYOPTION_AWAITDATA

Capítulo 14: Driver Python

Parâmetro Detalhe
hostX Opcional. Você pode especificar quantos hosts forem necessários. Você especificaria vários hosts, por exemplo, para
conexões com conjuntos de réplicas.
:portX Opcional. O valor padrão é: 27017 se não for especificado.
Opcional. O nome do banco de dados a ser autenticado se a string de conexão incluir credenciais de autenticação
base de dados Se /database não for especificado e a string de conexão incluir credenciais, o driver será autenticado no banco de
dados admin.
?options Opções específicas de conexão
Seção 14.1: Conecte-se ao MongoDB usando pymongo

de pymongo importar MongoClient
uri = "mongodb://localhost:27017/"
cliente = MongoCliente(uri)
banco de dados = cliente['db_teste']

# ou
# db = client.test_db
# coleção = db['test_collection'] # ou coleção =
db.test_collection
coleção.save({"olá":"mundo"})
imprimir coleção.find_one()
Seção 14.2: consultas PyMongo

Depois de obter um objeto de coleção , as consultas usam a mesma sintaxe do shell mongo. Algumas pequenas diferenças são:
cada chave deve ser colocada entre colchetes. Por exemplo:
db.find({frequências: {$existe: verdadeiro}})
torna-se em pymongo (observe o True em maiúsculas):
db.find({"frequências": { "$existem": Verdadeiro }})
objetos como ids de objeto ou ISODate são manipulados usando classes python. PyMongo usa seu próprio ObjectId class para
lidar com IDs de objetos, enquanto as datas usam o pacote datetime padrão . Por exemplo, se você deseja consultar todos
os eventos entre 2010 e 2011, pode fazer:
de data e hora importar data e hora
date_from = datetime(2010, 1, 1) date_to

= datetime(2011, 1, 1) db.find({ "date":
{ "$gte": date_from, "$lt": date_to } }):

Seção 14.3: Atualizar todos os documentos em uma coleção

usando PyMongo
Digamos que você precise adicionar um campo a cada documento em uma coleção.
importar pymongo
cliente = pymongo.MongoClient('localhost', 27017) db =

cliente.mydb.mycollection
para doc em db.find():
db.update( {'_id': doc['_id']},

{'$set': {'newField': 10} }, upsert=False, multi=False)
O método find retorna um Cursor, no qual você pode iterar facilmente usando o for na sintaxe. Em seguida, chamamos o método update ,
especificando o _id e adicionamos um campo ($set). Os parâmetros upsert e multi vêm do mongodb (veja aqui para mais informações).

Capítulo 15: Mongo como fragmentos

Seção 15.1: Configuração do ambiente de fragmentação
Membros do grupo de fragmentação:
Para sharding, existem três jogadores.
1. Servidor de configuração
2. Conjuntos de réplicas
3. Mongos
Para um fragmento mongo, precisamos configurar os três servidores acima.
Configuração do servidor de configuração: adicione o seguinte ao arquivo mongod conf
fragmentação: clusterRole: configsvr

replicação:
replSetName: <setname>
execute: mongod --config
podemos escolher o servidor de configuração como conjunto de réplicas ou pode ser um servidor autônomo. Com base em nossa exigência, podemos escolher o melhor. Se a
configuração precisar ser executada no conjunto de réplicas, precisamos seguir a configuração do conjunto de réplicas
Configuração da réplica: Criar conjunto de réplicas // Consulte a configuração da réplica
Configuração do MongoS: Mongos é a configuração principal no shard. É um roteador de consulta para acessar todos os conjuntos de réplicas
Adicione o seguinte no arquivo conf do mongos
fragmentação: configDB: <configReplSetName>/cfg1.example.net:27017;
Configurar compartilhado:
Conecte os mongos via shell (mongo --host --port )
1. sh.addShard( "/s1-mongo1.example.net:27017") 2. sh.enableSharding("")
3. sh.shardCollection("< banco de
dados >.< coleção >", { < chave > : < direção > } ) 4. sh.status() // Para garantir a fragmentação

Capítulo 16: Replicação

Seção 16.1: Configuração básica com três nós
O conjunto de réplicas é um grupo de instâncias mongod que mantêm o mesmo conjunto de dados.
Este exemplo mostra como configurar um conjunto de réplicas com três instâncias no mesmo servidor.
Criando pastas de dados
mkdir /srv/mongodb/data/rs0-0 mkdir /

srv/mongodb/data/rs0-1 mkdir /srv/
mongodb/data/rs0-2
Iniciando instâncias mongod
mongod --port 27017 --dbpath /srv/mongodb/data/rs0-0 --replSet rs0 mongod --port

27018 --dbpath /srv/mongodb/data/rs0-1 --replSet rs0 mongod --port 27019 - -dbpath /
srv/mongodb/data/rs0-2 --replSet rs0
Configurando o conjunto de réplicas
mongo --port 27017 // conexão com a instância 27017
rs.initiate(); // inicialização do conjunto de réplicas no 1º nó // adicionando

rs.add("<nome do host>:27018") um 2º nó // adicionando
rs.add("<nome do host>:27019") um 3º nó
Testando sua configuração
Para verificar o tipo de configuração rs.status(), o resultado deve ser como:
{
"set" : "rs0",
"date" : ISODate("2016-09-01T12:34:24.968Z"), "myState" :
1, "term" :
NumberLong(4),
"heartbeatIntervalMillis" : NumberLong(2000 ), [ "membros" :
{
"_id" : 0,
"nome" : "<hostname>:27017",
"saúde" : 1,
"estado" : 1,
"stateStr" : "PRIMARY",
..........................
},
{
"_id" : 1,
"nome" : "<hostname>:27018",
"saúde" : 1,
"estado" : 2,
"stateStr" : "SECONDARY",
..........................
},
{
"_id" : 2,
"nome" : "<nome do host>:27019",

"saúde" : 1,
"estado" : 2,
"estadoStr" : "SECONDARY",
..........................
}
],
"ok" : 1
}

Capítulo 17: Mongo como um conjunto de réplicas

Seção 17.1: Mongodb como um conjunto de réplicas
Estaríamos criando o mongodb como um conjunto de réplicas com 3 instâncias. Uma instância seria primária e as outras 2 instâncias seriam
secundárias.
Para simplificar, terei uma réplica definida com 3 instâncias do mongodb em execução no mesmo servidor e, portanto, para conseguir isso, todas as
três instâncias do mongodb seriam executadas em diferentes números de porta.
No ambiente de produção, onde você tem uma instância mongodb dedicada em execução em um único servidor, pode reutilizar os mesmos
números de porta.
1. Crie diretórios de dados (caminho onde os dados mongodb seriam armazenados em um arquivo)
- mkdir c:\data\server1 (caminho do arquivo de dados para a instância 1)

2. a. Inicie a primeira instância mongod
Abra o prompt de comando e digite o seguinte pressione enter.
mongod --replSet s0 --dbpath c:\data\server1 --port 37017 --smallfiles --oplogSize 100
O comando acima associa a instância do mongodb a um nome replicaSet "s0" e inicia a primeira instância do mongodb na porta 37017 com oplogSize
100 MB
2. b. Da mesma forma, inicie a segunda instância do Mongodb
100 MB
2. c. Agora inicie a terceira instância do Mongodb
100 MB
Com todas as 3 instâncias iniciadas, essas 3 instâncias são independentes umas das outras atualmente. Agora precisaríamos agrupar essas
instâncias como um conjunto de réplicas. Fazemos isso com a ajuda de um objeto de configuração.
3.a Conecte-se a qualquer um dos servidores mongod por meio do shell mongo. Para fazer isso, abra o prompt de comando e digite.
mongo --port 37017
Uma vez conectado ao shell mongo, crie um objeto de configuração
var config = {"_id":"s0", membros[]};
este objeto de configuração tem 2 atributos

1. _id: o nome da réplica Set ( "s0" ) 2. members: []

(members é um array de instâncias mongod. vamos deixar em branco por enquanto, vamos adicionar
membros através do comando push.
3.b Para enviar (adicionar) instâncias mongod ao array de membros no objeto de configuração. No tipo de shell mongo
config.members.push({"_id":0,"host":"localhost:37017"});
Atribuímos a cada instância mongod um _id e um host. _id pode ser qualquer número exclusivo e o host deve ser o nome do host do servidor
no qual está sendo executado, seguido pelo número da porta.
4. Inicie o objeto de configuração com o seguinte comando no shell mongo.
rs.initiate(config)
5. Aguarde alguns segundos e teremos um conjunto de réplicas de 3 instâncias mongod em execução no servidor. digite o
seguinte comando para verificar o status do conjunto de réplicas e identificar qual é o principal e qual é o secundário.
rs.status();
Seção 17.2: Verifique os estados do conjunto de réplicas do MongoDB
Use o comando abaixo para verificar o status do conjunto de réplicas.
Comando : rs.status()
Conecte qualquer um dos membros da réplica e acione este comando, ele fornecerá o estado completo do conjunto de réplicas
Exemplo :
{ "set" : "ReplicaName",
"date" : ISODate("2016-09-26T07:36:04.935Z"),
"myState" : 1,
"term" : NumberLong(-1),
"heartbeatIntervalMillis" : NumberLong (2000),
[ "membros" :
{
"_id" : 0,
"name" : "<IP>:<PORT>,
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 5953744,
"optime" : timestamp (1474875364, 36),
"optimeDate" : ISODate("2016-09-26T07:36:04Z"),
"electionTime" : Timestamp(1468921646, 1),
"electionDate" : ISODate("2016-07-19T09:47 :26Z"),
"configVersion" : 6,
"self" : verdadeiro
},
{
"_id" : 1,
"nome" : "<IP>:<PORT>",
"saúde" : 1,

"state" : 2,
"uptime" : 5953720,
"optime" : Timestamp(1474875364, 13),
"optimeDate" : ISODate("2016-09-26T07:36:04Z"), "lastHeartbeat" :
ISODate("2016-09-26T07:36:04.244Z"), "lastHeartbeatRecv" :
ISODate("2016-09-26T07:36:03.871Z"), "pingMs" : NumberLong(0), " syncingTo" :
"10.9.52.55:10050", "configVersion" :
6
},
{
"_id" : 2,
"name" : "<IP>:<PORT>",
"health" : 1,
"state" : 7,
"stateStr" : "ARBITER",
"uptime" : 5953696,
"lastHeartbeat" : ISODate("2016-09-26T07:36:03.183Z"), "lastHeartbeatRecv" :
ISODate("2016-09-26T07:36:03.715Z"), "pingMs" : NumberLong(0),
"configVersion" : 6
},
{
"_id" : 3,
"name" : "<IP>:<PORT>",
"health" : 1,
"state" : 2,
"uptime" : 1984305,
"optime" : Timestamp(1474875361, 16),
"optimeDate" : ISODate("2016-09-26T07:36:01Z"), "lastHeartbeat" :
ISODate("2016-09-26T07:36:02.921Z"), "lastHeartbeatRecv" :
ISODate("2016-09-26T07:36:03.793Z"), "pingMs" : NumberLong(22),
"lastHeartbeatMessage" :
"sincronizando de: 10.9.52.56:10050", "syncingTo" : "10.9.52.56:10050 ",
"configVersion" : 6
}
],
"ok" : 1 }
A partir do exposto, podemos conhecer todo o status do conjunto de réplicas

Capítulo 18: MongoDB - Configurar um

ReplicaSet para suportar TLS/SSL
Como configurar um ReplicaSet para suportar TLS/SSL?
Implantaremos um ReplicaSet de 3 nós em seu ambiente local e usaremos um certificado autoassinado. Não use um certificado autoassinado
em PRODUCTION.
Como conectar seu Client a este ReplicaSet?
Vamos conectar um Mongo Shell.
Uma descrição dos certificados TLS/ SSL, PKI (Public Key Infrastructure) e Autoridade de Certificação está além do escopo desta
documentação.
Seção 18.1: Como configurar um ReplicaSet para

suportar TLS/SSL?
Criar o certificado raiz
O certificado raiz (também conhecido como arquivo CA) será usado para assinar e identificar seu certificado. Para gerá-lo, execute o comando
abaixo.
openssl req -nodes -out ca.pem -new -x509 -keyout ca.key
Guarde o certificado raiz e sua chave com cuidado, ambos serão usados para assinar seus certificados. O certificado raiz também pode ser
usado por seu cliente.
Gere as Solicitações de Certificado e as Chaves Privadas
Ao gerar a solicitação de assinatura de certificado (também conhecida como CSR), insira o nome de host exato (ou IP) do seu nó no campo
Nome comum (também conhecido como CN). Os demais campos devem ter exatamente o mesmo valor. Pode ser necessário modificar
seu arquivo /etc/ hosts .
Os comandos abaixo vão gerar os arquivos CSR e as Chaves Privadas RSA (4096 bits).
openssl req -nodes -newkey rsa:4096 -sha256 -keyout mongodb_node_1.key -out mongodb_node_1.csr openssl req
-nodes -newkey rsa:4096 -sha256 -keyout mongodb_node_2.key -out mongodb_node_2.csr openssl req -nodes -newkey
rsa: 4096 -sha256 -keyout mongodb_node_3.key -out mongodb_node_3.csr
Você deve gerar um CSR para cada nó de seu ReplicaSet. Lembre-se que o Common Name não é o mesmo de um nó para outro. Não
baseie vários CSRs na mesma chave privada.
Agora você deve ter 3 CSRs e 3 chaves privadas.
mongodb_node_1.key - mongodb_node_2.key - mongodb_node_3.key

mongodb_node_1.csr - mongodb_node_2.csr - mongodb_node_3.csr
Assine suas solicitações de certificado
Use o Arquivo CA (ca.pem) e sua Chave Privada (ca.key) gerada anteriormente para assinar cada Solicitação de Certificado
executando os comandos abaixo.

openssl x509 -req -in mongodb_node_1.csr -CA ca.pem -CAkey ca.key -set_serial 00 -out mongodb_node_1.crt
openssl x509 -req -in
mongodb_node_2.csr -CA ca.pem -CAkey ca.key -set_serial 00 - out mongodb_node_2.crt openssl x509 -req -in
mongodb_node_3.csr
-CA ca.pem -CAkey ca.key -set_serial 00 -out mongodb_node_3.crt
Você deve assinar cada CSR.
Agora você deve ter 3 CSRs, 3 chaves privadas e 3 certificados autoassinados. Somente as Chaves Privadas e os Certificados serão
usados pelo MongoDB.
mongodb_node_1.key - mongodb_node_2.key - mongodb_node_3.key

mongodb_node_1.csr - mongodb_node_2.csr - mongodb_node_3.csr
mongodb_node_1.crt - mongodb_node_2.crt - mongodb_node_3.crt
Cada certificado corresponde a um nó. Lembre-se cuidadosamente de qual CN / nome de host você deu a cada CSR.
Concatene cada certificado de nó com sua chave
Execute os comandos abaixo para concatenar cada certificado de nó com sua chave em um arquivo (requisito do MongoDB).
cat mongodb_node_1.key mongodb_node_1.crt > mongodb_node_1.pem cat

mongodb_node_2.key mongodb_node_2.crt > mongodb_node_2.pem cat
mongodb_node_3.key mongodb_node_3.crt > mongodb_node_3.pem
Agora você deve ter 3 arquivos PEM.
mongodb_node_1.pem - mongodb_node_2.pem - mongodb_node_3.pem
Implante seu ReplicaSet
Assumiremos que seus arquivos pem estão localizados em sua pasta atual, bem como data/data1, data/data2 e data/data3.
Execute os comandos abaixo para implantar seu ReplicaSet de 3 nós escutando nas portas 27017, 27018 e 27019.
mongod --dbpath data/data_1 --replSet rs0 --port 27017 --sslMode requireSSL --sslPEMKeyFile mongodb_node_1.pem
mongod --dbpath data/
data_2 --replSet rs0 --port 27018 --sslMode requireSSL --sslPEMKeyFile mongodb_node_2.pem mongod --dbpath data/
data_3 --replSet rs0 --
port 27019 --sslMode requireSSL --sslPEMKeyFile mongodb_node_3.pem
Agora você tem um ReplicaSet de 3 nós implantado em seu ambiente local e todas as suas transações são criptografadas.
Você não pode se conectar a este ReplicaSet sem usar TLS.
Implante seu ReplicaSet para SSL Mútuo / Confiança Mútua
Para forçar seu cliente a fornecer um Certificado de Cliente (SSL Mútuo), você deve adicionar o Arquivo CA ao executar suas
instâncias.
mongod --dbpath data/data_1 --replSet rs0 --port 27017 --sslMode requireSSL --sslPEMKeyFile mongodb_node_1.pem --
sslCAFile ca.pem mongod --dbpath data/data_2
--replSet rs0 --port 27018 --sslMode requireSSL --sslPEMKeyFile

mongodb_node_2.pem --sslCAFile ca.pem

mongod --dbpath data/data_3 --replSet rs0 --port 27019 --sslMode requireSSL --sslPEMKeyFile mongodb_node_3.pem --
sslCAFile ca.pem
Agora você tem um ReplicaSet de 3 nós implantado em seu ambiente local e todas as suas transações são criptografadas.
Você não pode se conectar a este ReplicaSet sem usar TLS ou sem fornecer um certificado de cliente confiável para sua autoridade de certificação.
Seção 18.2: Como conectar seu cliente (Mongo Shell) a um

ReplicaSet?
Sem SSL Mútuo
Neste exemplo, podemos usar o arquivo CA (ca.pem) que você gerou durante a seção "Como configurar um ReplicaSet para oferecer suporte
a TLS/ SSL?" seção. Assumiremos que o arquivo CA está localizado em sua pasta atual.
Assumiremos que seus 3 nós estão sendo executados em mongo1:27017, mongo2:27018 e mongo3:27019. (Talvez seja necessário modificar
seu arquivo /etc/ hosts .)
No MongoDB 3.2.6, se o arquivo CA estiver registrado no Trust Store do sistema operacional, você poderá se conectar ao ReplicaSet sem
fornecer o arquivo CA.
mongo --ssl --host rs0/mongo1:27017,mongo2:27018,mongo3:27019
Caso contrário, você deve fornecer o arquivo CA.
mongo --ssl --sslCAFile ca.pem --host rs0/mongo1:27017,mongo2:27018,mongo3:27019
Agora você está conectado ao seu ReplicaSet e todas as transações entre seu Mongo Shell e seu ReplicaSet são criptografadas.
Com SSL Mútuo
Se o seu ReplicaSet solicitar um certificado de cliente, você deverá fornecer um assinado pela CA usada pela implantação do ReplicaSet.
Os passos para gerar o Certificado de Cliente são quase os mesmos para gerar o Certificado de Servidor.
De fato, você só precisa modificar o Common Name Field durante a criação do CSR. Em vez de fornecer 1 nome de host do nó no campo de
nome comum, você precisa fornecer todos os nomes de host do ReplicaSet separados por um
vírgula.
openssl req -nodes -newkey rsa:4096 -sha256 -keyout mongodb_client.key -out mongodb_client.csr
...
Nome comum (por exemplo, FQDN do servidor ou SEU nome) []: mongo1,mongo2,mongo3
Você pode enfrentar a limitação de tamanho do Nome comum se o campo Nome comum for muito longo (mais de 64 bytes).
Para ignorar essa limitação, você deve usar o SubjectAltName ao gerar o CSR.
openssl req -nodes -newkey rsa:4096 -sha256 -keyout mongodb_client.key -out mongodb_client.csr - config <( cat <<-EOF
[req]
default_bits = 4096
prompt = sem
default_md = sha256
req_extensions = req_ext

nome_ilustre = dn
[ dn ]
NC = .
[ req_ext ]
subjectAltName = @alt_names
[ alt_names ]
DNS.1 = mongo1
DNS.2 = mongo2
DNS.3 = mongo3
EOF )
Em seguida, você assina o CSR usando o certificado e a chave da CA.
openssl x509 -req -in mongodb_client.csr -CA ca.pem -CAkey ca.key -set_serial 00 -out mongodb_client.crt
Finalmente, você concatena a chave e o certificado assinado.
cat mongodb_client.key mongodb_client.crt > mongodb_client.pem
Para se conectar ao seu ReplicaSet, agora você pode fornecer o certificado de cliente recém-gerado.
mongo --ssl --sslCAFile ca.pem --host rs0/mongo1:27017,mongo2:27018,mongo3:27019 --sslPEMKeyFile mongodb_client.pem
Agora você está conectado ao seu ReplicaSet e todas as transações entre seu Mongo Shell e seu ReplicaSet são criptografadas.

Capítulo 19: Mecanismos de Autenticação em

MongoDBGenericName
A autenticação é o processo de verificação da identidade de um cliente. Quando o controle de acesso, ou seja, a autorização, está ativado, o
MongoDB exige que todos os clientes se autentiquem para determinar seu acesso.
O MongoDB oferece suporte a vários mecanismos de autenticação que os clientes podem usar para verificar sua identidade. Esses
mecanismos permitem que o MongoDB se integre ao seu sistema de autenticação existente.
Seção 19.1: Mecanismos de Autenticação
O MongoDB oferece suporte a vários mecanismos de autenticação.
Mecanismos de autenticação de clientes e usuários
SCRAM-SHA-1
Autenticação de certificado X.509
Desafio e resposta do MongoDB (MONGODB-CR)
Autenticação de proxy LDAP e
Autenticação Kerberos
Mecanismos de Autenticação Interna
Arquivo-
chave X.509

Capítulo 20: Modelo de autorização do MongoDB

A autorização é basicamente a verificação dos privilégios do usuário. O MongoDB suporta diferentes tipos de modelos de autorização. 1.
Controle de acesso à base de funções <br> Funções são grupos de privilégios, ações sobre recursos. Isso é ganho para os usuários em um determinado
namespace (Banco de dados). As ações são executadas nos recursos. Os recursos são qualquer objeto que mantém o estado no banco de dados.
Seção 20.1: Funções incorporadas
Funções de usuário de banco de dados integradas e funções de administração de banco de dados existem em cada banco de dados.
Funções do usuário do banco de dados
1. leia
2. ler e escrever

Capítulo 21: Configuração

Parâmetro Padrão
systemLog.verbosity 0
systemLog.quiet falso
systemLog.traceAllExceptions falso
systemLog.syslogFacility do utilizador
-
systemLog.path
systemLog.logAppend falso
systemLog.logRotate renomear
systemLog.destination stdout
systemLog.timeStampFormat iso8601-local
systemLog.component.accessControl.verbosity 0
systemLog.component.command.verbosity 0
systemLog.component.control.verbosity 0
systemLog.component.ftdc.verbosity 0
systemLog.component.geo.verbosity 0
systemLog.component.index.verbosity 0
systemLog.component.network.verbo 0
systemLog.component.query.verbosity 0
systemLog.component.replication.verbosity 0
systemLog.component.sharding.verbosity 0
systemLog .component.storage.verbosity 0
systemLog.component.storage.journal.verbosity 0
systemLog.component.write.verbosity 0
processManagement.fork falso
processManagement.pidFilePath nenhum
net.port 27017
net.bindIp 0.0.0.0
net.maxIncomingConnections 65536
net.wireObjectCheck verdadeiro
net.ipv6 falso
net.unixDomainSocket.enabled verdadeiro
net.unixDomainSocket.pathPrefix /tmp
net.unixDomainSocket.filePermissions 0700
net.http.enabled falso
net.http.JSONPEnabled falso
net.http.RESTInterfaceEnabled falso
net.ssl.sslOnNormalPorts falso
net.ssl.mode desabilitado
net.ssl.PEMKeyFile nenhum
net.ssl.PEMKeyPassword nenhum
net.ssl.clusterFile nenhum
net.ssl.clusterSenha nenhum
net.ssl.CAFile nenhum

net.ssl.CRLFile nenhum
net.ssl.allowConnectionsWithoutCertificates falso
net.ssl.allowInvalidCertificates falso
net.ssl.allowInvalidHostnames falso
net.ssl.disabledProtocols nenhum
net.ssl.FIPSMode falso
Seção 21.1: Iniciando o mongo com um arquivo de configuração específico
Usando o sinalizador --config .
$ /bin/mongod --config /etc/mongod.conf $ /bin/

mongos --config /etc/mongos.conf
Observe que -f é o sinônimo mais curto para --config.

Capítulo 22: Fazendo backup e restaurando

Dados
Seção 22.1: Mongodump básico da instância mongod
padrão local
mongodump --db meudb --gzip --out "meudb.dump.$(data +%F_%R)"
Este comando irá despejar um arquivo bson gzipado de seu banco de dados mongod 'mydb' local para o diretório 'mydb.dump.
{timestamp}'
Seção 22.2: Mongorestore básico do dump mongod padrão

local
mongorestore --db mydb mydb.dump.2016-08-27_12:44/mydb --drop --gzip
Este comando primeiro eliminará seu banco de dados 'mydb' atual e, em seguida, restaurará seu despejo bson gzipado do arquivo de despejo do arquivo
'mydb mydb.dump.2016-08-27_12:44/mydb'.
Seção 22.3: mongoimport com JSON

Exemplo de conjunto de dados de código postal em zipcodes.json armazenado em c:\Users\yc03ak1\Desktop\zips.json
{ "_id" : "01001", "cidade" : "AGAWAM", "loc" : [ -72.622739, 42.070206 ], "pop" : 15338, "estado" :
"MA" }
{ "_id" : "01002", "cidade" : "CUSHMAN", "loc" : "estado" : [ -72.51564999999999, 42.377017 ], "pop" : 36963,
"MA" } { "_id" :
"01005", "cidade" : "BARRE", "loc" : "estado" : "MA" } [ -72.10835400000001, 42.409698 ], "pop" : 4546,
{ "_id" : "01007",
"cidade" : "BELCHERTOWN", "loc" : 10579, "estado" : "MA" } [ -72.41095300000001, 42.275103 ], "pop" :
{ "_id" : "01008 ", "cidade" :
"BLANDFORD", "local" : [ -72.936114, 42.182949 ], "pop" : 1240, "estado" :
"MA" }
{ "_id" : "01010", "cidade" : "BRIMFIELD", "loc" : [ -72.188455, 42.116543 ], "pop" : 3706, "estado" :
"MA" }
{ "_id" : "01011", "cidade" : "CHESTER", "loc" : [ -72.988761, 42.279421 ], "pop" : 1688, "estado" :
"E" }
para importar este conjunto de dados para o banco de dados denominado "teste" e a coleção denominada "zips"
C:\Users\yc03ak1>mongoimport --db test --collection "zips" --drop --type json --host "localhost:47019" --file "c:
\Users\yc03ak1\Desktop\zips.json"
--db : nome do banco de dados para o qual os dados serão importados --collection:
nome da coleção no banco de dados para o qual os dados serão importados --drop : descarta a coleção antes
de importar --type : tipo de documento que precisa a ser importado.
padrão JSON --host : host mongodb e porta na qual os dados devem ser importados. --
file : caminho onde está o arquivo json
saída :
2016-08-10T20:10:50.159-0700 conectado a: localhost:47019

2016-08-10T20:10:50.163-0700 descartando: test.zips

2016-08-10T20:10:53.155-0700 [################........] test.zips [############## 2,1 MB/3,0 MB (68,5%)
2016-08-10T20:10:56.150-0700 #########] test.zips [########################] 3,0 MB/3,0 MB (100,0%)
2016-08-10T20:10:57.819-0700 2016- test.zips importou 29353 documentos 3,0 MB/3,0 MB (100,0%)
08-10T20: 10:57.821-0700
Seção 22.4: mongoimport com CSV

Arquivo CSV do conjunto de dados de teste de amostra armazenado no local c:\Users\yc03ak1\Desktop\testing.csv
_id cidade loc [10.0, pop estado

A 20.0] [10.1, 20.1] 2222 PQE
B [10.2, 20.0] [10.3, 22122
123 C 20.3] [10.4, 20.0] RW DELA
4 D 255222 226622 SFDS
5 E 222122 FDS
para importar este conjunto de dados para o banco de dados denominado "teste" e a coleção denominada "amostra"
C:\Users\yc03ak1>mongoimport --db test --collection "sample" --drop --type csv --headerline --host "localhost:47019" --file "c:\Users\yc03ak1\Desktop\testing .csv"
--headerline: use a primeira linha do arquivo csv como os campos para o documento json
saída :
2016-08-10T20:25:48.572-0700 conectado a: localhost:47019 descartando:

2016-08-10T20:25:48.576-0700 test.sample importou 5
2016-08-10T20:25:49.109-0700 documentos
OU
C:\Users\yc03ak1>mongoimport --db test --collection "sample" --drop --type csv --fields _id,city,loc,pop,state --host "localhost:47019" --file
"c :\Users\yc03ak1\Desktop\testing.csv"
--fields : lista separada por vírgulas de campos que precisam ser importados no documento json. Saída:
2016-08-10T20:26:48.978-0700 conectado a: localhost:47019 descartando:

2016-08-10T20:26:48.982-0700 test.sample importou 6
2016-08-10T20:26:49.611-0700 documentos

Capítulo 23: Atualizando a versão do MongoDB

Como atualizar a versão do MongoDB em sua máquina em diferentes plataformas e versões.
Seção 23.1: Atualizando para 3.4 no Ubuntu 16.04 usando o apt

Você deve ter 3.2 para poder atualizar para 3.4. Este exemplo assume que você está usando o apt.
1. sudo service mongod stop 2.

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv
0C49F3730359A14518585931BC711F9BA15703C6
3. echo "deb [arch=amd64,arm64] http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.4
multiverso" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.4.list
4. sudo apt-get update 5.
sudo apt-get upgrade 6.
sudo service mongod start
Certifique-se de que a nova versão esteja sendo executada com mongo. O shell imprimirá a versão do servidor MongoDB que deve ser
3.4 agora.

Créditos
Muito obrigado a todas as pessoas da Stack Overflow Documentation que ajudaram a fornecer este conteúdo, mais
alterações podem ser enviadas para web@petercv.com para novos conteúdos a serem publicados ou atualizados
Abdul Rehman disse Capítulo 1

ADIMO Capítulo 16
Antti_M Capítulo 23
Ashari Capítulo 1
Avindu Hewa Capítulo 4
bapr Capítulo 18
Batsu Capítulo 9
chridam Capítulo 10
Constantin Guay Capítulos 9 e 12
Derlin devtsu Capítulo 14
_ See More Capítulo 13
Emil Burzo Capítulo 13
Anamul Hassan Capítulos 1 e 8
frach Capítulos 2 e 3
cigano Capítulo 8
de uva Capítulo 11
Hoef Meistert Capítulo 8
trago Capítulo 1
Ishan Soni Capítulo 2
jain Capítulo 2
jerry Capítulo 2
Johnny HK Capítulo 2
Juan Carlos Farah Capítulo 9
Kelum Senanayake Capítulo 2
KrisVos130 Capítulo 2
Cozinhou Capítulo 6
Lakmal Vithanage Capítulos 2 e 8
LoicM Capítulo 8
Luzan Baral Capítulo 19
Marco Capítulo 2
Matt Clark Capítulo 21
Nic Cottrell Capítulo 9
Niroshan Ranapathi Capítulos 19 e 20
ogg Capítulo 4
Prasen Ghosh Capítulos 1, 2, 4 e 7
RaR Capítulos 8 e 9
Renukaradhya Capítulos 1 e 2
vermelho Capítulo 2
Sean Reilly Capítulo 1
Selva Kumar Capítulo 15
sergiuz Capítulo 14
Shrabanee Capítulo 2
SommerEngineering Capítulo 4
steveinatorx Capítulo 8
styvane Capítulo 2
Thomas Bormans Capítulo 2
hora Capítulo 12

titogeo Capítulos 1, 8 e 9
Tomás Cañibano Capítulos 2 e 9
usuário641887 Capítulos 17 e 22
WAF Capítulo 1
amareloB capítulo 5
Zanon Capítulo 12

você pode gostar

Mongo DBNotes For Professionals

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Mongo DBNotes For Professionals

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

Notas para Profissionais MongoDB®

Notas para Profissionais

GoalKicker.com Livros Isenção de

Capítulo 1: Introdução ao MongoDB ....................................... ................................................ .......... 2

Capítulo 4: Consulta de dados (primeiros passos) ....................................... ......................................... 12 Seção 4.1 :

operadores ........... ................................................ ................................................ .............. 18

Capítulo 9: Índices ................................................ ................................................ ................................................ 34

Seção 11.1: Criar um índice 2dsphere ................................................ ................................................ ..................... 43

Seção 12.1: WiredTiger .............................................. ................................................ ......................................... 44

Seção 15.1: Configuração do ambiente de fragmentação ....................................... ................................................ .................. 50

Capítulo 16: Replicação ........................... ................................................ ................................................ ............. 51

Seção 16.1: Configuração básica com três nós ................................................ ................................................ 51

Capítulo 17: Mongo como um conjunto de ................................................ ................................................ ............. 53

réplicas Seção 17.1: Mongodb como um ................................................ ................................................ ................ 53

Capítulo 22: Fazendo backup e restaurando dados Seção ................................................ ............................................. 64

Seção 22.3: mongoimport com JSON ................................................ ................................................ ................. 64

Sinta-se à vontade para compartilhar este PDF com qualquer pessoa

Este livro do MongoDB® Notes for Professionals é compilado da Stack Overflow

Envie comentários e correções para web@petercv.com

GoalKicker.com MongoDB® Notes for Professionals 1

Capítulo 1: Introdução ao MongoDB

Seção 1.1: Execução de um arquivo JavaScript no MongoDB

Além disso, você pode executar um arquivo .js no console mongo .

Seção 1.2: Tornando a saída de find legível no shell

Se os virmos via find, eles parecerão muito feios.

ObjectId("5790c5e9cae25b3d38c3c7b0"), "key" : "value3" , "key2" : "Val2 2", "key3" : "val33" }

Para contornar isso e torná-los legíveis, use a função pretty() .

GoalKicker.com MongoDB® Notes for Professionals 2

Seção 1.3: Termos Complementares

Entidade / Documento de Linha

Tabela Unir documentos incorporados

Seção 1.4: Instalação

Para instalar o MongoDB, siga os passos abaixo:

Para Mac OS:

Existem duas opções para Mac OS: instalação manual ou homebrew.

$ tar xvf mongodb-osx-xyz.tgz

GoalKicker.com MongoDB® Notes for Professionals 3

execute o servidor com os seguintes comandos:

Ele iniciaria o servidor na porta 27017 por padrão.

Aceite o contrato de licença e clique em Avançar.

Selecione Instalação completa .

Após a instalação clique em Concluir.

Clique com o botão direito em Meu computador e selecione Propriedades.

Clique em Configuração avançada do sistema no painel esquerdo.

Selecione Caminho na seção Variáveis do sistema e clique em Editar....

GoalKicker.com MongoDB® Notes for Professionals 4

as teclas Shift e Ctrl juntas.

Escreva o comando para iniciar o servidor:

Ele iniciaria o servidor na porta 27017 por padrão.

Abra outro prompt de comando e digite o seguinte para iniciar o cliente:

Para distribuições baseadas em Debian (usando apt-

Adicione o repositório à lista de pacotes no Ubuntu 16.04.

$ echo "deb http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/

$ echo "deb http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/

Atualizar lista de pacotes.

$ sudo apt-get update

$ sudo apt-get install mongodb-org

Para distribuições baseadas em Red Hat (usando yum):

use um editor de texto de sua preferência.

Cole o seguinte texto.

gpgkey=https:// www.mongodb.org/ static/ pgp/ server-3.4.asc

Atualizar lista de pacotes.