db.collection.find()

Abrir tutorial interativo

Especificação de campo incorporada

Para campos em documentos incorporados, você pode especificar o campo usando:

• notação de pontos, por exemplo "field.nestedfield": <value>

• formulário aninhado, por exemplo { field: { nestedfield: <value> } }

_id Projeção de campo

O campo _id é incluído nos documentos retornados por padrão, a menos que você especifique explicitamente _id: 0 na projeção para suprimir o campo.

Inclusão ou exclusão

Uma projection não pode conter especificações de inclusão e exclusão, com exceção do campo _id:

• Em projeções que incluem explicitamente campos, o campo _id é o único campo que você pode excluir explicitamente.

• Em projeções que excluem explicitamente campos, o campo _id é o único campo que você pode incluir explicitamente; entretanto, o campo _id é incluído por padrão.

Consulte Exemplos de projeção.

Tempo-limite de inatividade da sessão

Os drivers e mongosh do MongoDB associam todas as operações a uma sessão de servidor, com exceção de operações de gravação não reconhecidas. Para operações não explicitamente associadas a uma sessão (ou seja, uso Mongo.startSession()), os drivers do MongoDB e mongosh criam uma sessão implícita e a associam à operação.

Se uma sessão estiver ociosa por mais de 30 minutos, o servidor MongoDB marcará essa sessão como expirada e poderá fechá-la a qualquer momento. Quando o servidor MongoDB fecha a sessão, ele também elimina todas as operações em andamento e abre os cursores associados à sessão. Isso inclui cursores configurados com noCursorTimeout() ou maxTimeMS() com mais de 30 minutos.

Para operações que podem estar ociosas por mais de 30 minutos, associe a operação com uma sessão explícita utilizando Mongo.startSession() e atualize periodicamente a sessão utilizando o comando refreshSessions. Consulte Tempo limite de inatividade da sessão para obter mais informações.

Consulta por igualdade

• A seguinte operação retorna documentos na coleção bios onde _id é igual a 5:

  db.bios.find( { _id: 5 } )

• A operação a seguir retorna documentos na coleção bios em que o campo last no documento incorporado name é igual a "Hopper":

  db.bios.find( { "name.last": "Hopper" } )

  Observação

  Para acessar campos em um documento incorporado, use notação de ponto ("<embedded document>.<field>").

Consulta usando operadores

Para localizar documentos que correspondam a um conjunto de critérios de seleção, chame find() com o parâmetro <criteria> .

O MongoDB fornece vários operadores de consulta para especificar os critérios.

• A operação a seguir usa o operador $in para retornar documentos na coleção bios em que _id é igual a 5 ou ObjectId("507c35dd8fada716c89d0013"):

  db.bios.find(
     { _id: { $in: [ 5, ObjectId("507c35dd8fada716c89d0013") ] } }
  )

• A operação a seguir usa o operador $gt retorna todos os documentos da coleção bios onde birth é maior que new Date('1950-01-01'):

  db.bios.find( { birth: { $gt: new Date('1950-01-01') } } )

• A operação a seguir usa o operador $regex para retornar documentos na coleção bios em que o campo name.last começa com a letra N (ou é "LIKE N%")

  db.bios.find(
     { "name.last": { $regex: /^N/ } }
  )

Para obter uma lista dos operadores de consulta, consulte Seletores de consulta.

Consulta para intervalos

Combine operadores de comparação para especificar intervalos para um campo. A operação a seguir retorna dos documentos da coleção bios em que birth está entre new Date('1940-01-01') e new Date('1960-01-01') (exclusivo):

db.bios.find( { birth: { $gt: new Date('1940-01-01'), $lt: new Date('1960-01-01') } } )

Para obter uma lista dos operadores de consulta, consulte Seletores de consulta.

Consulta para múltiplas condições

A seguinte operação retorna todos os documentos da coleção bios onde o campo birth é greater than new Date('1950-01-01') e o campo death não existe:

db.bios.find( {
   birth: { $gt: new Date('1920-01-01') },
   death: { $exists: false }
} )

Para obter uma lista dos operadores de consulta, consulte Seletores de consulta.

Correspondências exatas de consulta em documentos incorporados

A operação a seguir retorna documentos na coleção bios em que o documento incorporado name é exatamente { first: "Yukihiro", last: "Matsumoto" }, incluindo a ordem:

db.bios.find(
    { name: { first: "Yukihiro", last: "Matsumoto" } }
)

O campo name deve corresponder exatamente ao documento incorporado. A consulta não corresponde aos documentos com os seguintes name campos:

{
   first: "Yukihiro",
   aka: "Matz",
   last: "Matsumoto"
}
{
   last: "Matsumoto",
   first: "Yukihiro"
}

Campos de consulta de um documento incorporado

A seguinte operação retorna documentos na coleção bios onde o documento integrado name contém um campo first com o valor "Yukihiro" e um campo last com o valor "Matsumoto". A consulta usa notação de ponto para acessar campos em um documento incorporado:

db.bios.find(
   {
     "name.first": "Yukihiro",
     "name.last": "Matsumoto"
   }
)

A consulta corresponde ao documento onde o campo name contém um documento incorporado com o campo first com o valor "Yukihiro" e um campo last com o valor "Matsumoto". Por exemplo, a consulta corresponderia documentos com campos name que possuíam um dos seguintes valores:

{
  first: "Yukihiro",
  aka: "Matz",
  last: "Matsumoto"
}
{
  last: "Matsumoto",
  first: "Yukihiro"
}

Para obter mais informações e exemplos, consulte também Consulta sobre documentos incorporados/aninhados.

Consulta para um elemento de array

Os exemplos a seguir fazem consulta no array contribs na coleção bios.

• A operação a seguir retorna documentos na coleção bios em que o campo array contribs contém o elemento "UNIX":

  db.bios.find( { contribs: "UNIX" } )

• A operação a seguir retorna documentos na coleção bios em que o campo array contribs contém o elemento "ALGOL" ou "Lisp":

  db.bios.find( { contribs: { $in: [ "ALGOL", "Lisp" ]} } )

• A operação a seguir usa o operador de consulta$all para retornar documentos na coleção bios onde o campo array contribs contém os elementos "ALGOL" e "Lisp":

  db.bios.find( { contribs: { $all: [ "ALGOL", "Lisp" ] } } )

  Para mais exemplos, consulte $all. Consulte também $elemMatch.

• A seguinte operação utiliza o operador $size para retornar documentos na coleção bios onde o tamanho do array contribs é 4:

  db.bios.find( { contribs: { $size: 4 } } )

Para obter mais informações e exemplos de consulta em arrays, consulte:

• Consultas em um array

• Consultas em um array de documentos incorporados

Para obter uma lista de operadores de consulta específicos de array, consulte Array.

Consultas em array de documentos

Os exemplos a seguir fazem consulta no array awards na coleção bios.

• A operação a seguir retorna documentos na coleção bios em que o array awards contém um elemento com o campo award igual a "Turing Award":

  db.bios.find(
     { "awards.award": "Turing Award" }
  )

• A operação a seguir retorna documentos na coleção bios em que o array awards contém pelo menos um elemento com o campo award igual a "Turing Award" e o campo year maior que 1980:

  db.bios.find(
     { awards: { $elemMatch: { award: "Turing Award", year: { $gt: 1980 } } } }
  )

  Use o operador $elemMatch para especificar vários critérios em um elemento array.

Para obter mais informações e exemplos de consulta em arrays, consulte:

• Consultas em um array

• Consultas em um array de documentos incorporados

Para obter uma lista de operadores de consulta específicos de array, consulte Array.

Especifique os campos a serem retornados

A operação a seguir localiza todos os documentos na coleção bios e retorna apenas os campos name, contribs e _id:

db.bios.find( { }, { name: 1, contribs: 1 } )

Campos excluídos explicitamente

A seguinte operação faz uma consulta da coleção bios e retorna todos os campos exceto o campo first no documento incorporado name e o campo birth:

db.bios.find(
   { contribs: 'OOP' },
   { 'name.first': 0, birth: 0 }
)

Excluir explicitamente o campo _id

A operação a seguir localiza documentos na coleção bios e retorna apenas o campo name e o campo contribs:

db.bios.find(
   { },
   { name: 1, contribs: 1, _id: 0 }
)

Em arrays e documentos incorporados

A operação a seguir consulta a coleção bios e retorna o campo last no documento incorporado name e os dois primeiros elementos no array contribs:

db.bios.find(
   { },
   { _id: 0, 'name.last': 1, contribs: { $slice: 2 } } )

Você também pode especificar campos incorporados usando o formulário aninhado. Por exemplo:

db.bios.find(
   { },
   { _id: 0, name: { last: 1 }, contribs: { $slice: 2 } }
)

Use expressão de agregação

A projeção db.collection.find() pode aceitar expressões de aggregation e sintaxe.

Com o uso de expressões de agregação e sintaxe, você pode projetar novos campos ou projetar campos existentes com novos valores. Por exemplo, a seguinte operação utiliza expressões de agregação para substituir o valor dos campos name e awards como também para incluir novos campos reportDate, reportBy e reportNumber.

db.bios.find(
   { },
   {
     _id: 0,
     name: {
        $concat: [
           { $ifNull: [ "$name.aka", "$name.first" ] },
           " ",
           "$name.last"
        ]
     },
     birth: 1,
     contribs: 1,
     awards: { $cond: { if: { $isArray: "$awards" }, then: { $size: "$awards" }, else: 0 } },
     reportDate: { $dateToString: {  date: new Date(), format: "%Y-%m-%d" } },
     reportBy: "hellouser123",
     reportNumber: { $literal: 1 }
   }
)

Para definir o campo reportRun para o valor 1 A operação retorna os seguintes documentos:

{ "birth" : ISODate("1924-12-03T05:00:00Z"), "contribs" : [ "Fortran", "ALGOL", "Backus-Naur Form", "FP" ], "name" : "John Backus", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1927-09-04T04:00:00Z"), "contribs" : [ "Lisp", "Artificial Intelligence", "ALGOL" ], "name" : "John McCarthy", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1906-12-09T05:00:00Z"), "contribs" : [ "UNIVAC", "compiler", "FLOW-MATIC", "COBOL" ], "name" : "Grace Hopper", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1926-08-27T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Kristen Nygaard", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1931-10-12T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Ole-Johan Dahl", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1956-01-31T05:00:00Z"), "contribs" : [ "Python" ], "name" : "Guido van Rossum", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1941-09-09T04:00:00Z"), "contribs" : [ "UNIX", "C" ], "name" : "Dennis Ritchie", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1965-04-14T04:00:00Z"), "contribs" : [ "Ruby" ], "name" : "Matz Matsumoto", "awards" : 1, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1955-05-19T04:00:00Z"), "contribs" : [ "Java" ], "name" : "James Gosling", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "contribs" : [ "Scala" ], "name" : "Martin Odersky", "awards" : 0, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }

Com nome da variável

O exemplo a seguir usa a variável myCursor para iterar sobre o cursor e imprimir os documentos correspondentes:

var myCursor = db.bios.find( );
myCursor

Com o método next()

O exemplo a seguir utiliza o método do cursor next() para acessar os documentos:

var myCursor = db.bios.find( );
var myDocument = myCursor.hasNext() ? myCursor.next() : null;
if (myDocument) {
    var myName = myDocument.name;
    print (tojson(myName));
}

Para imprimir, você também pode utilizar o método printjson() em vez de print(tojson()):

if (myDocument) {
   var myName = myDocument.name;
   printjson(myName);
}

Com o método forEach()

O exemplo a seguir usa o método de cursor forEach() para iterar o cursor e acessar os documentos:

var myCursor = db.bios.find( );
myCursor.forEach(printjson);

Ordene documentos no conjunto de resultados

O método sort() ordena os documentos no conjunto de resultados. A operação a seguir retorna documentos na coleção bios classificados em ordem crescente pelo campo name :

db.bios.find().sort( { name: 1 } )

sort() corresponde à instrução ORDER BY em SQL.

Limite o número de documentos a serem devolvidos

O método limit() limita o número de documentos no conjunto de resultados. A operação a seguir retorna no máximo 5 documentos na coleção de bios:

db.bios.find().limit( 5 )

limit() corresponde à instrução LIMIT em SQL.

Defina o ponto inicial do conjunto de resultados

O método skip() controla o ponto de partida do conjunto de resultados. A operação a seguir ignora os primeiros documentos 5 na coleção de bios e retorna todos os documentos restantes:

db.bios.find().skip( 5 )

Especifique o agrupamento

A colocação permite que os usuários especifiquem regras específicas do idioma para comparação de strings, como regras para letras maiúsculas e marcas de acento.

O método collation() especifica o agrupamento para a operação db.collection.find() .

db.bios.find( { "name.last": "hopper" } ).collation( { locale: "en_US", strength: 1 } )

Combinar métodos do cursor

As instruções a seguir encadeiam os métodos do cursorlimit() e sort():

db.bios.find().sort( { name: 1 } ).limit( 5 )
db.bios.find().limit( 5 ).sort( { name: 1 } )

As duas afirmações são equivalentes; ou seja, a ordem em que você encadeia os métodoslimit() e sort() não é significativa. Ambas as instruções retornam os cinco primeiros documentos, conforme determinado pela ordem de classificação crescente em "nome".

Métodos do cursor mongosh disponíveis

limite com opções

A seguinte query limita o número de documentos no conjunto de resultados com o parâmetro de opções limit :

db.users.find(
   { username : "rajiv"}, // query
   { age : 1 }, // projection
   { limit : 1 } // options
)

allowDiskUse com opções

A seguinte consulta utiliza o parâmetro options para habilitar o allowDiskUse:

db.users.find(
   { username : "david" },
   { age : 1 },
   { allowDiskUse : true }
)

explicar com opções

A seguinte query utiliza o parâmetro options para obter a saída de explicação do executionStats :

var cursor = db.users.find(
   { username: "amanda" },
   { age : 1 },
   { explain : "executionStats" }
)
cursor.next()

Especificar várias opções em uma query

A seguinte query utiliza múltiplos options em uma única query. Esta query usa limit definido como 2 para retornar somente dois documentos e showRecordId definido como true para retornar a posição do documento no conjunto de resultados:

db.users.find(
   {},
   { username: 1, age: 1 },
   {
     limit: 2,
     showRecordId: true
   }
)