MongoDB znajdź()

W MongoDB db.collection.find() metoda wybiera dokumenty w kolekcji lub widoku i zwraca kursor do wybranych dokumentów.

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

Możesz go użyć do zwrotu wszystkich dokumentów, tylko niektórych lub tylko jednego dokumentu. Możesz również określić, które pola mają zostać zwrócone.

Należy pamiętać, że tak naprawdę nie zwraca dokumentów. Zwraca jedynie kursor do dokumentów. Powiedziawszy to, łatwiej jest powiedzieć, że „zwraca dokumenty” i zazwyczaj jest to określane w taki sposób – także w tym artykule 🙂

Zwróć wszystkie dokumenty

Oto przykład do zademonstrowania.

db.pets.find()

Wynik:

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

Tutaj używamy find() metoda zwracania wszystkich dokumentów od pets kolekcja. Wiemy, że zwraca to wszystkie dokumenty, ponieważ nie podaliśmy żadnych kryteriów filtrowania. W rzeczywistości nie przedstawiliśmy żadnych argumentów.

Po wywołaniu bez argumentów, find() zwraca wszystkie dokumenty z kolekcji i zwraca wszystkie pola dla dokumentów.

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

db.pets.find({})

W tym przypadku przekazujemy pusty dokument.

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

Filtruj wyniki

Rzeczywista składnia find() idzie tak:

db.collection.find(query, projection)

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

Jeśli przekażesz zapytanie, zostanie ono użyte do filtrowania wyników. 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.find({"type":"Dog"})

Wynik:

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

To zawęziło wyniki tylko do tych dokumentów, które mają type pole o wartości Dog .

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

Wynik:

{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }

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

Sformatuj wyniki

Wynik poprzedniego przykładu został zwrócony w jednym wierszu. Możesz użyć cursor.pretty() metoda konfiguracji kursora w celu wyświetlenia wyników w bardziej czytelnym formacie.

Aby użyć pretty() metody, dołącz go do find() metoda.

Przykład:

db.pets.find({ "_id": 6 }).pretty()

Wynik:

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

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

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

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

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 find() . Ale w razie potrzeby możesz użyć prognoz, aby zmniejszyć liczbę zwracanych pól.

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

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

Obecnie nasza kolekcja zawiera następujące dokumenty:

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

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

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

Wynik:

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

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

Wynik:

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

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

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

Wynik:

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

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

Wynik:

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

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 przypomina trochę użycie aliasów w SQL.

Więcej informacji

Więcej informacji znajdziesz w dokumentacji MongoDB.