MongoDB find()

Devolver todos os documentos

db.pets.find() 

{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Latido", "tipo" :"Dog", "weight" :10 }{ "_id" :3, "name" :"Miau", "type" :"Cat", "weight" :7 }{ "_id" :4, "name" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Bat", "weight" :3 } 
 Aqui, usamos o find() método para retornar todos os documentos do pets coleção. Sabemos que isso retorna todos os documentos porque não fornecemos nenhum critério de filtragem. Na verdade, não fornecemos nenhum argumento. 
 
 Quando chamado sem argumentos, find() retorna todos os documentos de uma coleção e retorna todos os campos dos documentos. 
 
 Outra maneira de fazer o acima é assim:
 
db.pets.find({}) 
 
 Neste caso passamos um documento vazio. 
 
 Ao adicionar a este documento vazio, podemos começar a filtrar os resultados. 
 
Filtrar os resultados
 
 A sintaxe real de find() fica assim:
 
db.collection.find(query, projection) 
 
 Isso significa que você pode passar uma consulta como o primeiro argumento e uma projeção como o segundo. 
 
 Se você passar uma consulta, ela será usada para filtrar os resultados. Uma consulta é um documento que contém operadores de consulta. Como vimos no exemplo anterior, um documento vazio retorna todos os documentos. 
 
 Vamos restringir os resultados a um subconjunto de documentos na coleção. 
 
db.pets.find({"type":"Dog"}) 
 
 Resultado:
 
{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Latido", "tipo" :"Cão", "peso" :10 }
 
 Isso limitou os resultados apenas aos documentos que têm um type campo com um valor de Dog . 
 
 Nesse caso, simplesmente passamos um documento como critério de filtragem. 
 
 Você também pode usar operadores de consulta. Eles permitem que você aplique critérios mais específicos à sua consulta. 
 
 Exemplo:
 
db.pets.find({"weight": { $lt: 10 }}) 
 
 Resultado:
 
{ "_id" :3, "name" :"Miau", "type" :"Cat", "weight" :7 }{ "_id" :4, "name" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Bat", "weight" :3 }
 
Documentos incorporados
 
 Se você tiver documentos que contenham documentos incorporados, poderá usar os métodos a seguir para consultar dados nos documentos incorporados. 
 
 
Notação de ponto (por exemplo, field.nestedfield: <value> )
 
Formulário aninhado (por exemplo, { field: { nestedfield: <value> } } ). Observe que esta opção está disponível apenas no MongoDB 4.4.
 
 
 Suponha que inserimos o seguinte documento. 
 
db.pets.insertOne({ "_id" :6, "name" :"Buscar", "tipo" :"Cão", "especificações" :{ "altura" :400, "peso" :15, " color" :"marrom" }})
 
 Podemos usar a notação de ponto para consultar o documento incorporado. 
 
db.pets.find({ "specs.height": 400 }) 
 
 Resultado:
 
{ "_id" :6, "name" :"Buscar", "type" :"Dog", "specs" :{ "height" :400, "weight" :15, "color" :"brown" } }
 
 A consulta a seguir retorna o mesmo documento, exceto que desta vez fazemos referência ao documento incorporado usando o formulário aninhado. 
 
db.pets.find({ 
    "specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
 }) 
 
 Resultado:
 
{ "_id" :6, "name" :"Buscar", "type" :"Dog", "specs" :{ "height" :400, "weight" :15, "color" :"brown" } }
 
 Ao usar o formulário aninhado, a consulta deve corresponder exatamente a todo o documento incorporado. Por exemplo, a consulta a seguir não corresponde:
 
db.pets.find({ 
    "specs" : {
		"height" : 400
	}
 }) 
 
Formatar os resultados
 
 O resultado do exemplo anterior foi retornado em uma linha. Você pode usar o cursor.pretty() método para configurar o cursor para exibir os resultados em um formato mais legível. 
 
 Para usar o pretty() método, anexe-o ao find() método. 
 
 Exemplo:
 
db.pets.find({ "_id": 6 }).pretty() 
 
 Resultado:
 
{ "_id" :6, "name" :"Buscar", "type" :"Dog", "specs" :{ "height" :400, "weight" :15, "color" :"brown" }}
 
Matrizes
 
 Você pode fazer referência a dados em matrizes referenciando o elemento da matriz por seu índice ou por seu valor. 
 
 Suponha que inserimos o seguinte documento:
 
db.pets.insertOne({ "_id" :7, "name" :"Jake", "type" :"Dog", "awards" :[ "Top Dog", "Best Dog", "Biggest Dog" " ]})
 
 Se quiséssemos encontrar todos os cães com o prêmio Top Dog, poderíamos escrever a seguinte consulta (que retornará o cão acima). 
 
db.pets.find({ 
    "awards": "Top Dog"
}).pretty() 
 
 Resultado:
 
{ "_id" :7, "name" :"Jake", "type" :"Dog", "awards" :[ "Top Dog", "Best Dog", "Biggest Dog" ]}
 
 Você também pode especificar o índice do elemento, assim:
 
db.pets.find({ 
    "awards.0": "Top Dog"
}).pretty() 
 
 Fazer isso requer que o valor especificado esteja no índice especificado. Portanto, a consulta a seguir não retorna o mesmo cão. 
 
db.pets.find({ 
    "awards.1": "Top Dog"
}).pretty() 
 
 Observe que as matrizes são baseadas em zero, portanto, um índice de 0 especifica o primeiro elemento, 1 especifica o segundo elemento e assim por diante. 
 
Projeções
 
 Por padrão, todos os campos do documento são retornados quando você usa find() . Mas você pode usar projeções para reduzir o número de campos retornados, se necessário. 
 
 Você deve se lembrar que a sintaxe para find() fica assim:
 
db.collection.find(query, projection) 
 
 Onde query fornece os critérios de filtragem (que fizemos nos exemplos acima) e projection é uma projeção opcional que especifica quais campos retornar de qualquer documento correspondente. Portanto, se quisermos usar uma projeção, simplesmente a colocamos após a consulta. 
 
 Ao usar uma projeção, você pode especificar os campos para incluir , os campos a excluir , ou ambos. Para fazer isso, liste o nome do campo e um 1 (para incluí-lo) ou 0 (para excluí-lo). 
 
 Até agora, nossa coleção contém os seguintes documentos:
 
{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Latido", "tipo" :"Dog", "weight" :10 }{ "_id" :3, "name" :"Miau", "type" :"Cat", "weight" :7 }{ "_id" :4, "name" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Bat", "weight" :3 }{ " _id" :6, "name" :"Buscar", "type" :"Dog", "specs" :{ "height" :400, "weight" :15, "color" :"brown" } }{ "_id " :7, "name" :"Jake", "type" :"Dog", "awards" :[ "Top Dog", "Best Dog", "Biggest Dog" ] }
 
 Aqui está um exemplo de como usar uma projeção para especificar os campos a serem incluídos:
 
db.pets.find({}, { name: 1, type: 1 }) 
 
 Resultado:
 
{ "_id" :1, "name" :"Wag", "type" :"Cachorro" }{ "_id" :2, "name" :"Latido", "type" :"Cachorro" }{ "_id" :3, "name" :"Miau", "type" :"Cat" }{ "_id" :4, "name" :"Scratch", "type" :"Cat" }{ "_id" :5, "name" :"Bruce", "type" :"Bat" }{ "_id" :6, "name" :"Buscar", "type" :"Cão" }{ "_id" :7, "name " :"Jake", "type" :"Cachorro" }
 
 Observe que o _id campo é retornado mesmo que não o tenhamos incluído em nossa projeção. Este campo é uma exceção e é incluído por padrão. 
 
 Se você não quiser o _id campo a ser retornado, você precisa excluí-lo explicitamente. 
 
db.pets.find({}, { _id: 0, name: 1, type: 1 }) 
 
 Resultado:
 
{ "name" :"Wag", "type" :"Cachorro" }{ "name" :"Latido", "type" :"Cachorro" }{ "name" :"Miau", "type" :"Cat" }{ "name" :"Scratch", "type" :"Cat" }{ "name" :"Bruce", "type" :"Bat" }{ "name" :"Fetch", "type" :"Cachorro" }{ "name" :"Jake", "type" :"Cachorro" }
 
 Aqui está outro exemplo, desta vez especificamos apenas quais campos excluir. 
 
db.pets.find({}, { _id: 0, weight: 0, specs: 0, awards: 0 }) 
 
 Resultado:
 
{ "name" :"Wag", "type" :"Cachorro" }{ "name" :"Latido", "type" :"Cachorro" }{ "name" :"Miau", "type" :"Cat" }{ "name" :"Scratch", "type" :"Cat" }{ "name" :"Bruce", "type" :"Bat" }{ "name" :"Fetch", "type" :"Cachorro" }{ "name" :"Jake", "type" :"Cachorro" }
 
Mais projeções
 
 Há várias outras coisas que você pode fazer com projeções. Por exemplo, a partir do MongDB 4.4, você pode usar expressões agregadas para especificar o valor de um campo projetado. 
 
 Exemplo:
 
db.pets.find({}, { 
    "_id": 0,
    "n": "$name", 
    "t": "$type", 
    "w": "$weight" 
    }) 
 
 Resultado:
 
{ "n" :"Abanar", "t" :"Cachorro", "w" :20 }{ "n" :"Latir", "t" :"Cachorro", "w" :10 }{ "n" :"Miau", "t" :"Gato", "w" :7 }{ "n" :"Arranhão", "t" :"Gato", "w" :8 }{ "n" :"Bruce", "t" :"Morcego", "w" :3 }{ "n" :"Buscar", "t" :"Cachorro" }{ "n" :"Jake", "t" :"Cachorro " }
 
 Aqui, renomeamos os nomes dos campos. Fizemos isso especificando um novo nome para cada campo como uma string literal, usando o $fieldName sintaxe para gerar esse valor de campos. O resultado é um pouco como usar aliases no SQL. 
 
Mais informações
 
 Consulte a documentação do MongoDB para obter mais informações.