MongoDB
 sql >> Database >  >> NoSQL >> MongoDB

MongoDB trovauno()

In MongoDB il db.collection.findOne() restituisce un documento che soddisfa i criteri di query specificati nella raccolta o nella visualizzazione.

La collection part è il nome della raccolta o della vista da cercare.

findOne() è simile a find() , tranne che findOne() restituisce solo il primo documento che corrisponde ai criteri di filtro, secondo l'ordine naturale che riflette l'ordine dei documenti sul disco.

Il find() metodo d'altra parte, restituisce tutti i documenti corrispondenti.

Inoltre, findOne() restituisce il documento effettivo, mentre find() restituisce solo un cursore per ogni documento. Pertanto, non puoi applicare i metodi del cursore a findOne() come puoi con find() .

Esempio

Supponiamo di avere una collezione chiamata pets con 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 }

Possiamo usare findOne() per restituire un documento.

db.pets.findOne()

Risultato:

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }

Qui, abbiamo cercato in tutti i documenti in pets collezione. Sappiamo che questo ha cercato tutti i documenti perché non abbiamo fornito alcun criterio di filtraggio. Non abbiamo nemmeno fornito argomenti.

Quando viene chiamato senza argomenti, findOne() ricerca tutti i documenti da una raccolta e restituisce tutti i campi per il documento corrispondente.

Un altro modo per fare quanto sopra è questo:

db.pets.findOne({})

In questo caso passiamo un documento vuoto.

Aggiungendo a questo documento vuoto, possiamo iniziare a filtrare i risultati.

Fornire una query

La sintassi effettiva di findOne() va così:

db.collection.findOne(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 l'ambito della ricerca solo per quei documenti che corrispondono alla query. 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.findOne({"type":"Cat"})

Risultato:

{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }

Ciò ha ristretto la ricerca ai soli documenti che hanno un type campo con un valore di Cat , quindi findOne() restituito il primo documento da quel risultato.

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.findOne({"weight": { $lt: 10 }})

Risultato:

{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }

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.findOne({ "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.findOne({ 
    "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.findOne({ 
    "specs" : {
		"height" : 400
	}
 })

Risultato:

null

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.findOne({ 
    "awards": "Top Dog"
})

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.findOne({ 
    "awards.0": "Top Dog"
})

Ciò richiede che il valore specificato sia all'indice specificato. Pertanto, la query seguente non restituisce lo stesso cane.

db.pets.findOne({ 
    "awards.1": "Top Dog"
})

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 usi findOne() . Ma puoi utilizzare le proiezioni per ridurre il numero di campi restituiti, se necessario.

Potresti ricordare che la sintassi per findOne() va così:

db.collection.findOne(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).

Ecco un esempio di utilizzo di una proiezione per specificare i campi da includere:

db.pets.findOne({}, { name: 1, type: 1 })

Risultato:

{ "_id" : 1, "name" : "Wag", "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.findOne({}, { _id: 0, name: 1, type: 1 })

Risultato:

{ "name" : "Wag", "type" : "Dog" }

Ecco un altro esempio, questa volta specifichiamo solo quali campi escludere.

db.pets.findOne({}, { _id: 0, weight: 0, specs: 0, awards: 0 })

Risultato:

{ "name" : "Wag", "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.findOne({}, { 
    "_id": 0,
    "n": "$name", 
    "t": "$type", 
    "w": "$weight" 
    })

Risultato:

{ "n" : "Wag", "t" : "Dog", "w" : 20 }

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 produrre 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.