Pengantar
Saat menggunakan MongoDB, Anda memiliki kemampuan untuk fleksibel dengan struktur data Anda. Anda tidak terkunci dalam mempertahankan skema tertentu yang harus sesuai dengan semua dokumen Anda. Untuk bidang tertentu dalam dokumen, Anda dapat menggunakan salah satu tipe data . yang tersedia didukung oleh MongoDB. Terlepas dari cara kerja default ini, Anda dapat menerapkan Skema JSON di MongoDB untuk menambahkan validasi pada koleksi Anda jika diinginkan. Kami tidak akan membahas detail desain skema dalam panduan ini, tetapi ini dapat berdampak pada pengetikan data jika diterapkan.
Tipe data menentukan pola umum untuk data yang mereka terima dan simpan. Sangat penting untuk memahami kapan harus memilih tipe data tertentu daripada yang lain saat merencanakan database Anda. Jenis yang dipilih akan menentukan bagaimana Anda dapat mengoperasikan data Anda dan bagaimana data tersebut disimpan.
JSON dan BSON
Sebelum masuk ke detail tipe data tertentu, penting untuk memiliki pemahaman tentang bagaimana MongoDB menyimpan data. MongoDB dan banyak database NoSQL berbasis dokumen lainnya menggunakan JSON (JavaScript Object Notation) untuk mewakili catatan data sebagai dokumen.
Ada banyak keuntungan menggunakan JSON untuk menyimpan data. Beberapa di antaranya adalah:
- kemudahan membaca, belajar, dan keakrabannya di kalangan pengembang
- fleksibilitas dalam format, baik yang jarang, hierarkis, atau sangat bersarang
- mendeskripsikan diri sendiri, yang memungkinkan aplikasi untuk dengan mudah beroperasi dengan data JSON
- memungkinkan fokus pada tipe dasar dalam jumlah minimal
JSON mendukung semua tipe data dasar seperti string, angka, boolean, dll. MongoDB sebenarnya menyimpan catatan data sebagai dokumen Binary-encoded JSON (BSON). Seperti JSON, BSON mendukung penyematan dokumen dan larik di dalam dokumen dan larik lain. BSON memungkinkan untuk tipe data tambahan yang tidak tersedia untuk JSON.
Apa saja tipe data di MongoDB?
Sebelum masuk ke detail, mari kita lihat secara luas tipe data apa yang didukung di MongoDB.
MongoDB mendukung berbagai tipe data yang cocok untuk berbagai jenis data baik yang sederhana maupun yang kompleks. Ini termasuk:
Teks
String
Numerik
32-Bit Integer64-Bit IntegerDoubleDecimal128
Tanggal/Waktu
DateTimestamp
Lainnya
ObjectArrayBinary DataObjectIdBooleanNullRegular ExpressionJavaScriptMin KeyMax Key
Di MongoDB, setiap tipe BSON memiliki pengidentifikasi integer dan string. Kami akan membahas yang paling umum dari ini secara lebih mendalam di seluruh panduan ini.
Jenis string
Tipe string adalah tipe data MongoDB yang paling umum digunakan. Nilai apa pun yang ditulis di dalam tanda kutip ganda "" di JSON adalah nilai string. Nilai apa pun yang ingin Anda simpan sebagai teks sebaiknya diketik sebagai String . String BSON adalah UTF-8 dan direpresentasikan dalam MongoDB sebagai:
Type | Number | Alias | ------------------ | ------ | -------- | String | 2 | "string" |
Umumnya, driver untuk bahasa pemrograman akan mengonversi dari format string bahasa ke UTF-8 saat membuat serial dan deserializing BSON. Ini menjadikan BSON metode yang menarik untuk menyimpan karakter internasional dengan mudah misalnya.
Menyisipkan dokumen dengan String tipe data akan terlihat seperti ini:
db.mytestcoll.insertOne({first_name: "Alex"}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d15")}
Menanyakan koleksi akan mengembalikan yang berikut:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex"}
Menggunakan $type operator
Sebelum beralih ke tipe data berikutnya, penting untuk mengetahui bagaimana Anda bisa mengetik memeriksa nilai sebelum membuat penyisipan apa pun. Kami akan menggunakan contoh sebelumnya untuk mendemonstrasikan menggunakan $type operator di MongoDB.
Katakanlah sudah lama sejak kami bekerja dengan mytestcoll koleksi dari sebelumnya. Kami ingin memasukkan beberapa dokumen tambahan ke dalam koleksi dengan first_name bidang. Untuk memeriksa apakah kami menggunakan String sebagai tipe data yang disimpan sebagai nilai first_name awalnya, kita dapat menjalankan yang berikut ini menggunakan nilai alias atau angka dari tipe data:
db.mytestcoll.find( { "first_name": { $type: "string" } } )
Atau
db.mytestcoll.find( { "first_name": { $type: 2 } } )
Kedua kueri mengembalikan output dari semua dokumen yang memiliki String nilai yang disimpan untuk first_name dari penyisipan bagian sebelumnya:
[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
Jika Anda menanyakan jenis yang tidak disimpan di first_name bidang dokumen apa pun, Anda tidak akan mendapatkan hasil. Ini menunjukkan bahwa ini adalah tipe data lain yang disimpan di first_name .
Anda juga dapat melakukan kueri untuk beberapa tipe data sekaligus dengan $type operator seperti berikut:
db.mytestcoll.find( { "first_name": { $type: ["string", "null"] } } )
Karena kami tidak memasukkan Null ketik nilai ke dalam koleksi kami, hasilnya akan sama:
[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
Anda dapat menggunakan metode yang sama dengan semua tipe berikut yang akan kita bahas.
Angka dan nilai numerik
MongoDB mencakup berbagai tipe data numerik yang cocok untuk skenario yang berbeda. Memutuskan jenis mana yang akan digunakan bergantung pada sifat nilai yang Anda rencanakan untuk disimpan dan kasus penggunaan Anda untuk data. JSON menyebut apa pun dengan angka sebagai Nomor . Itu memaksa sistem untuk mencari cara mengubahnya menjadi tipe data asli terdekat. Kita akan mulai dengan menjelajahi bilangan bulat dan cara kerjanya di MongoDB.
Integer
Integer tipe data digunakan untuk menyimpan angka sebagai bilangan bulat tanpa pecahan atau desimal. Bilangan bulat dapat berupa nilai positif atau negatif. Ada dua jenis di MongoDB, 32-Bit Integer dan 64-Bit Integer . Mereka dapat direpresentasikan dalam dua cara yang digambarkan dalam tabel di bawah ini, number dan alias :
Integer type | number | alias | ------------ | ----- | ------------ | `32-bit integer`| 16 | "int" | `64-bit integer`| 18 | "long" |
Rentang nilai yang dapat ditampung untuk setiap jenis adalah sebagai berikut:
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
Jenis di atas dibatasi oleh rentang validnya. Nilai apa pun di luar rentang akan menghasilkan kesalahan. Menyisipkan Integer ketikkan ke MongoDB akan terlihat seperti di bawah ini:
db.mytestcoll.insertOne({age: 26}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d14")}
Dan menemukan hasilnya akan mengembalikan yang berikut:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d14"), age: 26}
Seperti yang disarankan oleh namanya, 32-Bit Integer memiliki presisi bilangan bulat 32 bit yang berguna untuk nilai bilangan bulat yang lebih kecil yang tidak ingin Anda simpan sebagai urutan digit. Saat bertambah dalam ukuran angka, Anda dapat mencapai 64-Bit Integer yang memiliki presisi bilangan bulat 64 bit dan cocok dengan kasus penggunaan yang sama seperti sebelumnya.
Ganda
Di BSON, pengganti default untuk Nomor J JSON adalah Double tipe data. Double tipe data digunakan untuk menyimpan nilai floating-point dan dapat direpresentasikan dalam MongoDB seperti:
Type | Number | Alias | ------------------ | ------ | -------- | Double | 1 | "double" |
Angka floating point adalah cara lain untuk mengekspresikan angka desimal, tetapi tanpa presisi yang tepat dan konsisten.
Angka floating point dapat bekerja dengan sejumlah besar desimal secara efisien tetapi tidak selalu tepat. Berikut ini adalah contoh memasukkan dokumen dengan kode Double ketik ke dalam koleksi Anda:
db.mytestcoll.insertOne({testScore: 89.6}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d13")}
Mungkin ada sedikit perbedaan antara input dan output saat menghitung dengan ganda yang berpotensi menyebabkan perilaku yang tidak terduga. Saat melakukan operasi yang membutuhkan nilai eksak, MongoDB memiliki tipe yang lebih presisi.
Desimal128
Jika Anda bekerja dengan angka yang sangat besar dengan banyak rentang floating point, maka Decimal128 Tipe data BSON akan menjadi pilihan terbaik. Ini akan menjadi tipe yang paling berguna untuk nilai yang membutuhkan banyak presisi seperti dalam kasus penggunaan yang melibatkan operasi moneter yang tepat. Decimal128 jenis direpresentasikan sebagai:
Type | Number | Alias | ------------------ | ------ | --------- | Decimal128 | 19 | "decimal" |
Jenis BSON, Decimal128 , menyediakan 128 bit representasi desimal untuk menyimpan angka di mana pembulatan desimal sangat penting. Decimal128 mendukung presisi 34 digit desimal, atau sinificand dengan kisaran -6143 hingga +6144. Ini memungkinkan presisi yang tinggi.
Memasukkan nilai menggunakan Decimal128 tipe data memerlukan penggunaan NumberDecimal() konstruktor dengan nomor Anda sebagai String untuk mencegah MongoDB menggunakan tipe numerik default, Double .
Di sini, kami menunjukkan ini:
db.mytestcoll.insertOne({price : NumberDecimal("5.099")}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d12")}
Saat menanyakan koleksi, Anda kemudian mendapatkan pengembalian berikut:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d12"), price: "5.099" }
Nilai numerik mempertahankan presisi yang memungkinkan untuk operasi yang tepat. Untuk mendemonstrasikan Decimal128 ketik versus Double , kita dapat mengikuti latihan berikut.
Bagaimana presisi bisa hilang berdasarkan tipe data
Katakanlah kita ingin memasukkan angka dengan banyak nilai desimal sebagai Double ke MongoDB dengan yang berikut:
db.mytestcoll.insertOne({ price: 9999999.4999999999 }){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d24")}
Saat kami meminta data ini, kami mendapatkan hasil berikut:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d24"), price: 9999999.5}
Nilai ini dibulatkan menjadi 9999999.5 , kehilangan nilai persisnya yang kita masukkan. Ini membuat Double tidak cocok untuk penyimpanan angka dengan banyak desimal.
Contoh berikutnya menunjukkan di mana presisi akan hilang saat melewati Double secara implisit dengan Decimal128 bukannya String seperti pada contoh sebelumnya.
Kita mulai dengan menyisipkan Double berikut ini lagi tetapi dengan NumberDecimal() untuk membuatnya menjadi Decimal128 ketik:
db.mytestcoll.insertOne({ price: NumberDecimal( 9999999.4999999999 ) }){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d14")}
Catatan :Saat melakukan penyisipan ini di shell MongoDB, pesan peringatan berikut akan ditampilkan:
Warning: NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead
Pesan peringatan ini menunjukkan bahwa nomor yang Anda coba berikan dapat kehilangan presisi. Mereka menyarankan untuk menggunakan String menggunakan NumberDecimal() sehingga Anda tidak kehilangan presisi.
Jika kita mengabaikan peringatan dan tetap memasukkan dokumen, hilangnya presisi terlihat pada hasil kueri dari pembulatan nilai:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d14"), price: Decimal128("9999999.50000000")}
Jika kita mengikuti NumberDecimal() yang direkomendasikan pendekatan menggunakan String kita akan melihat hasil berikut dengan presisi yang terjaga:
db.mytestcoll.insertOne({ price: NumberDecimal( "9999999.4999999999" ) } )
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d14"), price: Decimal128("9999999.4999999999")}
Untuk kasus penggunaan apa pun yang membutuhkan nilai yang tepat dan pasti, pengembalian ini dapat menyebabkan masalah. Setiap pekerjaan yang melibatkan operasi moneter adalah contoh di mana presisi akan menjadi sangat penting dan memiliki nilai yang tepat sangat penting untuk perhitungan yang akurat. Demonstrasi ini menyoroti pentingnya mengetahui tipe data numerik mana yang paling cocok untuk data Anda.
Tanggal
Date BSON tipe data adalah bilangan bulat 64-bit yang mewakili jumlah milidetik sejak zaman Unix (1 Januari 1970). Tipe data ini menyimpan tanggal atau waktu saat ini dan dapat dikembalikan sebagai objek tanggal atau sebagai string. Date direpresentasikan dalam MongoDB sebagai berikut:
Type | Number | Alias | ------------------ | ------ | ------------ | Date | 9 | "date" |
Catatan :BSON Date jenis ditandatangani. Nilai negatif menunjukkan tanggal sebelum tahun 1970.
Ada tiga metode untuk mengembalikan nilai tanggal.
-
Date()- mengembalikan string -
new Date()- mengembalikan objek tanggal menggunakanISODate()pembungkus -
ISODate()- juga mengembalikan objek tanggal menggunakanISODate()pembungkus
Kami mendemonstrasikan opsi ini di bawah:
var date1 = Date()var date2 = new Date()var date3 = ISODate()db.mytestcoll.insertOne({firstDate: date1, secondDate: date2, thirdDate: date3}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d22")}
Dan saat kembali:
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")}
Stempel waktu
Ada juga Timestamp tipe data dalam MongoDB untuk mewakili waktu. Namun, Timestamp akan paling berguna untuk penggunaan internal dan tidak terkait dengan Date Tipe. Tipe itu sendiri adalah urutan karakter yang digunakan untuk menggambarkan tanggal dan waktu ketika suatu peristiwa terjadi. Timestamp adalah nilai 64 bit di mana:
- 32 bit yang paling signifikan adalah
time_tnilai (detik sejak zaman Unix) - 32 bit yang paling tidak signifikan adalah
ordinal. yang bertambah untuk operasi dalam satu detik tertentu
Representasinya di MongoDB akan terlihat sebagai berikut:
Type | Number | Alias | ------------------ | ------ | ------------ | Timestamp | 17 | "timestamp" |
Saat memasukkan dokumen yang berisi bidang tingkat atas dengan stempel waktu kosong, MongoDB akan mengganti nilai stempel waktu kosong dengan nilai stempel waktu saat ini. Pengecualian untuk ini adalah jika _id bidang berisi stempel waktu kosong. Nilai stempel waktu akan selalu dimasukkan apa adanya dan tidak diganti.
Memasukkan Timestamp baru nilai di MongoDB akan menggunakan new Timestamp() fungsi dan terlihat seperti ini:
db.mytestcoll.insertOne( {ts: new Timestamp() });{ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d23")}
Saat menanyakan koleksi, Anda akan menampilkan hasil yang menyerupai:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d24"), "ts" : Timestamp( { t: 1412180887, i: 1 })}
Objek
Object tipe data di MongoDB digunakan untuk menyimpan dokumen yang disematkan. Dokumen yang disematkan adalah serangkaian dokumen bersarang di key: value format pasangan. Kami mendemonstrasikan Object ketik di bawah ini:
var classGrades = {"Physics": 88, "German": 92, "LitTheoery": 79}db.mytestcoll.insertOne({student_name: "John Smith", report_card: classGrades}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d18")}
Kami kemudian dapat melihat dokumen baru kami:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d18"), student_name: 'John Smith', report_card: {Physics: 88, German: 92, LitTheoery: 79}}
Object tipe data mengoptimalkan untuk menyimpan data yang paling baik diakses bersama-sama. Ini memberikan beberapa efisiensi seputar penyimpanan, kecepatan, dan daya tahan dibandingkan dengan menyimpan setiap tanda kelas, dari contoh di atas, secara terpisah.
Data Biner
Binary data , atau BinData , tipe data melakukan persis seperti namanya dan menyimpan data biner untuk nilai bidang. BinData paling baik digunakan saat Anda menyimpan dan mencari data, karena efisiensinya dalam merepresentasikan bit array. Tipe data ini dapat direpresentasikan dengan cara berikut:
Type | Number | Alias | ------------------ | ------ | ------------ | Binary data | 5 | "binData" |
Berikut adalah contoh menambahkan beberapa Binary data ke dalam dokumen dalam koleksi:
var data = BinData(1, "111010110111100110100010101")db.mytestcoll.insertOne({binaryData: data}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d20")}
Untuk kemudian melihat dokumen yang dihasilkan:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d20"), "binaryData" : BinData(1, "111010110111100110100010101")}
ObjectId
ObjectId type khusus untuk MongoDB dan menyimpan ID unik dokumen. MongoDB menyediakan _id bidang untuk setiap dokumen. ObjectId berukuran 12 byte dan dapat direpresentasikan sebagai berikut:
Type | Number | Alias | ------------------ | ------ | ------------ | ObjectId | 7 | "objectId" |
ObjectId terdiri dari tiga bagian yang membentuk susunan 12-byte:
- 4 byte nilai stempel waktu , mewakili pembuatan ObjectId, diukur dalam hitungan detik sejak zaman Unix
- 5 byte nilai acak
- penghitung peningkatan 3 byte diinisialisasi ke nilai acak
Di MongoDB, setiap dokumen dalam koleksi memerlukan _id yang unik untuk bertindak sebagai kunci utama. Jika _id kolom dibiarkan kosong untuk dokumen yang disisipkan, MongoDB akan secara otomatis menghasilkan ObjectId untuk kolom tersebut.
Ada beberapa manfaat menggunakan ObjectIds untuk _id :
- dalam
mongosh(MongoDB shell), waktu pembuatanObjectIddapat diakses menggunakanObjectId.getTimestamp()metode. - mengurutkan pada
_idbidang yang menyimpanObjectIdtipe data hampir sama dengan pengurutan berdasarkan waktu pembuatan.
Sejauh ini kita telah melihat ObjectIds di seluruh contoh, dan mereka akan terlihat seperti ini:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d19")}
Catatan :Nilai ObjectId harus meningkat seiring waktu, namun tidak selalu monoton. Ini karena mereka:
- Hanya berisi satu detik resolusi temporal, jadi nilai yang dibuat dalam detik yang sama tidak memiliki jaminan pemesanan
- nilai dihasilkan oleh klien, yang mungkin memiliki jam sistem yang berbeda
Boolean
MongoDB memiliki Boolean asli tipe data untuk menyimpan nilai benar dan salah dalam koleksi. Boolean di MongoDB dapat direpresentasikan sebagai berikut:
Type | Number | Alias | ------------------ | ------ | ------------ | Boolean | 8 | "bool" |
Menyisipkan dokumen dengan Boolean tipe data akan terlihat seperti berikut:
db.mytestcoll.insertOne({isCorrect: true, isIncorrect: false}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d21")}
Kemudian ketika mencari dokumen maka akan muncul hasil sebagai berikut:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d21") "isCorrect" : true, "isIncorrect" : false}
Ekspresi Reguler
Regular Expression tipe data di MongoDB memungkinkan penyimpanan ekspresi reguler sebagai nilai bidang. MongoDB menggunakan PCRE (Perl Compatible Regular Expression) sebagai bahasa ekspresi regulernya.
Ini dapat direpresentasikan dengan cara berikut:
Type | Number | Alias | ------------------ | ------ | ------- | Regular Expression | 11 | "regex" |
BSON memungkinkan Anda untuk menghindari langkah "konversi dari string" yang umum dialami saat bekerja dengan ekspresi reguler dan database. Tipe ini akan sangat berguna saat Anda menulis objek database yang memerlukan pola validasi atau pemicu yang cocok.
Misalnya, Anda dapat memasukkan Regular Expression tipe data seperti ini:
db.mytestcoll.insertOne({exampleregex: /tt/}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d16")}db.mytestcoll.insertOne({exampleregext:/t+/}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d17")}
Urutan pernyataan ini akan menambahkan dokumen-dokumen ini ke koleksi Anda. Anda kemudian dapat menanyakan koleksi Anda untuk menemukan dokumen yang disisipkan:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d16"), exampleregex: /tt/, _id: ObjectId("614b37296a124db40ae74d17"), exampleregex: /t+/ }
Pola ekspresi reguler disimpan sebagai regex dan bukan sebagai string. Ini memungkinkan Anda untuk membuat kueri untuk string tertentu dan mendapatkan dokumen yang dikembalikan yang memiliki ekspresi reguler yang cocok dengan string yang diinginkan.
JavaScript (tanpa cakupan)
Sama seperti Regular Expression yang disebutkan sebelumnya tipe data, BSON memungkinkan MongoDB untuk menyimpan fungsi JavaScript tanpa ruang lingkup sebagai tipenya sendiri. JavaScript jenis dapat dikenali sebagai berikut:
Type | Number | Alias | ------------------ | ------ | ------------ | JavaScript | 13 | "javascript" |
Menambahkan dokumen ke koleksi Anda dengan JavaScript tipe data akan terlihat seperti ini:
db.mytestcoll.insertOne({jsCode: "function(){var x; x=1}"}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d122")}
Fungsionalitas ini memungkinkan Anda untuk menyimpan fungsi JavaScript di dalam koleksi MongoDB Anda jika diperlukan untuk kasus penggunaan tertentu.
Catatan :Dengan MongoDB versi 4.4 dan di atasnya, jenis JavaScript alternatif, JavaScript with Scope tipe data, tidak digunakan lagi
Kesimpulan
Dalam artikel ini, kami telah membahas sebagian besar tipe data umum yang berguna saat bekerja dengan database MongoDB. Ada jenis tambahan yang tidak tercakup secara eksplisit dalam panduan ini yang mungkin berguna tergantung pada kasus penggunaan. Memulai dengan mengetahui jenis ini mencakup sebagian besar kasus penggunaan. Ini adalah dasar yang kuat untuk mulai memodelkan database MongoDB Anda.
Penting untuk mengetahui tipe data apa yang tersedia untuk Anda saat menggunakan database sehingga Anda menggunakan nilai yang valid dan mengoperasikan data dengan hasil yang diharapkan. Ada risiko yang dapat Anda hadapi tanpa mengetik data Anda dengan benar seperti yang ditunjukkan dalam Double versus Decimal128 latihan. Penting untuk memikirkan hal ini sebelum berkomitmen pada jenis apa pun.
Jika Anda tertarik untuk memeriksa Prisma dengan database MongoDB, Anda dapat melihat dokumentasi konektor data.
