db.coleção.find() (método mongosh)

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>

• formato 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.

Classificação

Quando uma operação classifica e projeta com os mesmos campos, o MongoDB classifica nos valores de campo originais antes de aplicar a projeção. Para obter mais informações sobre a ordem de operação, consulte find() Ordem de operações.

Tempo-limite de inatividade da sessão

Os drivers MongoDB e mongosh associam todas as operações a uma sessão do servidor, com exceção das operações de gravação não reconhecidas. No caso das operações não associadas explicitamente a uma sessão (ou seja, usando Mongo.startSession()), os drivers 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 query, consulte Predicados de query.

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 query, consulte Predicados de query.

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 query, consulte Predicados de query.

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 na 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 da array contribs é 4:

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

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

• Consultas em uma array

• Consultas em uma array de documentos incorporados

Para obter uma lista de operadores de query específicos de array, consulte Operadores de predicado de query de array.

Consultas em array de documentos

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

• A operação a seguir retorna documentos na coleção bios em que a 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 a 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 uma array

• Consultas em uma array de documentos incorporados

Para obter uma lista de operadores de query específicos de array, consulte Operadores de predicado de query de 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 }
)

Exclui 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 na 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 agregação 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 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 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 de cursor mongosh disponíveis

limite com opções

A query a seguir 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 query a seguir utiliza o parâmetro options para habilitar allowDiskUse:

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

explicar com opções

A consulta a seguir usa o parâmetro options para obter a saída de explicação executionStats:

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

Especifique várias opções em uma query

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

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