In MongoDB il db.collection.find() il metodo seleziona i documenti in una raccolta o vista e riporta un cursore sui documenti selezionati..
La collection part è il nome della raccolta o della vista da cercare.
Puoi usarlo per restituire tutti i documenti, solo alcuni o solo un documento. Puoi anche specificare quali campi devono essere restituiti.
È importante notare che in realtà non restituisce i documenti. Restituisce semplicemente un cursore ai documenti. Detto questo, è più facile dire che "restituisce documenti" e in genere viene indicato in questo modo, anche in questo articolo 🙂
Restituisci tutti i documenti
Ecco un esempio da dimostrare.
db.pets.find()Risultato:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }
Qui utilizziamo find() metodo per restituire tutti i documenti da pets collezione. Sappiamo che questo restituisce tutti i documenti perché non abbiamo fornito alcun criterio di filtro. In effetti, non abbiamo fornito argomenti.
Quando viene chiamato senza argomenti, find() restituisce tutti i documenti da una raccolta e restituisce tutti i campi per i documenti.
Un altro modo per fare quanto sopra è questo:
db.pets.find({})In questo caso passiamo un documento vuoto.
Aggiungendo a questo documento vuoto, possiamo iniziare a filtrare i risultati.
Filtra i risultati
La sintassi effettiva di find() va così:
db.collection.find(query, projection)Ciò significa che puoi passare una query come primo argomento e una proiezione come secondo.
Se si passa una query, viene utilizzata per filtrare i risultati. Una query è un documento che contiene operatori di query. Come abbiamo visto nell'esempio precedente, un documento vuoto restituisce tutti i documenti.
Restringiamo i risultati a un sottoinsieme di documenti nella raccolta.
db.pets.find({"type":"Dog"})Risultato:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
Ciò ha ristretto i risultati ai soli documenti che hanno un type campo con un valore di Dog .
In questo caso, abbiamo semplicemente passato un documento come criterio di filtraggio.
Puoi anche utilizzare gli operatori di query. Questi ti consentono di applicare criteri più specifici alla tua richiesta.
Esempio:
db.pets.find({"weight": { $lt: 10 }})Risultato:
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 } Documenti incorporati
Se disponi di documenti che contengono documenti incorporati, puoi utilizzare i seguenti metodi per eseguire query sui dati nei documenti incorporati.
- Notazione punto (ad es.
field.nestedfield: <value>) - Modulo nidificato (ad es. {
field: { nestedfield: <value> } }). Nota che questa opzione è disponibile solo da MongoDB 4.4.
Supponiamo di inserire il seguente documento.
db.pets.insertOne({
"_id" : 6,
"name" : "Fetch",
"type" : "Dog",
"specs" : {
"height" : 400,
"weight" : 15,
"color" : "brown"
}
}) Possiamo usare la notazione del punto per eseguire query all'interno del documento incorporato.
db.pets.find({ "specs.height": 400 })Risultato:
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } } La query seguente restituisce lo stesso documento, tranne per il fatto che questa volta si fa riferimento al documento incorporato utilizzando il modulo nidificato.
db.pets.find({
"specs" : {
"height" : 400,
"weight" : 15,
"color" : "brown"
}
})Risultato:
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } } Quando si utilizza il modulo nidificato, la query deve corrispondere esattamente all'intero documento incorporato. Ad esempio, la seguente query non corrisponde:
db.pets.find({
"specs" : {
"height" : 400
}
})Formatta i risultati
Il risultato dell'esempio precedente è stato restituito in una riga. Puoi usare cursor.pretty() metodo per configurare il cursore per visualizzare i risultati in un formato più leggibile.
Per usare pretty() metodo, aggiungilo a find() metodo.
Esempio:
db.pets.find({ "_id": 6 }).pretty()Risultato:
{
"_id" : 6,
"name" : "Fetch",
"type" : "Dog",
"specs" : {
"height" : 400,
"weight" : 15,
"color" : "brown"
}
} Array
Puoi fare riferimento ai dati negli array facendo riferimento all'elemento dell'array in base al suo indice o al suo valore.
Supponiamo di inserire il seguente documento:
db.pets.insertOne({
"_id" : 7,
"name" : "Jake",
"type" : "Dog",
"awards" : [
"Top Dog",
"Best Dog",
"Biggest Dog"
]
}) Se volessimo trovare tutti i cani con il premio Top Dog, potremmo scrivere la seguente query (che restituirà il cane sopra).
db.pets.find({
"awards": "Top Dog"
}).pretty()Risultato:
{
"_id" : 7,
"name" : "Jake",
"type" : "Dog",
"awards" : [
"Top Dog",
"Best Dog",
"Biggest Dog"
]
} Puoi anche specificare l'indice dell'elemento, in questo modo:
db.pets.find({
"awards.0": "Top Dog"
}).pretty()Ciò richiede che il valore specificato sia all'indice specificato. Pertanto, la query seguente non restituisce lo stesso cane.
db.pets.find({
"awards.1": "Top Dog"
}).pretty()Si noti che gli array sono in base zero, quindi un indice di 0 specifica il primo elemento, 1 specifica il secondo elemento e così via.
Proiezioni
Per impostazione predefinita, tutti i campi del documento vengono restituiti quando utilizzi find() . Ma puoi utilizzare le proiezioni per ridurre il numero di campi restituiti, se necessario.
Potresti ricordare che la sintassi per find() va così:
db.collection.find(query, projection)
Dove query fornisce i criteri di filtraggio (che abbiamo fatto negli esempi precedenti) e projection è una proiezione facoltativa che specifica quali campi restituire da eventuali documenti corrispondenti. Pertanto, se vogliamo utilizzare una proiezione, la inseriamo semplicemente dopo la query.
Quando utilizzi una proiezione, puoi specificare i campi da includere , i campi da escludere , o entrambi. Per fare ciò, elenca il nome del campo e un 1 (per includerlo) o 0 (per escluderlo).
La nostra collezione contiene ormai i seguenti documenti:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } }
{ "_id" : 7, "name" : "Jake", "type" : "Dog", "awards" : [ "Top Dog", "Best Dog", "Biggest Dog" ] } Ecco un esempio di utilizzo di una proiezione per specificare i campi da includere:
db.pets.find({}, { name: 1, type: 1 })Risultato:
{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat" }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat" }
{ "_id" : 6, "name" : "Fetch", "type" : "Dog" }
{ "_id" : 7, "name" : "Jake", "type" : "Dog" }
Nota che il _id il campo viene restituito anche se non lo abbiamo incluso nella nostra proiezione. Questo campo è un'eccezione ed è incluso per impostazione predefinita.
Se non vuoi il _id campo da restituire, è necessario escluderlo esplicitamente.
db.pets.find({}, { _id: 0, name: 1, type: 1 })Risultato:
{ "name" : "Wag", "type" : "Dog" }
{ "name" : "Bark", "type" : "Dog" }
{ "name" : "Meow", "type" : "Cat" }
{ "name" : "Scratch", "type" : "Cat" }
{ "name" : "Bruce", "type" : "Bat" }
{ "name" : "Fetch", "type" : "Dog" }
{ "name" : "Jake", "type" : "Dog" } Ecco un altro esempio, questa volta specifichiamo solo quali campi escludere.
db.pets.find({}, { _id: 0, weight: 0, specs: 0, awards: 0 })Risultato:
{ "name" : "Wag", "type" : "Dog" }
{ "name" : "Bark", "type" : "Dog" }
{ "name" : "Meow", "type" : "Cat" }
{ "name" : "Scratch", "type" : "Cat" }
{ "name" : "Bruce", "type" : "Bat" }
{ "name" : "Fetch", "type" : "Dog" }
{ "name" : "Jake", "type" : "Dog" } Altre proiezioni
Ci sono varie altre cose che puoi fare con le proiezioni. Ad esempio, a partire da MongDB 4.4 è possibile utilizzare espressioni aggregate per specificare il valore di un campo proiettato.
Esempio:
db.pets.find({}, {
"_id": 0,
"n": "$name",
"t": "$type",
"w": "$weight"
})Risultato:
{ "n" : "Wag", "t" : "Dog", "w" : 20 }
{ "n" : "Bark", "t" : "Dog", "w" : 10 }
{ "n" : "Meow", "t" : "Cat", "w" : 7 }
{ "n" : "Scratch", "t" : "Cat", "w" : 8 }
{ "n" : "Bruce", "t" : "Bat", "w" : 3 }
{ "n" : "Fetch", "t" : "Dog" }
{ "n" : "Jake", "t" : "Dog" }
Qui, abbiamo rinominato i nomi dei campi. Lo abbiamo fatto specificando un nuovo nome per ogni campo come una stringa letterale, usando il $fieldName sintassi per generare il valore di quel campo. Il risultato è un po' come usare gli alias in SQL.
Maggiori informazioni
Consulta la documentazione di MongoDB per ulteriori informazioni.
