Jak zarządzać dokumentami w MongoDB

Wprowadzenie

Korzystając z MongoDB, spędzasz większość czasu na zarządzaniu dokumentami w taki czy inny sposób. Niezależnie od tego, czy tworzysz nowe dokumenty i dodajesz je do kolekcji, pobierasz dokumenty, aktualizujesz dane, czy usuwasz nieaktualne elementy, dokumenty są w centrum modelu MongoDB.

W tym przewodniku omówimy, czym są dokumenty MongoDB, a następnie omówimy typowe operacje, o których prawdopodobnie będziesz musiał wiedzieć, aby zarządzać środowiskiem skoncentrowanym na dokumentach.

Co to są dokumenty MongoDB?

W MongoDB wszystkie dane w bazach danych i kolekcjach są przechowywane w dokumentach. Ponieważ kolekcje domyślnie nie określają wymaganego schematu, dokumenty w kolekcji mogą zawierać dowolnie złożoną strukturę i nie muszą być zgodne z formatem używanym przez dokumenty równorzędne. Zapewnia to niesamowitą elastyczność i umożliwia organiczny rozwój schematu w miarę zmiany wymagań aplikacji.

Same dokumenty MongoDB używają formatu serializacji danych BSON, binarnej reprezentacji JSON JavaScript Object Notation. Zapewnia to zorganizowaną strukturę ze zdefiniowanymi typami danych, które mogą być wyszukiwane i obsługiwane programowo.

Dokumenty BSON są reprezentowane przez parę nawiasów klamrowych ({} ), które zawierają pary klucz-wartość. W BSON te dwuwiersze danych są znane jako pole i jego wartość . Pole znajduje się na pierwszym miejscu i jest reprezentowane przez łańcuch. Wartość może być dowolnym prawidłowym typem danych BSON. Dwukropek (: ) oddziela pole od jego wartości. Przecinek służy do oddzielenia od siebie każdego pola i pary wartości.

Jako przykład, oto ważny dokument BSON, który MongoDB może zrozumieć:

{    _id: 80380,    vehicle_type: "car",    mileage: 7377.80,    color: "blue",    markets: [        "US",        "UK"    ],    options: {        transmission: "automatic",        num_doors: 4,        power_windows: true    }}
 

Tutaj możemy zobaczyć kilka typów:

• _id jest liczbą całkowitą
• vehicle_type i color są ciągami
• mileage jest pływakiem
• markets jest tablicą ciągów
• options zawiera zagnieżdżony dokument z wartościami składającymi się z łańcucha, liczby całkowitej i wartości logicznej

Ze względu na tę elastyczność dokumenty są dość elastycznym nośnikiem do przechowywania danych. Nowe pola można łatwo dodawać, dokumenty można osadzić jeden w drugim, a złożoność strukturalna dokładnie odpowiada przechowywanym danym.

Jak tworzyć nowe dokumenty

Aby utworzyć nowy dokument, przejdź do bazy danych, w której chcesz przechowywać utworzony dokument. Użyjemy school baza danych do celów demonstracyjnych w tym artykule:

use school
 

Będziesz także chciał wybrać kolekcję, do której chcesz wstawić dokumenty. Podobnie jak w przypadku baz danych, nie musisz jawnie tworzyć kolekcji, do której chcesz wstawić dokument. MongoDB utworzy go automatycznie po zapisaniu pierwszych danych. W tym przykładzie użyjemy kolekcji o nazwie students .

Teraz, gdy wiesz, gdzie będzie przechowywany dokument, możesz wstawić nowy dokument, korzystając z jednej z następujących metod.

Korzystanie z insert() metoda

insert() Metoda pozwala wstawić jeden lub więcej dokumentów do kolekcji, w której jest wywoływana.

Aby wstawić pojedynczy dokument, przekaż dokument do metody, wywołując go w kolekcji. Tutaj wstawiamy nowy dokument dla ucznia o imieniu Ashley:

db.students.insert(    {        first_name: "Ashley",        last_name: "Jenkins",        dob: new Date("January 08, 2003"),        grade_level: 8    })
 

WriteResult({ "nInserted" : 1 })
 

Jeśli chcesz wstawić więcej niż jeden dokument w tym samym czasie, zamiast przekazywać dokument do insert() , przekaż tablicę dokumentów. Możemy dodać dwa nowe dokumenty dla uczniów o imieniu Brian i Leah:

db.students.insert(    [        {            first_name: "Brian",            last_name: "McMantis",            dob: new Date("September 18, 2010"),            grade_level: 2        },        {            first_name: "Leah",            last_name: "Drake",            dob: new Date("October 03, 2009")        }    ])
 

BulkWriteResult({        "writeErrors" : [ ],        "writeConcernErrors" : [ ],        "nInserted" : 2,        "nUpserted" : 0,        "nMatched" : 0,        "nModified" : 0,        "nRemoved" : 0,        "upserted" : [ ]})
 

Ponieważ wykonaliśmy operację zapisu zbiorczego, naszą wartością zwracaną jest BulkWriteResult zamiast WriteResult obiekt, który widzieliśmy wcześniej.

Podczas gdy insert() Metoda jest elastyczna, została przestarzała w wielu sterownikach MongoDB na rzecz dwóch następujących metod.

Korzystanie z insertOne() metoda

insertOne() metoda może być użyta do wstawienia pojedynczego dokumentu. W przeciwieństwie do insert() metoda, może wstawić tylko jeden dokument na raz, co sprawia, że ​​jego zachowanie jest nieco bardziej przewidywalne.

Składnia jest taka sama jak w przypadku użycia insert() dodać pojedynczy dokument. Możemy dodać kolejną uczennicę o imieniu Naomi:

db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 

{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}
 

W przeciwieństwie do insert() , insertOne() Metoda zwraca dokument zawierający dodatkowe przydatne informacje. Potwierdza, że ​​zapis został potwierdzony przez klaster i zawiera identyfikator obiektu, który został przypisany do dokumentu, ponieważ go nie podaliśmy.

Korzystanie z insertMany() metoda

Aby uwzględnić scenariusze, w których chcesz wstawić wiele dokumentów jednocześnie, insertMany() metoda jest teraz zalecana. Tak jak w przypadku wstawiania wielu dokumentów za pomocą insert() , insertMany() pobiera tablicę dokumentów.

Możemy dodać trzech nowych uczniów o imieniu Jasmine, Michael i Toni:

db.students.insertMany(    [        {            first_name: "Jasmine",            last_name: "Took",            dob: new Date("April 11, 2011")        },        {            first_name: "Michael",            last_name: "Rodgers",            dob: new Date("February 25, 2008"),            grade_level: 6        },        {            first_name: "Toni",            last_name: "Fowler"        }    ])
 

{        "acknowledged" : true,        "insertedIds" : [                ObjectId("60e8792d4655cbf49ff7cb87"),                ObjectId("60e8792d4655cbf49ff7cb88"),                ObjectId("60e8792d4655cbf49ff7cb89")        ]}
 

Tak jak w przypadku insertOne() , insertMany() zwraca dokument, który potwierdza zapis i dostarcza tablicę zawierającą identyfikatory, które zostały przypisane do wstawionych dokumentów.

Jak wyszukiwać istniejące dokumenty

Zapytania o dokumenty to dość obszerny temat, który zasługuje na osobny artykuł. Szczegółowe informacje na temat formułowania zapytań w celu pobrania różnych typów dokumentów można znaleźć w naszym przewodniku dotyczącym zapytań o dane w MongoDB.

Chociaż szczegóły najlepiej pozostawić w artykule, do którego link znajduje się powyżej, możemy przynajmniej omówić metody, które MongoDB udostępnia do wyszukiwania dokumentów. Głównym sposobem pobierania dokumentów z MongoDB jest wywołanie funkcji find() metody na danej kolekcji.

Na przykład, aby zebrać wszystkie dokumenty od students , możesz wywołać find() bez argumentów:

db.students.find()
 

{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb85"), "first_name" : "Leah", "last_name" : "Drake", "dob" : ISODate("2009-10-03T00:00:00Z") }{ "_id" : ObjectId("60e877914655cbf49ff7cb86"), "first_name" : "Naomi", "last_name" : "Pyani" }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb87"), "first_name" : "Jasmine", "last_name" : "Took", "dob" : ISODate("2011-04-11T00:00:00Z") }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Aby dane wyjściowe były bardziej czytelne, możesz także połączyć pretty() metoda po find() :

db.<collection>.find().pretty()
 

{        "_id" : ObjectId("60e8743b4655cbf49ff7cb83"),        "first_name" : "Ashley",        "last_name" : "Jenkins",        "dob" : ISODate("2003-01-08T00:00:00Z"),        "grade_level" : 8}{        "_id" : ObjectId("60e875d54655cbf49ff7cb84"),        "first_name" : "Brian",        "last_name" : "McMantis",        "dob" : ISODate("2010-09-18T00:00:00Z"),        "grade_level" : 2}{        "_id" : ObjectId("60e875d54655cbf49ff7cb85"),        "first_name" : "Leah",        "last_name" : "Drake",        "dob" : ISODate("2009-10-03T00:00:00Z")}{        "_id" : ObjectId("60e877914655cbf49ff7cb86"),        "first_name" : "Naomi",        "last_name" : "Pyani"}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb87"),        "first_name" : "Jasmine",        "last_name" : "Took",        "dob" : ISODate("2011-04-11T00:00:00Z")}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb88"),        "first_name" : "Michael",        "last_name" : "Rodgers",        "dob" : ISODate("2008-02-25T00:00:00Z"),       "grade_level" : 6}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb89"),        "first_name" : "Toni",        "last_name" : "Fowler"}
 

Widać, że _id pole zostało dodane do każdego z dokumentów. MongoDB wymaga unikalnego _id dla każdego dokumentu w kolekcji. Jeśli nie podasz go podczas tworzenia obiektu, doda go za Ciebie. Możesz użyć tego identyfikatora, aby niezawodnie pobrać pojedynczy obiekt:

db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 

{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Możesz dowiedzieć się więcej o różnych sposobach wyszukiwania danych w artykule, do którego link znajduje się powyżej.

Jak zaktualizować istniejące dokumenty

Wiele lub większość przypadków użycia baz danych wymaga możliwości modyfikowania istniejących danych w bazie danych. Pole może wymagać aktualizacji w celu odzwierciedlenia nowej wartości lub może być konieczne dodanie dodatkowych informacji do istniejącego dokumentu, gdy stanie się dostępny.

MongoDB używa kilku powiązanych metod do aktualizacji istniejących dokumentów:

• updateOne() :Aktualizuje pojedynczy dokument w kolekcji na podstawie dostarczonego filtra.
• updateMany() :Aktualizuje wiele dokumentów w kolekcji, które pasują do podanego filtra.
• replaceOne() :Zastępuje cały dokument w kolekcji na podstawie dostarczonego filtra.

Omówimy, jak używać każdej z tych odmian do wykonywania różnych rodzajów aktualizacji.

Aktualizuj operatory

Zanim przyjrzymy się każdej z metod aktualizacji dokumentów, powinniśmy przejrzeć niektóre dostępne operatory aktualizacji.

• $currentDate :Ustawia wartość pola na bieżącą datę, jako typ daty lub znacznika czasu.
  • Składnia:{ $currentDate: { <field>: <type>, ... } }
• $inc :Zwiększa wartość pola o ustaloną kwotę.
  • Składnia:{ $inc: { <field>: <amount>, ... } }
• $min :Aktualizuje wartość pola, jeśli określona wartość jest mniejsza niż wartość bieżąca.
  • Składnia:{ $min: { <field>: <value>, ... } }
• $max :Aktualizuje wartość pola, jeśli określona wartość jest większa niż wartość bieżąca.
  • Składnia:{ $max: { <field>: <value>, ... } }
• $mul :Aktualizuje wartość pola, mnożąc ją przez podaną liczbę.
  • Składnia:{ $mul: { <field>: <value>, ... } }
• $rename :Zmienia nazwę pola na nowy identyfikator.
  • Składnia:{ $rename: { <field>: <new_name>, ... } }
• $set :Zastępuje wartość pola podaną wartością.
  • Składnia:{ $set: { <field>: value, ... } }
• $setOnInsert :Podczas operacji upsert ustawia wartość pola, jeśli tworzony jest nowy dokument i nie robi nic innego.
  • Składnia:{ $setOnInsert: { <field>: <value>, ... } }
• $unset :Usuwa pole z dokumentu.
  • Składnia:{ $unset: { <field>: "", ... } }
• $ :Symbol zastępczy dla pierwszego elementu tablicy, który spełnia zapytanie.
  • Składnia:{ <update_operator>: {<array>.$: <value> } }
• $[] :Symbol zastępczy dla wszystkich elementów tablicy, które spełniają zapytanie.
  • Składnia:{ <update_operator>: { <array>.$[]: <value> } }
• $addToSet :Dodaje wartości do tablicy, chyba że są już obecne.
  • Składnia:{ $addToSet: { <field>: <value>, ... } }
• $pop :Usuwa pierwszy lub ostatni element tablicy.
  • Składnia:{ $pop: { <field>: (-1 or 1), ... } }
• $pull :Usuwa wszystkie elementy tablicy, które pasują do warunku.
  • Składnia:{ $pull: { <field>: <condition>, ... } }
• $push :Dołącza wartość do tablicy.
  • Składnia:{ $push: { <field>: <value>, ... } }
• $pullAll :Usuwa wszystkie określone elementy z tablicy.
  • Składnia:{ $pullAll: { <field>: [ <value>, ... ], ...} }
• $each :Modyfikuje $addToSet i $push operatorów, tak aby dodawały każdy element tablicy zamiast tablicy jako pojedynczy element.
  • Składnia:{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
• $position :Używane z $each i określa pozycję $push operator powinien wstawić w.
  • Składnia:{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
• $slice :Używane z $each i $push aby ograniczyć liczbę wszystkich elementów w tablicy.
  • Składnia:{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
• $sort :Używane z $each i $push do sortowania elementów tablicy.
  • Składnia:{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Te różne operatory aktualizacji umożliwiają aktualizowanie różnych pól dokumentów na różne sposoby.

Aktualizacja pojedynczego dokumentu w kolekcji

updateOne() MongoDB Metoda służy do aktualizacji pojedynczego dokumentu w kolekcji. Metoda przyjmuje dwa wymagane argumenty oraz dokument określający argumenty opcjonalne.

Pierwszym argumentem jest dokument określający warunki filtrowania, które będą używane do wybierania dokumentów. Od updateOne() Metoda modyfikuje co najwyżej jeden dokument w kolekcji, zostanie użyty pierwszy dokument spełniający warunki filtrowania.

Drugi argument określa operację aktualizacji, która powinna zostać wykonana. Powyższe operacje aktualizacji można określić tutaj, aby zmienić zawartość dopasowanego dokumentu.

Trzeci argument to dokument zawierający różne opcje modyfikacji zachowania metody. Najważniejsze potencjalne wartości to:

• upsert :Zamienia operację w procedurę upsert przez wstawienie nowego dokumentu, jeśli filtr nie pasuje do żadnych istniejących dokumentów.
• collation :dokument definiujący specyficzne dla języka zasady, które powinny obowiązywać podczas operacji.

Jako przykład możemy zaktualizować pojedynczy rekord ucznia, który filtrujemy według _id pole, aby upewnić się, że kierujemy na właściwy dokument. Możemy ustawić grade_level do nowej wartości:

db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Aktualizowanie wielu dokumentów w kolekcji

updateMany() MongoDB metoda działa podobnie do metody updateOne() metody, ale zamiast tego aktualizuje każdy dokument, który pasuje do danego filtra, zamiast zatrzymywać się po pierwszym dopasowaniu.

updateMany() składnia dokładnie odpowiada updateOne() składnia, więc jedyną różnicą jest zakres operacji.

Na przykład, jeśli chcemy zmienić wszystkie wystąpienia "składu" na "pisanie" w subjects tablica u naszych teachers dokumentów inkasowych, moglibyśmy użyć czegoś takiego:

db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
 

Jeśli sprawdzisz dokumenty, każde wystąpienie „składu” powinno zostać zastąpione przez „pisanie”:

db.teachers.find()
 

{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Nancy", "last_name" : "Smith", "subjects" : [ "vocabulary", "pronunciation" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }
 

Zastępowanie dokumentu

replaceOne() metoda działa podobnie do metody updateOne() metody, ale zastępuje cały dokument zamiast aktualizować poszczególne pola. Składnia jest taka sama jak w poprzednich dwóch poleceniach.

Na przykład, jeśli Nancy Smith opuści twoją szkołę i zastąpisz ją nauczycielką o imieniu Clara Newman, która uczy literatury, możesz wpisać:

db.teachers.replaceOne(    {        $and: [             { first_name: "Nancy" },            { last_name: "Smith" }        ]    },    {        first_name: "Clara",        last_name: "Newman",        subjects: [ "literature" ]    })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Możesz zobaczyć, że dopasowany dokument został usunięty, a określony dokument go zastąpił:

db.teachers.find()
 

{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Clara", "last_name" : "Newman", "subjects" : [ "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }
 

Jak usunąć dokumenty

Usuwanie dokumentów ze zbiorów jest również częścią cyklu życia dokumentu. Aby usunąć dokument, możesz użyć deleteOne() lub deleteMany() metody. Mają tę samą składnię i różnią się tylko liczbą dokumentów, na których działają.

W większości przypadków wszystko, co musisz zrobić, aby usunąć dokumenty za pomocą jednej z tych metod, to zapewnić im filtr dokumentu, który określa, w jaki sposób chcesz wybrać dokument do usunięcia. deleteOne() Metoda usunie co najwyżej jeden dokument (niezależnie od tego, ile dopasowań tworzy filtr), podczas gdy deleteMany() metoda usuwa każdy dokument, który pasuje do warunków filtrowania.

Na przykład, aby usunąć jednego ucznia, możesz podać _id aby dokładnie je dopasować:

db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 

{ "acknowledged" : true, "deletedCount" : 1 }
 

Jeśli chcemy usunąć dowolnego ucznia, który nie ma przypisanego poziomu oceny, możemy użyć deleteMany() zamiast tego metoda:

db.students.deleteMany({    grade_level: { $eq: null }})
 

{ "acknowledged" : true, "deletedCount" : 2 }
 

Jeśli sprawdzimy, powinniśmy zobaczyć, że wszyscy pozostali uczniowie mają przypisany poziom oceny:

db.students.find()
 

{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler", "grade_level" : 3 }
 

Wniosek

Uczenie się, jak tworzyć, wyszukiwać, aktualizować i usuwać dokumenty, daje Ci umiejętności potrzebne do skutecznego zarządzania dokumentami w MongoDB na co dzień. Zapoznanie się z różnymi metodami gromadzenia i gromadzenia dokumentów oraz operatorami, które pozwalają dopasowywać i modyfikować informacje, pozwala wyrazić złożone myśli, które system bazy danych może zrozumieć.