MongoDB findOne()

W MongoDB db.collection.findOne() metoda zwraca jeden dokument, który spełnia określone kryteria zapytania w kolekcji lub widoku.

collection część to nazwa kolekcji lub widoku do przeszukania.

findOne() jest podobny do find() , z wyjątkiem tego, że findOne() zwraca tylko pierwszy dokument, który spełnia kryteria filtrowania, zgodnie z naturalną kolejnością, która odzwierciedla kolejność dokumentów na dysku.

find() z drugiej strony, metoda zwraca wszystkie pasujące dokumenty.

Również findOne() zwraca rzeczywisty dokument, podczas gdy find() tylko zwraca kursor do każdego dokumentu. Dlatego nie możesz zastosować metod kursora do findOne() tak jak możesz z find() .

Przykład

Załóżmy, że mamy kolekcję o nazwie pets z następującymi dokumentami:

{ "_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 }

Możemy użyć findOne() zwrócić jeden dokument.

db.pets.findOne()

Wynik:

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

Tutaj przeszukaliśmy wszystkie dokumenty w sekcji pets kolekcja. Wiemy, że przeszukało to wszystkie dokumenty, ponieważ nie podaliśmy żadnych kryteriów filtrowania. Nie przedstawiliśmy nawet żadnych argumentów.

Po wywołaniu bez argumentów, findOne() przeszukuje wszystkie dokumenty z kolekcji i zwraca wszystkie pola pasującego dokumentu.

Inny sposób na wykonanie powyższego jest taki:

db.pets.findOne({})

W tym przypadku przekazujemy pusty dokument.

Dodając do tego pustego dokumentu, możemy zacząć filtrować wyniki.

Dodaj zapytanie

Rzeczywista składnia findOne() idzie tak:

db.collection.findOne(query, projection)

Oznacza to, że możesz przekazać zapytanie jako pierwszy argument, a projekcję jako drugi.

Jeśli przekażesz zapytanie, jest ono używane do filtrowania zakresu wyszukiwania tylko do tych dokumentów, które pasują do zapytania. Zapytanie to dokument zawierający operatory zapytań. Jak widzieliśmy w poprzednim przykładzie, pusty dokument zwraca wszystkie dokumenty.

Zawęźmy wyniki do podzbioru dokumentów w kolekcji.

db.pets.findOne({"type":"Cat"})

Wynik:

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

To zawęziło wyszukiwanie tylko do tych dokumentów, które mają type pole o wartości Cat , a następnie findOne() zwrócił pierwszy dokument z tego wyniku.

W tym przypadku po prostu przekazaliśmy dokument jako kryteria filtrowania.

Możesz także użyć operatorów zapytań. Pozwalają one na zastosowanie bardziej szczegółowych kryteriów do zapytania.

Przykład:

db.pets.findOne({"weight": { $lt: 10 }})

Wynik:

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

Osadzone dokumenty

Jeśli masz dokumenty zawierające osadzone dokumenty, możesz użyć następujących metod do zapytania o dane w osadzonych dokumentach.

Zapis kropkowy (np. field.nestedfield: <value> )
Forma zagnieżdżona (np. { field: { nestedfield: <value> } } ). Pamiętaj, że ta opcja jest dostępna tylko w MongoDB 4.4.

Załóżmy, że wstawiamy następujący dokument.

db.pets.insertOne({
    "_id" : 6,
    "name" : "Fetch",
    "type" : "Dog",
    "specs" : {
        "height" : 400,
        "weight" : 15,
        "color" : "brown"
    }
})

Możemy użyć notacji kropkowej do zapytania w osadzonym dokumencie.

db.pets.findOne({ "specs.height": 400 })

Wynik:

{
	"_id" : 6,
	"name" : "Fetch",
	"type" : "Dog",
	"specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
}

Poniższe zapytanie zwraca ten sam dokument, z tym wyjątkiem, że tym razem odwołujemy się do osadzonego dokumentu za pomocą formularza zagnieżdżonego.

db.pets.findOne({ 
    "specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
 })

Wynik:

{
	"_id" : 6,
	"name" : "Fetch",
	"type" : "Dog",
	"specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
}

W przypadku korzystania z formularza zagnieżdżonego zapytanie musi dokładnie pasować do całego osadzonego dokumentu. Na przykład następujące zapytanie nie pasuje:

db.pets.findOne({ 
    "specs" : {
		"height" : 400
	}
 })

Wynik:

null

Tablice

Możesz odwoływać się do danych w tablicach, odwołując się do elementu tablicy przez jego indeks lub jego wartość.

Załóżmy, że wstawiamy następujący dokument:

db.pets.insertOne({
    "_id" : 7,
    "name" : "Jake",
    "type" : "Dog",
    "awards" : [
        "Top Dog",
        "Best Dog",
        "Biggest Dog"
    ]
})

Gdybyśmy chcieli znaleźć wszystkie psy z nagrodą Top Dog, moglibyśmy napisać następujące zapytanie (które zwróci powyższego psa).

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

Wynik:

{
	"_id" : 7,
	"name" : "Jake",
	"type" : "Dog",
	"awards" : [
		"Top Dog",
		"Best Dog",
		"Biggest Dog"
	]
}

Możesz również określić indeks elementu w następujący sposób:

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

Wymaga to, aby określona wartość znajdowała się pod określonym indeksem. Dlatego następujące zapytanie nie zwraca tego samego psa.

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

Zauważ, że tablice są liczone od zera, więc indeks 0 określa pierwszy element, 1 określa drugi element i tak dalej.

Projekcje

Domyślnie wszystkie pola dokumentu są zwracane, gdy używasz findOne() . Ale w razie potrzeby możesz użyć prognoz, aby zmniejszyć liczbę zwracanych pól.

Być może pamiętasz, że składnia findOne() idzie tak:

db.collection.findOne(query, projection)

Gdzie query udostępnia kryteria filtrowania (co zrobiliśmy w powyższych przykładach) oraz projection to opcjonalna projekcja, która określa, które pola mają zostać zwrócone z dowolnych pasujących dokumentów. Dlatego jeśli chcemy użyć projekcji, po prostu umieszczamy ją po zapytaniu.

Korzystając z projekcji, możesz określić pola do uwzględnienia , pola do wykluczenia , lub oba. Aby to zrobić, podaj nazwę pola i albo 1 (aby to uwzględnić) lub 0 (aby to wykluczyć).

Oto przykład użycia rzutowania do określenia pól do uwzględnienia:

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

Wynik:

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

Zauważ, że _id pole jest zwracane, mimo że nie uwzględniliśmy go w naszej projekcji. To pole jest wyjątkiem i jest uwzględniane domyślnie.

Jeśli nie chcesz _id pole, które ma zostać zwrócone, musisz je wyraźnie wykluczyć.

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

Wynik:

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

Oto kolejny przykład, tym razem określamy tylko, które pola należy wykluczyć.

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

Wynik:

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

Więcej projekcji

Jest wiele innych rzeczy, które możesz zrobić z projekcjami. Na przykład, począwszy od MongDB 4.4, możesz użyć wyrażeń agregujących, aby określić wartość przewidywanego pola.

Przykład:

db.pets.findOne({}, { 
    "_id": 0,
    "n": "$name", 
    "t": "$type", 
    "w": "$weight" 
    })

Wynik:

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

Tutaj zmieniliśmy nazwy pól. Zrobiliśmy to, określając nową nazwę dla każdego pola jako literał ciągu, używając $fieldName składnia do wyświetlenia tej wartości pól. Rezultat jest trochę podobny do używania aliasów w SQL.

Więcej informacji

Więcej informacji znajdziesz w dokumentacji MongoDB.