Combina as melhores características de banco de dados documental, armazenamento de chave-valores e banco de dados relacional.
MongoDB é uma solução escalável, de alta performance, open source e banco de dados orientado a documentos. Escrito em C++, algumas características:
- Armazenamento orientando a documentos (a simplicidade e poder do esquemas de dados em JSON);
- Consultas dinâmicas;
- Completo suporte a índices, extendo para objetos internos e arrays embutidos;
- Rápido, para atualizações;
- Eficiente armazenamento de dados binários, como: fotos e vídeos;
- Auto-sharding alto nível de escabilidade na nuvem;
- MapReduce para agregação complexa;
- …
MongoDB é a ponte do fosso entre o armazenamento de chave-valores (que são rápidos e altamente escaláveis) e os tradicionais banco de dados relacionais (que fornecem esquemas estruturados e consultas poderosas).
Conceitos
Coleções
Coleções são essecialmente nomes de grupos de documentos. Você pode pensar nelas mais ou menos equivalente às tabelas do banco de dados relacional.
Estes documentos usualmente tem a mesma estrutura, mas isso não é um exigência do MongoDB o esquema de dados é livre. Você pode armazenar conjunto heterogêneo de documentos dentro de uma coleção, você não precisa predefinir “colunas” ou campos para as coleções.
Os nomes das coleções podem começar com letras, underscore ou podem incluir números; $ é reservado não podendo ser usado.
Documentos
Quando nós inserimos dados no MongoDB, os dados sempre são na forma de documentos. Documentos são uma estrutura de dados análogo ao JSON, dicionários em Python, e hashes em Ruby. Por exemplo:
doc = { author : 'joe', created : new Date('03-28-2009'), ... }(BSON) Tipos de dados
MongoDB usa tipos de dados especiais além dos tipos básicos JSON de string, integer, boolean, double, null, array e object. Esses tipos incluem date, object id, dados binários, expressão regular e código.
Object IDs
Documentos no MongoDB são obrigados a ter uma chave, _id, única para a sua identificação.
Cada documento no MongoDB tem um campo _id como primeiro atributo. Esse valor usualmente é BSON ObjectId, sendo único para cada membro da coleção.
Se o usuário tentar inserir um documento sem fornecer um id, o banco de dados irá gerar automaticamente um _object id e armazená-lo no campo _id.
Usuários podem gerar suas próprias convenções para criação de ids; o valor para _id pode ser de qualquer tipo enquanto for único.
Instalação
http://www.mongodb.org/display/DOCS/Quickstart
Para iniciar o processo do MongoDB:
$ mongod
Conexão com o banco de dados
Você pode manipular o banco de dados através do shell JavaScript com:
$ mongo
Por padrão o shell conecta no banco de dados em localhost. Você verá:
MongoDB shell version: 1.2.2 url: test connecting to: test type "help" for help >
“connecting to:” informa para você o nome do banco de dados que o shell está usando. Para mudar para outro banco de dados, digite:
> use mydb
Para ver toda a lista de comandos válidos, digite help.
Para os desenvolvedores mais experiêntes em outros banco de dados, você pode notar que nunca é criado o banco de dados ou coleção, MongoDB não solicita isso. Quando você inserir algo o MongoDB cria a coleção e o banco de dados. Se você consultar uma coleção que não existe o MongoDB trata como uma coleção vazia.
Inserindo dados em uma coleção
Para começar vamos criar uma coleção de teste e inserir alguns dados. Nós vamos criar dois objetos, j e t, e então salvar eles na coleção things.
> j = { name: "mongo" };
{ "name" : "mongo" }
> t = { x: 3 };
{ "x" : 3 }
> db.things.save(j);
> db.things.save(t);
> db.things.find();
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
>Algumas coisas para notar:
- Nós não temos uma coleção pré-definida. O banco de dados cria automaticamente na primeira inserção;
- Os documentos que nós gravamos podem ter qualquer “estrutura” – na verdade nesse exemplo, os documentos não tem elementos de dados comum a todos. Na prática, usualmente os documentos tem a mesma estrutura dentro das coleções. No entando, esta flexibilidade significa que as migrações de esquema e de reposição são muito mais fáceis na prática – raramente você vai precisar escrever um script que executa operações do tipo “alter table”;
- Ao ser inserido no banco de dados, os objetos são atribuídos a um identificador de objeto (se ele não tiver um) no campo _id;
Vamos adicionar mais alguns registros para esta coleção:
> for( var i=1; i < 10; i++) db.things.save({ x:4, j:i });
> db.things.find();
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }
>Note que vamos ver os dois documentos adicionados no começo e mais os 9 novos documentos adicionados no loop for.
Acessando dados da consulta
Tecnicamente, find() retorna um objeto cursor, desta forma é possível iterar em cima dele em um loop while:
> var cursor = db.things.find();
> while (cursor.hasNext()) { print(tojson(cursor.next())); }
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }
>O exemplo acima exibe o estilo de iteração usando o cursor. A funcão hasNext() informa se existe mais documentos para retornar, e a função next() retorna o próximo documento. Nós usamos o método tojson() para formatar os documentos para JSON.
Ao trabalhar com o shell JavaScript, também podemos usar os recursos da linguagem, e apenas chamar forEach para o cursor.
> db.things.find().forEach( function(x) { print(tojson(x)); } );
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }
>Nesse caso do forEach() devemos definir uma função que é chamada para cada documento no cursor.
No shell do MongoDB, você pode tratar cursores como um array:
> var cursor = db.things.find();
> print (tojson(cursor[4]));
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }Ao usar um cursor assim, note que todos os valores até o mais alto acessado (cursor[4] acima) são carregados na memória RAM ao mesmo tempo. Isso não é apropriado para grandes conjuntos de resultados, você pode ficar sem memória. Cursores devem ser usados com um iterador com qualquer consulta que retornar um grande número de elementos.
Também é possível converter o cursor para um array:
> var arr = db.things.find().toArray();
> arr[5];
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }Por favor note que esses recursos de array são específicos do shell interativo do MongoDB, e não disponíveis em todos os drivers para MongoDB.
Especificando o que a consulta retorna
Agora que sabemos como trabalhar com cursores, podemos nós concentrar para as consultas retornarem coisas específicas.
Em geral, a maneira de fazer isso é criar “documentos de consulta”, que são documentos que indicam o padrão de chaves e valores que devem ser combinados.
Estes são mais fáceis demonstrar que explicar. No exemplos a seguir, vamos dar o exemplo da consulta SQL, e demonstrar a forma de representar a mesma consulta usando MongoDB através o shell. Esta maneira de consultas específicas é fundamental para MongoDB, assim que você vai encontrar a mesma facilidade em alguns driver ou linguagens.
SELECT * FROM things WHERE name="mongo"
> db.things.find({name:"mongo"}).forEach(function(x) { print(tojson(x)); } );
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }SELECT * FROM things WHERE x=4
> db.things.find({x:4}).forEach(function(x) { print(tojson(x)); });
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }A expressão de consulta é um documento em si. O documento de consulta é da forma { a:A, b:B, … } significa “where a==A and b==B and …”.
MongoDB também permite que você retorne “documentos parciais” – documentos que tenham apenas um subconjunto de elementos do documento armazenado em banco de dados. Para fazer isso, você adiciona um segundo argumento para a consulta find(), fornecendo um documento que enumera os elementos que devem ser devolvidos.
Para ilustar, vamos repetir o último exemplo find({x:4}) com o argumento adicional que limita o documento devolvido apenas com os elementos “j”:
SELECT j FROM things WHERE x=4
> db.things.find({x:4}, {j:true}).forEach(function(x) { print(tojson(x)); });
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "j" : 9 }Note que o campo “_id” sempre é retornado.
findOne()
Por conveniência, o MongoDB shell (e outros drivers) permite evitar sobrecarga de programação de lidar com o cursor, e só permite recuperar um documento através da função findOne(). findOne() utiliza os mesmos parâmetros que a função find(), mas ao invés de retornar um cursor, ele irá retornar primeiro documento retornado do banco de dados, ou null se nenhum documento for encontrado com a consulta especificada.
Como exemplo, podemos recuperar um documento com o name==’mongo’. Há muitas maneiras de fazer isso, incluindo apenas chamar next() do cursor (após verificar se não é nulo, é claro), ou tratar o curso como um array e acessando o elemento zero.
No entando, o método findOne() é conveniente e eficiênte:
> var mongo = db.things.findOne({name:"mongo"});
> print(tojson(mongo));
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }Isso é mais eficiênte porque que o cliente requisita um único objeto do banco de dados, assim menos trabalho é necessário pelo banco de dados e rede. Isso é equivalente a find({name:”mongo”}).limit(1);
Limitar o Result Set através de limit()
Você pode limitar a quantidade de resultados da consulta definindo o máximo de número de resultados para serem retornados através do método limit().
Isso é altamente recomendável por razões de desempenho, isso limita o trabalho que o banco de dados faz, e limita o montante de dados retornados pela rede. Por exemplo:
> db.things.find().limit(3);
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }Índices
Índices podem melhorar o desempenho da consulta, muitas vezes damaticamente. É importante pensar sobre os tipos de consulta da sua aplicação que você possa definir índices relevantes. Atualmente criar índices no MongoDB é relativamente fácil.
Um índice é uma estrutura de dado em coleção sobre os valores dos campos especificados nos documentos de uma coleção. Essa estrutura de dados é usado pelo otimizador de consulta do MongoDB para classificar rapidamente e ordenar documentos em uma coleção. Formalmente, esses índices são implementados usando índices “B-Tree”.
No shell, você pode criar um índice chamando a função ensureIndex(), e fornecendo um documento que especifica uma ou mais chaves de índice. Como exemplo nós podemos criar um índice para os campos “j”:
> db.things.ensureIndex({j:1});A função ensureIndex() apenas cria o índice se ele não existir.
Uma vez que uma coleção é indexada por uma chave, o acesso aleatório a uma consulta que combina com a achave específica é rápido. Sem o índice o MongoDB tem que passar por cada documento, verificando o valor da chave especificada na consulta:
> db.things.find({j:2}); // rápido - usando índice
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
> db.things.find({x:3}); // lento - tem que verificar todos porque 'x' não tem índice
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }Chaves embutidas
Com MongoDB você pode indexar até mesmo uma chave dentro de um documento embutido. Por exemplo:
> db.things.ensureIndex({"address.city":1});Documentos como chaves
Campos indexados pode ser de qualquer tipo, incluíndo documentos:
> db.factories.save( { name: "xyz", metro: { city: "New York", state: "NY" } } );
> db.factories.ensureIndex({metro:1});Você não pode especificar a classificação e ordenação para uma chave de objeto, portanto, as chaves de objetos são úteis para recuperação aleatória, menos para acessos ordenados (para esse último, considere chave de índices compostos).
Índices de chaves compostas
Além de chave única para índices, MongoDB também suporta múltiplas chaves “compostas” para índices. Assim como nos índices simples você usa a função ensureIndex() para criar o índice, mas em vez de especificar somente uma chave, você pode especificar várias:
> db.things.ensureIndex({j:1, name:-1});Ao criar um índice, o número associado com a chave específica a direção do índice, assim sempre deve ser 1 (ascedente) ou -1 (descendente). Direção não importa para índices de chave única ou para acesso aleatório, mas é importante se você estiver fazendo consultas amplas sobre índices compostos.
Se você tiver um índice composto em múltiplos campos, você pode usá-lo para consulta no subconjunto dos campos. Por exemplo, se você tiver o índice composto nos campos:
a, b, c
Você pode usá-lo em consulta para:
a
a, b
a, b, c
Índices únicos
MongoDB suporta índices únicos, o que garante que não existem documentos já inseridos, cujos valores para as chaves indexadas coincidem com os de um documento existente. Para criar um índice que garante que não existem dois documentos que têm os mesmos valores para x e j você pode fazer:
> db.things.ensureIndex({x:1, j:1}, {unique:true});Chaves perdidas
Quando o documento é salvado na coleção com índices únicos, as chaves faltantes serão inseridas com valores nulo. Assim, não será possível a inserção de múltiplos documentos em falta com a mesma chave indexada.
> db.people.save({firstname: "Patrick", lastname: "Espake"});
> db.people.ensureIndex({firstname: 1}, {unique: true});
> db.people.save({lastname: "Smith"});
> db.people.save({lastname: "Jones"});
E11000 duplicate key errorindex: mydb.people.$firstname_1 dup key: { : null }
> db.people.find()
{ "_id" : ObjectId("4b841fdd07c6c3b400e7fe3e"), "firstname" : "Patrick", "lastname" : "Espake" }
{ "_id" : ObjectId("4b84200f07c6c3b400e7fe3f"), "lastname" : "Smith" }Valores duplicados
O índice único não pode ser criado em uma chave que tem valores duplicados. Se você quiser criar o índice mesmo assim, mantendo o primeiro documento no banco de dados e apagando todos os outros documentos que tenha valores duplicados, adicione a opção dropDups.
> db.things.ensureIndex({firstname : 1}, {unique : true, dropDups : true})Apagando índices
Para apagar todos os índices de uma coleção específica:
> db.collection.dropIndexes();
Para apagar um único índice:
> db.collection.dropIndex({x: 1, y: -1})ReIndex
O comando reIndex vai reconstruir todos os índices da coleção:
> db.myCollection.reIndex()
Usualmente isso é desnecessário. Você pode pedir para fazer se o tamanho da sua coleção mudou drasticamente ou o espaço em disco usado pelos índices parece estranhamente grande.
Desempenho dos índices
Índices fazem a busca por chave, incluíndo a recuperação sequencial ordenada, muito rápido. Atualizações por chave são rápidas também, MongoDB pode buscar o documento e atualizar rapidamente.
No entanto, tenha em mente que cada índice criado adiciona uma certa quantidade de sobrecarga para as inserções e exclusões. Além de escrever dados na base de coleções, as chaves devem ser adicionadas aos índices B-Tree. Assim, índices são melhores para coleções onde o número de leituras e muito maior que o número de escritas. Para coleções que são escritas intensamente, índices, em alguns casos podem ser anti-produtivos. A maioria das coleções são de leitura intensa, por isso os índices são uma coisa boa na maioria das situações.
Usando sort() sem um índice
Você pode usar sort() para retornar dados em ordem sem um índice, se o conjunto de dados a ser devolvido é pequeno (menor que quatro megabytes). Para outros casos é melhor user limit() e sort() juntos.
Multikeys
MongoDB fornece um interessante recurso “multikey” que pode automaticamente indexar arrays de valores de um objeto. Um bom exemplo são tags. Suponha que você tenha um artigo com tags que sejam alguns nomes de categorias:
> db.articles.save({ name: "Warm Weather", author: "Steve", tags: ['weather', 'hot', 'record', 'april'] });
> db.articles.find()
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }Nós podemos facilmente executar uma consulta à procura de um determinado valor no array de tags:
> db.articles.find({ tags: 'april' })
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }Além disso, nós podemos indexar o array de tags. Criando um índice no array de elementos de resultados na indexação do banco de dados indexando cada elemento do array:
> db.articles.ensureIndex( { tags: 1 } )
> db.articles.find( { tags: 'april' } )
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }
> db.articles.find( { tags: 'april' } ).explain()
{
"cursor" : "BtreeCursor tags_1",
"startKey" : {
"tags" : "april"
},
"endKey" : {
"tags" : "april"
},
"nscanned" : 1,
"n" : 1,
"millis" : 0,
"oldPlan" : {
"cursor" : "BtreeCursor tags_1",
"startKey" : {
"tags" : "april"
},
"endKey" : {
"tags" : "april"
}
},
"allPlans" : [
{
"cursor" : "BtreeCursor tags_1",
"startKey" : {
"tags" : "april"
},
"endKey" : {
"tags" : "april"
}
}
]
}Campos de objeto embutido em um array
Além disso, a mesma técnica pode ser usado para campos em objetos embutidos:
> db.posts.save( { title: "How the west was won", comments: [ { text: "great!", author: "sam" }, { text: "ok", author: "julie" } ] } )
> db.posts.find( { "comments.author": "julie" } )
{ "_id" : ObjectId("4b84310707c6c3b400e7fe44"), "title" : "How the west was won", "comments" : [
{
"text" : "great!",
"author" : "sam"
},
{
"text" : "ok",
"author" : "julie"
}
] }Consultado todos os valores definidos em um conjunto determinado
Ao utilizar a opção $all na consulta, um conjunto de valores podem ser fornecidos os quais devem estar presentes em um campo de objeto correspondente. Por exemplo:
> db.articles.find( { tags: { $all: ['april', 'record'] } } )
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }
> db.articles.find( { tags: { $all: ['april', 'june'] } } )
> // nada encontradoSkip e Limit
MongoDB também suporta skip e limit para paginação fácil. Aqui podemos ignorar os 10 primeiros documentos, e limitar o nosso conjunto de resultados para 20:
> db.things.find({}, {}, 10, 20)Consultas avançadas
Operadores condicionais: <, <=, >, >=
Use essas formas especiais para comparações maior que e menor que em consultas, desde que eles possam ser representandos em documentos de consulta:
> db.collection.find({ "field" : { $gt: value } } ); // maior que : campo > valor
> db.collection.find({ "field" : { $lt: value } } ); // menor que : campo < valor
> db.collection.find({ "field" : { $gte: value } } ); // maior que ou igual : campo >= valor
> db.collection.find({ "field" : { $lte: value } } ); // menor que ou igual : campo <= valorPor exemplo:
> db.things.find( { j: { $lt: 3 } } );
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }
> db.things.find( { j: { $gte: 4 } } );
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }
{ "_id" : ObjectId("4b856c065b4e024e99277722"), "x" : 10, "j" : 5 }
{ "_id" : ObjectId("4b856c065b4e024e99277723"), "x" : 10, "j" : 6 }Você pode combinar esses operadores para intervalos específicos:
> db.things.find( { j: { $gt: 3, $lt: 6 } } )
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }
{ "_id" : ObjectId("4b856c065b4e024e99277722"), "x" : 10, "j" : 5 }Operador condicional: $ne
Use $ne para “não igual”:
> db.things.find( { j: { $ne: 2 } } )
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e99277720"), "x" : 10, "j" : 3 }
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }Operador condicional: $in
O operador $in é análogo ao modificador SQL IN, permite que você especifique um array de combinação:
> db.things.find( { j: { $in: [2, 4, 6] } } )
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }
{ "_id" : ObjectId("4b856c065b4e024e99277723"), "x" : 10, "j" : 6 }Operador condicional: $nin
O operador $nin é similar ao $in exceto que seleciona objetos que não tem nenhum valor especificado no array. Por exemplo:
> db.things.find( { j: { $nin: [2,4,6] } } );
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e99277720"), "x" : 10, "j" : 3 }
{ "_id" : ObjectId("4b856c065b4e024e99277722"), "x" : 10, "j" : 5 }
{ "_id" : ObjectId("4b856c065b4e024e99277724"), "x" : 10, "j" : 7 }Operador condicional: $mod
O operador $mod permite que você faça consultas rápidas usando módulo:
> db.things.find( { j: { $mod: [ 10, 1 ] } } ) // this.a % 10 == 1
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e99277728"), "x" : 10, "j" : 11 }
{ "_id" : ObjectId("4b856c065b4e024e99277732"), "x" : 10, "j" : 21 }Operador condicional: $all
O operador $all é similar ao $in, mas ao invés combinar qualquer valor do array, deve combinar todos os valores especificados no array. Por exemplo, o objeto:
{ a: [1, 2, 3] }Deve combinar com:
db.things.find( { a: { $all: [ 2, 3 ] } } );mas não com:
db.things.find( { a: { $all: [ 2, 3, 4 ] } } );Operador condicional: $size
O operador $size permite especificar o tamanho de um array, ou seja, a quantidade de elementos:
> db.things.find( { j: { $size: 1 } } )
{ "_id" : ObjectId("4b8580965b4e024e99277781"), "j" : [ 99 ] }
{ "_id" : ObjectId("4b85809b5b4e024e99277782"), "j" : [ 999 ] }
{ "_id" : ObjectId("4b85809e5b4e024e99277783"), "j" : [ 9999 ] }
{ "_id" : ObjectId("4b8580a15b4e024e99277784"), "j" : [ 99990000 ] }Operador condicional: $exists
Verifica pela existência (ou ausência) de um campo:
> db.things.find( { a: { $exists: true } } )
> db.things.find( { a: { $exists: false } } )
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }Expressões regulares
Você pode usar expressões regulares para consultas:
> db.customers.find( { name : /acme.*corp/i } );Valores em um Array
Você pode buscar todas as coleções que possuam a cor vermelha no array de cores:
> db.things.find( { colors : "red" } );Operador condicional: $elemMatch
Use $elemMatch para verificar se um elemento no array combina com a expressão de combinação especificada:
> db.things.find( { x: { $elemMatch: { a:1, b: { $gt: 1 } } } } )Operador meta: $not
O operador meta $not pode ser usado para negar a verificação realizada por um operador padrão. Por exemplo:
> db.things.find( { x: { $not: { $mod: [10, 1] } } } );Expressão de linguagem e $where
Além da sintaxe estruturada de consulta mostrada até agora, você pode escrever consultas com a expressão “where” no estilo SQL.
> db.things.find( { $where: "this.j < 3" } )
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }
> db.things.find("this.j < 3")
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }sort()
sort() é análogo ao ORDER BY no padrão SQL. Em MongoDB o valor 1 indica a ordem crescente e o -1 indica a ordem descrecente.
> db.things.find().sort( { x:1 } ) // classifica em ordem crescente
> db.things.find().sort( { x:-1 } ) // classifica em ordem decrescentelimit()
limit() é análogo ao LIMIT no padrão SQL. Especifica a quantidade máxima de resultados devolvidos.
> db.things.find().limit(2)
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }count()
O método count() retorna o número de objetos que combinam com a consulta especificada.
> db.things.find( { j: { $mod: [2, 0] } } ).count()
53
> db.mycollection.count( { active:true } )Elemento do array por posição
Os elementos do array também pode ser acessados por sua posição específica:
// exemplo: comments[0].by == "Abe"
> db.blogposts.find( { "comments.0.by" : "Abe" } )Operações OU em expressões de consultas
Objetos de consulta em MongoDB por padrão usam expressão AND para junção. MongoDB atualmente não incluem nenhum operador OR para consultas, entretanto existe algums modos de expressar isso em consultas.
> db.mycollection.find( { $where : function() { return this.a == 3 || this.b == 4; } } );
> db.mycollection.find( function() { return this.a == 3 || this.b == 4; } );
> db.things.find("this.j == 1 || this.j == 3")Distinct
Devolve a lista de valores distintos para a chave na coleção:
> db.addresses.save({"zip-code": 10010})
> db.addresses.save({"zip-code": 10010})
> db.addresses.save({"zip-code": 99701})
> db.addresses.distinct("zip-code");
[ 10010, 99701 ]distinct também pode ser usado para chaves aninhadas:
> db.comments.save({"user": {"points": 25}})
> db.comments.save({"user": {"points": 31}})
> db.comments.save({"user": {"points": 25}})
> db.comments.distinct("user.points");
[ 25, 31 ]Atualizando documentos
Vamos criar um documento para depois atualizar:
db.users.save({name: 'Johnny', languages: ['ruby', 'c']});Para atualizar o documento:
db.users.update({name: 'Johnny'}, {name: 'Cash', languages: ['english']});Operadores de atualização
MongoDB suporta atualizações parciais de documentos. Por exemplo, você pode definir um valor:
db.users.update({name: 'Cash'}, {'$set': {'age': 50} });É possível adicionar e remover itens dos arrays:
db.users.update({name: 'Sue'}, {'$pull': {'languages': 'scala'} });
db.users.update({name: 'Sue'}, {'$push': {'languages': 'ruby'} });Apagando Dados
Para apagar tudo da coleção:
db.scores.remove();
Para apagar os documentos que casam com uma consulta:
db.users.remove({name: 'Sue'});
