Wprowadzenie do typów danych MongoDB

Wprowadzenie

Korzystając z MongoDB, masz możliwość elastycznego podejścia do struktury swoich danych. Nie jesteś ograniczony do utrzymywania określonego schematu, do którego muszą pasować wszystkie twoje dokumenty. Dla dowolnego pola w dokumencie możesz użyć dowolnego z dostępnych typów danych obsługiwane przez MongoDB. Pomimo tego domyślnego sposobu pracy, w razie potrzeby możesz narzucić schemat JSON w MongoDB, aby dodać walidację do swoich kolekcji. W tym przewodniku nie będziemy omawiać szczegółów projektowania schematu, ale może to mieć wpływ na typowanie danych, jeśli zostanie zaimplementowane.

Typy danych określają ogólny wzorzec dla danych, które akceptują i przechowują. Podczas planowania bazy danych najważniejsze jest, aby zrozumieć, kiedy wybrać określony typ danych, a nie inny. Wybrany typ będzie dyktować, jak możesz operować na swoich danych i jak są przechowywane.

JSON i BSON

Zanim przejdziemy do szczegółów konkretnych typów danych, ważne jest, aby zrozumieć, w jaki sposób MongoDB przechowuje dane. MongoDB i wiele innych baz danych NoSQL opartych na dokumentach używa formatu JSON (JavaScript Object Notation) do reprezentowania rekordów danych jako dokumentów.

Korzystanie z formatu JSON do przechowywania danych ma wiele zalet. Niektóre z nich to:

• łatwość czytania, uczenia się i jej znajomość wśród programistów
• elastyczność w formacie, zarówno rzadka, hierarchiczna, jak i głęboko zagnieżdżona
• samoopisujący się, który pozwala aplikacjom na łatwe działanie z danymi JSON
• pozwala na skupienie się na minimalnej liczbie podstawowych typów

JSON obsługuje wszystkie podstawowe typy danych, takie jak ciąg, liczba, wartość logiczna itp. MongoDB faktycznie przechowuje rekordy danych jako dokumenty JSON zakodowane binarnie (BSON). Podobnie jak JSON, BSON obsługuje osadzanie dokumentów i tablic w innych dokumentach i tablicach. BSON pozwala na dodatkowe typy danych, które nie są dostępne dla JSON.

Jakie są typy danych w MongoDB?

Zanim przejdziemy do szczegółów, przyjrzyjmy się ogólnie, jakie typy danych są obsługiwane w MongoDB.

MongoDB obsługuje szereg typów danych odpowiednich dla różnych typów danych zarówno prostych, jak i złożonych. Należą do nich:

Tekst

• String

Numeryczne

• 32-Bit Integer
• 64-Bit Integer
• Double
• Decimal128

Data/godzina

• Date
• Timestamp

Inne

• Object
• Array
• Binary Data
• ObjectId
• Boolean
• Null
• Regular Expression
• JavaScript
• Min Key
• Max Key

W MongoDB każdy typ BSON ma zarówno identyfikatory całkowite, jak i łańcuchowe. W tym przewodniku omówimy najczęstsze z nich bardziej szczegółowo.

Typy stringów

Typ string jest najczęściej używanym typem danych MongoDB. Dowolna wartość zapisana w cudzysłowie "" w JSON jest wartością ciągu. Każda wartość, która ma być przechowywana jako tekst, najlepiej wpisać jako String . Ciągi BSON to UTF-8 i są reprezentowane w MongoDB jako:

        Type         | Number |  Alias   |  ------------------ | ------ | -------- |       String        |    2   | "string" |
 

Zasadniczo sterowniki języków programowania będą konwertować z formatu ciągu języka na UTF-8 podczas serializacji i deserializacji BSON. To sprawia, że ​​BSON jest na przykład atrakcyjną metodą łatwego przechowywania międzynarodowych znaków.

Wstawianie dokumentu z String typ danych będzie wyglądał mniej więcej tak:

db.mytestcoll.insertOne({first_name: "Alex"}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d15")}
 

Zapytanie o kolekcję zwróci następujące informacje:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d15"),         first_name: "Alex"}
 

Korzystanie z $type operator

Przed przejściem do następnego typu danych ważne jest, aby wiedzieć, jak można wpisać, sprawdzić wartość przed wprowadzeniem jakichkolwiek wstawek. Użyjemy poprzedniego przykładu, aby zademonstrować użycie $type operator w MongoDB.

Powiedzmy, że minęło trochę czasu, odkąd pracowaliśmy z mytestcoll odbiór sprzed. Chcemy wstawić kilka dodatkowych dokumentów do kolekcji z first_name pole. Aby sprawdzić, czy użyliśmy String jako typ danych przechowywany jako wartość first_name pierwotnie możemy uruchomić następujące polecenie, używając aliasu lub wartości liczbowej typu danych:

db.mytestcoll.find( { "first_name": { $type: "string" } } )
 

Lub

db.mytestcoll.find( { "first_name": { $type: 2 } } )
 

Oba zapytania zwracają dane wyjściowe wszystkich dokumentów, które mają String wartość przechowywana dla first_name z naszej poprzedniej wstawienia sekcji:

[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
 

Jeśli zapytasz o typ, który nie jest przechowywany w first_name pola dowolnego dokumentu, nie otrzymasz wyniku. Oznacza to, że jest to inny typ danych przechowywany w first_name .

Możesz także wysyłać zapytania o wiele typów danych jednocześnie za pomocą $type operator podobny do następującego:

db.mytestcoll.find( { "first_name": { $type: ["string", "null"] } } )
 

Ponieważ nie wstawiliśmy żadnego Null wpisz wartości do naszej kolekcji, wynik będzie taki sam:

[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
 

Możesz użyć tej samej metody dla wszystkich poniższych typów, które omówimy.

Liczby i wartości numeryczne

MongoDB zawiera szereg liczbowych typów danych odpowiednich dla różnych scenariuszy. Wybór typu do użycia zależy od charakteru wartości, które planujesz przechowywać, oraz przypadków użycia danych. JSON nazywa wszystko, co ma numer, Numer . To zmusza system do wymyślenia, jak przekształcić go w najbliższy natywny typ danych. Zaczniemy od zbadania liczb całkowitych i sposobu ich działania w MongoDB.

Liczba całkowita

Integer typ danych służy do przechowywania liczb jako liczb całkowitych bez ułamków zwykłych lub dziesiętnych. Liczby całkowite mogą być wartościami dodatnimi lub ujemnymi. W MongoDB istnieją dwa typy, 32-Bit Integer i 64-Bit Integer . Mogą być reprezentowane na dwa sposoby przedstawione w poniższej tabeli, number i alias :

  Integer type   | number |    alias     |   ------------   | -----  | ------------ |  `32-bit integer`|   16   |    "int"     | `64-bit integer`|   18   |    "long"    |
 

Zakresy, do których może zmieścić się wartość dla każdego typu, są następujące:

  Integer type   |    Applicable signed range     |    Applicable unsigned range    |  ------------   | ------------------------------ | ------------------------------- | `32-bit integer`| -2,147,483,648 to 2,147,483,647|  0 to 4,294,967,295             | `64-bit integer`| -9,223,372,036,854,775,808 to  |  0 to 18,446,744,073,709,551,615                         9,223,372,036,854,775,807
 

Powyższe typy są ograniczone ich obowiązującym zakresem. Każda wartość poza zakresem spowoduje błąd. Wstawianie Integer wpisz do MongoDB będzie wyglądać jak poniżej:

db.mytestcoll.insertOne({age: 26}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d14")}
 

A znalezienie wyniku zwróci następujące informacje:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"), age: 26}
 

Jak sugerują nazwy, 32-Bit Integer ma 32 bity dokładności liczb całkowitych, co jest przydatne w przypadku mniejszych wartości liczb całkowitych, których nie chcesz przechowywać jako ciąg cyfr. Gdy rośnie rozmiar liczby, możesz podskoczyć do 64-Bit Integer który ma 64 bity precyzji w liczbach całkowitych i pasuje do tego samego przypadku użycia, co poprzedni.

Podwójny

W BSON domyślny zamiennik Number JSON'a to Double typ danych. Double typ danych służy do przechowywania wartości zmiennoprzecinkowych i może być reprezentowany w MongoDB w następujący sposób:

        Type         | Number |   Alias  |  ------------------ | ------ | -------- |       Double        |    1   | "double" |
 

Liczby zmiennoprzecinkowe to kolejny sposób wyrażania liczb dziesiętnych, ale bez dokładnej, spójnej precyzji.

Liczby zmiennoprzecinkowe mogą wydajnie pracować z dużą liczbą miejsc dziesiętnych, ale nie zawsze dokładnie. Poniżej znajduje się przykład wprowadzania dokumentu za pomocą Double wpisz do swojej kolekcji:

db.mytestcoll.insertOne({testScore: 89.6}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d13")}
 

Mogą wystąpić niewielkie różnice między danymi wejściowymi i wyjściowymi podczas obliczania z użyciem podwojeń, które mogą potencjalnie prowadzić do nieoczekiwanego zachowania. Podczas wykonywania operacji, które wymagają dokładnych wartości, MongoDB ma bardziej precyzyjny typ.

Decimal128

Jeśli pracujesz z bardzo dużymi liczbami z dużą ilością zakresu zmiennoprzecinkowego, wtedy Decimal128 Najlepszym rozwiązaniem będzie typ danych BSON. Będzie to najbardziej przydatny typ dla wartości, które wymagają dużej precyzji, jak w przypadkach użycia obejmujących dokładne operacje pieniężne. Decimal128 typ jest reprezentowany jako:

        Type         | Number |   Alias   |  ------------------ | ------ | --------- |      Decimal128     |   19   | "decimal" |
 

Typ BSON, Decimal128 , zapewnia 128 bitów reprezentacji dziesiętnej do przechowywania liczb, w których ważne jest dokładne zaokrąglanie liczb dziesiętnych. Decimal128 obsługuje 34 cyfry dziesiętne precyzji lub sinificand z zakresu od -6143 do +6144. Pozwala to na dużą precyzję.

Wstawianie wartości za pomocą Decimal128 typ danych wymaga użycia NumberDecimal() konstruktor z Twoim numerem jako String aby uniemożliwić MongoDB używanie domyślnego typu liczbowego, Double .

Tutaj pokazujemy to:

db.mytestcoll.insertOne({price : NumberDecimal("5.099")}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d12")}
 

Podczas zapytania o kolekcję otrzymasz następujący wynik:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d12"),         price: "5.099" }
 

Wartość liczbowa zachowuje swoją precyzję pozwalającą na dokładne operacje. Aby zademonstrować Decimal128 typ kontra Double , możemy wykonać następujące ćwiczenie.

Jak można stracić precyzję na podstawie typu danych

Powiedzmy, że chcemy wstawić liczbę z wieloma wartościami dziesiętnymi jako Double do MongoDB z następującymi danymi:

db.mytestcoll.insertOne({ price: 9999999.4999999999 }){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d24")}
 

Kiedy pytamy o te dane, otrzymujemy następujący wynik:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d24"),         price: 9999999.5}
 

Ta wartość jest zaokrąglana w górę do 9999999.5 , tracąc dokładną wartość, z jaką ją wprowadziliśmy. To sprawia, że ​​Double nie nadaje się do przechowywania liczb z wieloma miejscami po przecinku.

Następny przykład pokazuje, gdzie zostanie utracona precyzja podczas przekazywania Double niejawnie z Decimal128 zamiast String jak w poprzednim przykładzie.

Zaczynamy od wstawienia następującego Double ponownie, ale z NumberDecimal() aby to było Decimal128 typ:

db.mytestcoll.insertOne({ price: NumberDecimal( 9999999.4999999999 ) }){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d14")}
 

Uwaga :Podczas wstawiania w powłoce MongoDB wyświetlany jest następujący komunikat ostrzegawczy:

Warning: NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead
 

Ten komunikat ostrzegawczy wskazuje, że numer, który próbujesz przekazać, może utracić precyzję. Sugerują użycie String za pomocą NumberDecimal() aby nie stracić precyzji.

Jeśli zignorujemy ostrzeżenie i mimo to wstawimy dokument, utrata precyzji jest widoczna w wynikach zapytania z zaokrąglenia wartości w górę:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"),         price: Decimal128("9999999.50000000")}
 

Jeśli postępujemy zgodnie z zalecaną NumberDecimal() podejście za pomocą String zobaczymy następujące wyniki z zachowaną precyzją:

db.mytestcoll.insertOne({ price: NumberDecimal( "9999999.4999999999" ) } )
 

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"),         price: Decimal128("9999999.4999999999")}
 

W przypadku każdego przypadku użycia wymagającego dokładnych, dokładnych wartości ten zwrot może powodować problemy. Każda praca związana z operacjami pieniężnymi jest przykładem, w którym precyzja będzie niezwykle ważna, a posiadanie dokładnych wartości ma kluczowe znaczenie dla dokładnych obliczeń. Ta demonstracja podkreśla znaczenie wiedzy, który typ danych liczbowych będzie najlepiej pasował do Twoich danych.

Data

Date BSON typ danych to 64-bitowa liczba całkowita, która reprezentuje liczbę milisekund od epoki Uniksa (1 stycznia 1970). Ten typ danych przechowuje bieżącą datę lub godzinę i może zostać zwrócony jako obiekt daty lub jako ciąg. Date jest reprezentowana w MongoDB w następujący sposób:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |        Date         |    9   |     "date"   |
 

Uwaga :BSON Date typ jest podpisany. Wartości ujemne reprezentują daty sprzed 1970 r.

Istnieją trzy metody zwracania wartości dat.

1. Date() - zwraca ciąg

2. new Date() - zwraca obiekt daty za pomocą ISODate() opakowanie

3. ISODate() - zwraca również obiekt daty za pomocą ISODate() opakowanie

Poniżej przedstawiamy te opcje:

var date1 = Date()var date2 = new Date()var date3 = ISODate()db.mytestcoll.insertOne({firstDate: date1, secondDate: date2, thirdDate: date3}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d22")}
 

A po powrocie:

db.mytestcoll.find().pretty(){                "_id" : ObjectId("614b37296a124db40ae74d22"),                firstDate: 'Tue Sep 28 2021 11:28:52 GMT+0200 (Central European Summer Time)',                secondDate: ISODate("2021-09-28T09:29:01.924Z"),                thirdDate: ISODate("2021-09-28T09:29:12.151Z")}
 

sygnatura czasowa

Istnieje również Timestamp typ danych w MongoDB do reprezentowania czasu. Jednak Timestamp będzie najbardziej przydatny do użytku wewnętrznego, a nie powiązane z Date rodzaj. Sam typ to sekwencja znaków używana do opisania daty i godziny wystąpienia zdarzenia. Timestamp to wartość 64-bitowa, gdzie:

• najbardziej znaczące 32 bity to time_t wartość (sekundy od epoki Uniksa)
• najmniej znaczące 32 bity to rosnący ordinal dla operacji w ciągu danej sekundy

Jego reprezentacja w MongoDB będzie wyglądać następująco:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      Timestamp      |   17   |  "timestamp" |
 

Podczas wstawiania dokumentu zawierającego pola najwyższego poziomu z pustymi znacznikami czasu MongoDB zastąpi pustą wartość znacznika czasu bieżącą wartością znacznika czasu. Wyjątkiem jest sytuacja, gdy _id pole zawiera pustą sygnaturę czasową. Wartość sygnatury czasowej będzie zawsze wstawiana bez zmian, a nie zastępowana.

Wstawianie nowego Timestamp wartość w MongoDB użyje new Timestamp() funkcjonować i wyglądać mniej więcej tak:

db.mytestcoll.insertOne( {ts: new Timestamp() });{        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d23")}
 

Podczas zapytania o kolekcję zwrócisz wynik podobny do:

db.mytestcoll.find().pretty(){        "_id" : ObjectId("614b37296a124db40ae74d24"),         "ts" : Timestamp( { t: 1412180887, i: 1 })}
 

Obiekt

Object typ danych w MongoDB służy do przechowywania osadzonych dokumentów. Dokument osadzony to seria dokumentów zagnieżdżonych w key: value format pary. Demonstrujemy Object wpisz poniżej:

var classGrades = {"Physics": 88, "German": 92, "LitTheoery": 79}db.mytestcoll.insertOne({student_name: "John Smith", report_card: classGrades}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d18")}
 

Następnie możemy wyświetlić nasz nowy dokument:

db.mytestcoll.find().pretty(){    _id: ObjectId("614b37296a124db40ae74d18"),    student_name: 'John Smith',    report_card: {Physics: 88, German: 92, LitTheoery: 79}}
 

Object typ danych optymalizuje pod kątem przechowywania danych, do których najlepiej uzyskuje się dostęp razem. Zapewnia pewne korzyści związane z przechowywaniem, szybkością i trwałością w przeciwieństwie do przechowywania każdego znaku klasy osobno, z powyższego przykładu.

Dane binarne

Binary Data lub BinData , typ danych robi dokładnie to, co sugeruje jego nazwa, i przechowuje dane binarne dla wartości pola. BinData najlepiej sprawdza się podczas przechowywania i wyszukiwania danych, ze względu na jego wydajność w reprezentowaniu tablic bitowych. Ten typ danych może być reprezentowany w następujący sposób:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      Binary data    |    5   |   "binData"  |
 

Oto przykład dodawania Binary data do dokumentu w kolekcji:

var data = BinData(1, "111010110111100110100010101")db.mytestcoll.insertOne({binaryData: data}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d20")}
 

Aby następnie zobaczyć wynikowy dokument:

db.mytestcoll.find().pretty(){        "_id" : ObjectId("614b37296a124db40ae74d20"),        "binaryData" : BinData(1, "111010110111100110100010101")}
 

ObjectId

ObjectId typ jest specyficzny dla MongoDB i przechowuje unikalny identyfikator dokumentu. MongoDB udostępnia _id pole dla każdego dokumentu. ObjectId ma rozmiar 12 bajtów i może być reprezentowany w następujący sposób:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      ObjectId       |    7   |   "objectId" |
 

ObjectId składa się z trzech części, które tworzą jego 12-bajtowy skład:

• 4-bajtowa wartość sygnatury czasowej , reprezentujący tworzenie ObjectId, mierzony w sekundach od epoki Uniksa
• 5-bajtowa wartość losowa
• 3-bajtowy licznik przyrostowy zainicjowany do wartości losowej

W MongoDB każdy dokument w kolekcji wymaga unikalnego _id działać jako klucz podstawowy. Jeśli _id pole jest puste dla wstawionego dokumentu, MongoDB automatycznie wygeneruje ObjectId dla tego pola.

Istnieje kilka korzyści z używania identyfikatorów ObjectId dla _id :

• po mongosh (powłoka MongoDB), czas utworzenia ObjectId jest dostępny za pomocą ObjectId.getTimestamp() metoda.
• sortowanie według _id pole, które przechowuje ObjectId typy danych są bliskim odpowiednikiem sortowania według czasu utworzenia.

Do tej pory widzieliśmy identyfikatory ObjectId w przykładach i będą one wyglądać podobnie do tego:

db.mytestcoll.find().pretty(){         _id: ObjectId("614b37296a124db40ae74d19")}
 

Uwaga :Wartości ObjectId powinny z czasem rosnąć, jednak niekoniecznie są monotoniczne. Dzieje się tak, ponieważ:

• Zawierają tylko jedną sekundę rozdzielczości czasowej, więc wartości utworzone w tej samej sekundzie nie mają gwarantowanej kolejności
• wartości są generowane przez klientów, którzy mogą mieć różne zegary systemowe

Boolean

MongoDB ma natywny Boolean typ danych do przechowywania wartości true i false w kolekcji. Boolean w MongoDB może być reprezentowana w następujący sposób:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |       Boolean       |    8   |     "bool"   |
 

Wstawianie dokumentu z Boolean typ danych będzie wyglądał mniej więcej tak:

db.mytestcoll.insertOne({isCorrect: true, isIncorrect: false}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d21")}
 

Następnie podczas wyszukiwania dokumentu wynik pojawi się jako:

db.mytestcoll.find().pretty(){    "_id" : ObjectId("614b37296a124db40ae74d21")    "isCorrect" : true,    "isIncorrect" : false}
 

Wyrażenie regularne

Regular Expression typ danych w MongoDB pozwala na przechowywanie wyrażeń regularnych jako wartości pola. MongoDB używa PCRE (Perl Compatible Regular Expression) jako języka wyrażeń regularnych.

Można to przedstawić w następujący sposób:

        Type         | Number |  Alias  |  ------------------ | ------ | ------- |  Regular Expression |   11   | "regex" |
 

BSON pozwala uniknąć typowego kroku „konwertowania z ciągu”, który jest często spotykany podczas pracy z wyrażeniami regularnymi i bazami danych. Ten typ będzie najbardziej przydatny podczas pisania obiektów bazy danych, które wymagają wzorców walidacji lub pasujących wyzwalaczy.

Na przykład możesz wstawić Regular Expression typ danych w ten sposób:

db.mytestcoll.insertOne({exampleregex: /tt/}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d16")}db.mytestcoll.insertOne({exampleregext:/t+/}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d17")}
 

Ta sekwencja oświadczeń doda te dokumenty do Twojej kolekcji. Następnie możesz przeszukać swoją kolekcję, aby znaleźć wstawione dokumenty:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d16"), exampleregex: /tt/,        _id: ObjectId("614b37296a124db40ae74d17"), exampleregex: /t+/ }
 

Wzorce wyrażeń regularnych są przechowywane jako wyrażenia regularne, a nie jako ciągi. Pozwala to na zapytanie o konkretny ciąg i uzyskanie zwróconych dokumentów, które mają wyrażenie regularne pasujące do żądanego ciągu.

JavaScript (bez zakresu)

Podobnie jak wcześniej wspomniane Regular Expression typu danych, BSON umożliwia MongoDB przechowywanie funkcji JavaScript bez zakresu jako własnego typu. JavaScript typ można rozpoznać w następujący sposób:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      JavaScript     |   13   | "javascript" |
 

Dodawanie dokumentu do swojej kolekcji za pomocą JavaScript typ danych będzie wyglądał mniej więcej tak:

db.mytestcoll.insertOne({jsCode: "function(){var x; x=1}"}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d122")}
 

Ta funkcja umożliwia przechowywanie funkcji JavaScript wewnątrz kolekcji MongoDB, jeśli jest to potrzebne w konkretnym przypadku użycia.

Uwaga :z MongoDB w wersji 4.4 i nowszej, alternatywnym typem JavaScript, JavaScript with Scope typ danych został wycofany

Wniosek

W tym artykule omówiliśmy większość typowych typów danych, które są przydatne podczas pracy z bazami danych MongoDB. Istnieją dodatkowe typy, które nie zostały wyraźnie omówione w tym przewodniku, które mogą być pomocne w zależności od przypadku użycia. Rozpoczęcie od znajomości tych typów obejmuje większość przypadków użycia. To mocna podstawa do rozpoczęcia modelowania bazy danych MongoDB.

Ważne jest, aby wiedzieć, jakie typy danych są dostępne podczas korzystania z bazy danych, aby używać prawidłowych wartości i operować na danych z oczekiwanymi wynikami. Istnieje ryzyko, na które możesz się natknąć bez prawidłowego wpisania danych, jak pokazano w Double a Decimal128 ćwiczenie. Ważne jest, aby pomyśleć o tym przed zaangażowaniem się w dowolny typ.

Jeśli chcesz wypróbować Prisma z bazą danych MongoDB, możesz zapoznać się z dokumentacją złącza danych.