Cara membuat skema di mongodb

Jika Anda belum melakukannya, harap luangkan waktu sejenak untuk membaca quickstart untuk mendapatkan gambaran tentang cara kerja Mongoose. Jika Anda bermigrasi dari 5. x ke 6. x harap luangkan waktu sejenak untuk membaca panduan migrasi

Segala sesuatu di Mongoose dimulai dengan Skema. Setiap skema memetakan ke koleksi MongoDB dan menentukan bentuk dokumen di dalam koleksi itu

Jika Anda ingin menambahkan kunci tambahan nanti, gunakan metode ini

Setiap kunci dalam kode kami

const schema = new Schema({..}, { bufferCommands: false });
_0 mendefinisikan properti dalam dokumen kami yang akan dilemparkan ke yang terkait. Misalnya, kami telah menetapkan properti
const schema = new Schema({..}, { bufferCommands: false });
_1 yang akan dilemparkan ke Jenis Skema dan properti
const schema = new Schema({..}, { bufferCommands: false });
2 yang akan dilemparkan ke Jenis Skema
const schema = new Schema({..}, { bufferCommands: false });
3

Perhatikan di atas bahwa jika properti hanya memerlukan tipe, properti dapat ditentukan menggunakan notasi steno (kontraskan properti

const schema = new Schema({..}, { bufferCommands: false });
1 di atas dengan properti
const schema = new Schema({..}, { bufferCommands: false });
2)

Kunci juga dapat diberikan objek bersarang yang berisi definisi kunci/jenis lebih lanjut seperti properti

const schema = new Schema({..}, { bufferCommands: false });
6 di atas. Ini akan terjadi setiap kali nilai kunci adalah POJO yang tidak memiliki properti
const schema = new Schema({..}, { bufferCommands: false });
7

Dalam kasus ini, Mongoose hanya membuat jalur skema sebenarnya untuk daun di pohon. (seperti

const schema = new Schema({..}, { bufferCommands: false });
8 dan
const schema = new Schema({..}, { bufferCommands: false });
9 di atas), dan cabang tidak memiliki jalur sebenarnya. Efek sampingnya adalah
const schema = new Schema({..}, { bufferCommands: false });
6 di atas tidak dapat memiliki validasinya sendiri. Jika validasi diperlukan di atas pohon, jalur perlu dibuat di atas pohon - lihat bagian Subdokumen untuk informasi lebih lanjut tentang cara melakukan ini. Baca juga subbagian Campuran dari panduan SchemaTypes untuk beberapa gotcha

Jenis Skema yang diizinkan adalah

Baca lebih lanjut tentang SchemaTypes di sini

Skema tidak hanya menentukan struktur dokumen Anda dan casting properti, mereka juga menentukan document , , , dan document lifecycle hooks yang disebut middleware

Untuk menggunakan definisi skema kita, kita perlu mengonversi

const schema = new Schema({..}, { bufferCommands: false });
0 kita menjadi Model yang dapat kita kerjakan. Untuk melakukannya, kami menyebarkannya ke
new Schema({..}, { capped: 1024 });
2

Secara default, Mongoose menambahkan properti

new Schema({..}, { capped: 1024 });
3 ke skema Anda

Saat Anda membuat dokumen baru dengan properti

new Schema({..}, { capped: 1024 });
3 yang ditambahkan secara otomatis, Mongoose membuat
new Schema({..}, { capped: 1024 });
3 tipe ObjectId baru ke dokumen Anda

Anda juga dapat menimpa default Mongoose

new Schema({..}, { capped: 1024 });
3 dengan
new Schema({..}, { capped: 1024 });
3 Anda sendiri. Hati-hati. Mongoose akan menolak untuk menyimpan dokumen yang tidak memiliki
new Schema({..}, { capped: 1024 });
3, jadi Anda bertanggung jawab untuk menyetel
new Schema({..}, { capped: 1024 });
3 jika Anda menentukan jalur
new Schema({..}, { capped: 1024 });
3 Anda sendiri

Contoh

new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
_1 adalah dokumen. Dokumen memiliki banyak metode instance bawaannya sendiri. Kami juga dapat menentukan metode contoh dokumen kustom kami sendiri

Sekarang semua instance

new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
_2 kami memiliki metode
new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
3 yang tersedia untuk mereka

  • Menimpa metode dokumen luwak default dapat menyebabkan hasil yang tidak terduga. Lihat untuk detail lebih lanjut
  • Contoh di atas menggunakan objek
    new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
    
    _4 secara langsung untuk menyimpan metode instance. Anda juga dapat menggunakan pembantu
    new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
    
    _5 seperti yang dijelaskan
  • Jangan mendeklarasikan metode menggunakan fungsi panah ES6 (
    new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
    
    6). Fungsi panah , jadi metode Anda tidak akan memiliki akses ke dokumen dan contoh di atas tidak akan berfungsi

Anda juga dapat menambahkan fungsi statis ke model Anda. Ada tiga cara yang setara untuk menambahkan statis

  • Tambahkan properti fungsi ke argumen kedua konstruktor skema (
    new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
    
    8)
  • Tambahkan properti fungsi ke
    new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
    
    _9
  • Panggil

Jangan mendeklarasikan statika menggunakan fungsi panah ES6 (

new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
6). Fungsi panah, jadi contoh di atas tidak akan berfungsi karena nilai
new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });
7

Anda juga dapat menambahkan fungsi pembantu kueri, yang seperti metode instan tetapi untuk kueri luwak. Metode pembantu kueri memungkinkan Anda memperluas API pembuat kueri rantai luwak

MongoDB mendukung indeks sekunder. Dengan luwak, kami mendefinisikan indeks ini dalam level

const dataSchema = new Schema({..}, { collection: 'data' });
4 atau
const dataSchema = new Schema({..}, { collection: 'data' });
5 kami. Menentukan indeks pada tingkat skema diperlukan saat membuat indeks majemuk

Lihat untuk opsi indeks lainnya

Saat aplikasi Anda dijalankan, Mongoose secara otomatis memanggil setiap indeks yang ditentukan dalam skema Anda. Mongoose akan memanggil

const dataSchema = new Schema({..}, { collection: 'data' });
_6 untuk setiap indeks secara berurutan, dan memancarkan peristiwa 'indeks' pada model saat semua panggilan
const dataSchema = new Schema({..}, { collection: 'data' });
6 berhasil atau saat terjadi kesalahan. Meskipun bagus untuk pengembangan, disarankan agar perilaku ini dinonaktifkan dalam produksi karena pembuatan indeks dapat menyebabkan a. Nonaktifkan perilaku dengan menyetel opsi
const dataSchema = new Schema({..}, { collection: 'data' });
_9 dari skema Anda ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0, atau secara global pada koneksi dengan menyetel opsi
const dataSchema = new Schema({..}, { collection: 'data' });
9 ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0

Mongoose akan mengeluarkan peristiwa

const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
3 pada model saat indeks selesai dibuat atau terjadi kesalahan

Lihat juga caranya

adalah properti dokumen yang bisa Anda dapatkan dan atur tetapi tidak bertahan di MongoDB. Getter berguna untuk memformat atau menggabungkan bidang, sedangkan setter berguna untuk mendekomposisi satu nilai menjadi beberapa nilai untuk penyimpanan

Misalkan Anda ingin mencetak nama lengkap orang tersebut. Anda bisa melakukannya sendiri

Tetapi menggabungkan nama depan dan belakang setiap saat bisa menjadi rumit. Dan bagaimana jika Anda ingin melakukan pemrosesan ekstra pada nama, seperti menghapus diakritik?

Sekarang, luwak akan memanggil fungsi pengambil Anda setiap kali Anda mengakses properti

const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
4

Jika Anda menggunakan

const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
6 atau
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
7 luwak tidak akan menyertakan virtual secara default. Ini termasuk hasil pemanggilan
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
_8 pada dokumen Mongoose, karena. Lewati
new Schema({ . }, { shardKey: { tag: 1, name: 1 }})
_1 ke salah satu atau

Anda juga dapat menambahkan penyetel khusus ke virtual Anda yang memungkinkan Anda menyetel nama depan dan nama belakang melalui

const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
4 virtual

Penyetel properti virtual diterapkan sebelum validasi lainnya. Jadi contoh di atas akan tetap berfungsi meskipun bidang nama

new Schema({ . }, { shardKey: { tag: 1, name: 1 }})
5 dan
new Schema({ . }, { shardKey: { tag: 1, name: 1 }})
6 diperlukan

Hanya properti non-virtual yang berfungsi sebagai bagian dari kueri dan untuk pemilihan bidang. Karena virtual tidak disimpan di MongoDB, Anda tidak dapat menanyakannya

Anda dapat mempelajari lebih lanjut tentang virtual di sini

Alias ​​​​adalah jenis virtual tertentu di mana pengambil dan penyetel secara mulus mendapatkan dan menyetel properti lain. Ini berguna untuk menghemat bandwidth jaringan, sehingga Anda dapat mengonversi nama properti pendek yang disimpan dalam database menjadi nama yang lebih panjang agar kode mudah dibaca

Anda juga dapat mendeklarasikan alias di jalur bersarang. Lebih mudah menggunakan skema dan subdokumen bersarang, tetapi Anda juga dapat mendeklarasikan alias jalur bersarang sebaris selama Anda menggunakan jalur bersarang lengkap

new Schema({ . }, { shardKey: { tag: 1, name: 1 }})
7 sebagai alias

Skema memiliki beberapa opsi yang dapat dikonfigurasi yang dapat diteruskan ke konstruktor atau ke metode

new Schema({ . }, { shardKey: { tag: 1, name: 1 }})
8

Opsi yang valid

Secara default, Mongoose membuat semua indeks yang ditentukan dalam skema model Anda dengan memanggil setelah Anda berhasil terhubung ke MongoDB. Membuat indeks secara otomatis sangat bagus untuk lingkungan pengembangan dan pengujian. Tetapi build indeks juga dapat membuat beban yang signifikan pada database produksi Anda. Jika Anda ingin mengelola indeks dengan hati-hati dalam produksi, Anda dapat menyetel

const dataSchema = new Schema({..}, { collection: 'data' });
9 ke false

const schema = new Schema({..}, { autoIndex: false });
const Clock = mongoose.model('Clock', schema);
Clock.ensureIndexes(callback);

Opsi

const dataSchema = new Schema({..}, { collection: 'data' });
_9 diatur ke
schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
3 secara default. Anda dapat mengubah default ini dengan pengaturan

Sebelum Mongoose membangun indeks, Mongoose memanggil

schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
5 untuk membuat koleksi dasar di MongoDB secara default. Memanggil
schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
6 menyetel susunan default koleksi berdasarkan dan menetapkan koleksi sebagai koleksi tertutup jika Anda menyetel

Anda dapat menonaktifkan perilaku ini dengan menyetel

schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
8 ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0 menggunakan. Seperti
const dataSchema = new Schema({..}, { collection: 'data' });
_9,
schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
8 berguna untuk lingkungan pengembangan dan pengujian, tetapi Anda mungkin ingin menonaktifkannya untuk produksi guna menghindari panggilan database yang tidak perlu

Sayangnya,

schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
6 tidak dapat mengubah koleksi yang ada. Misalnya, jika Anda menambahkan
async function markApproved(id) {
  const house = await House.findOne({ _id });
  if (house.photos.length < 2) {
    throw new Error('House must have at least two photos!');
  }
  
  house.status = 'APPROVED';
  await house.save();
}
4 ke skema Anda dan koleksi yang ada tidak dibatasi,
schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
6 tidak akan menimpa koleksi yang ada. Itu karena server MongoDB tidak mengizinkan mengubah opsi koleksi tanpa menghapus koleksi terlebih dahulu

Secara default, buffer mongoose memerintahkan saat koneksi terputus hingga driver berhasil menyambung kembali. Untuk menonaktifkan buffering, atur

async function markApproved(id) {
  const house = await House.findOne({ _id });
  if (house.photos.length < 2) {
    throw new Error('House must have at least two photos!');
  }
  
  house.status = 'APPROVED';
  await house.save();
}
6 ke false

const schema = new Schema({..}, { bufferCommands: false });

Opsi skema

async function markApproved(id) {
  const house = await House.findOne({ _id });
  if (house.photos.length < 2) {
    throw new Error('House must have at least two photos!');
  }
  
  house.status = 'APPROVED';
  await house.save();
}
6 menggantikan opsi global
async function markApproved(id) {
  const house = await House.findOne({ _id });
  if (house.photos.length < 2) {
    throw new Error('House must have at least two photos!');
  }
  
  house.status = 'APPROVED';
  await house.save();
}
6

Jika

async function markApproved(id) {
  const house = await House.findOne({ _id });
  if (house.photos.length < 2) {
    throw new Error('House must have at least two photos!');
  }
  
  house.status = 'APPROVED';
  await house.save();
}
_6 aktif, opsi ini menetapkan jumlah waktu maksimum buffering Mongoose akan menunggu sebelum melontarkan kesalahan. Jika tidak ditentukan, Mongoose akan menggunakan 10000 (10 detik)

Mongoose mendukung koleksi yang dibatasi oleh MongoDB. Untuk menentukan koleksi MongoDB yang mendasari menjadi

schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
7, setel opsi
schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
7 ke ukuran maksimum koleksi di

new Schema({..}, { capped: 1024 });

Opsi

schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});
_7 juga dapat disetel ke objek jika Anda ingin memberikan opsi tambahan seperti atau. Dalam hal ini Anda harus secara eksplisit memberikan opsi
const schema1 = new Schema({
  name: String
}, { pluginTags: ['useMetaPlugin'] });

const schema2 = new Schema({
  name: String
});
3, yang diperlukan

new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });

Mongoose secara default menghasilkan nama koleksi dengan meneruskan nama model ke metode. Metode ini jamak nama. Setel opsi ini jika Anda membutuhkan nama lain untuk koleksi Anda

const dataSchema = new Schema({..}, { collection: 'data' });

Saat Anda menentukan diskriminator, Mongoose menambahkan jalur ke skema Anda yang menyimpan diskriminator mana yang merupakan instance dari dokumen. Secara default, Mongoose menambahkan jalur

const schema1 = new Schema({
  name: String
}, { pluginTags: ['useMetaPlugin'] });

const schema2 = new Schema({
  name: String
});
4, tetapi Anda dapat mengatur
const schema1 = new Schema({
  name: String
}, { pluginTags: ['useMetaPlugin'] });

const schema2 = new Schema({
  name: String
});
5 untuk menimpa default ini

Mongoose menetapkan setiap skema Anda sebagai pengambil virtual

const schema1 = new Schema({
  name: String
}, { pluginTags: ['useMetaPlugin'] });

const schema2 = new Schema({
  name: String
});
6 secara default yang mengembalikan bidang
new Schema({..}, { capped: 1024 });
3 dokumen yang dilemparkan ke string, atau dalam kasus ObjectIds, hexString-nya. Jika Anda tidak ingin getter
const schema1 = new Schema({
  name: String
}, { pluginTags: ['useMetaPlugin'] });

const schema2 = new Schema({
  name: String
});
6 ditambahkan ke skema Anda, Anda dapat menonaktifkannya dengan meneruskan opsi ini pada waktu pembuatan skema

Mongoose menetapkan setiap skema Anda bidang

new Schema({..}, { capped: 1024 });
3 secara default jika tidak diteruskan ke konstruktor. Jenis yang ditetapkan adalah untuk bertepatan dengan perilaku default MongoDB. Jika Anda sama sekali tidak ingin
new Schema({..}, { capped: 1024 });
_3 ditambahkan ke skema Anda, Anda dapat menonaktifkannya menggunakan opsi ini

Anda hanya dapat menggunakan opsi ini pada subdokumen. Mongoose tidak dapat menyimpan dokumen tanpa mengetahui idnya, jadi Anda akan mendapatkan kesalahan jika mencoba menyimpan dokumen tanpa

new Schema({..}, { capped: 1024 });
3

Mongoose akan, secara default, "meminimalkan" skema dengan menghapus objek kosong

Perilaku ini dapat diganti dengan menyetel opsi

const schema = new Schema({..}, { bufferCommands: false });
02 ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0. Ini kemudian akan menyimpan objek kosong

Untuk memeriksa apakah suatu objek kosong, Anda dapat menggunakan helper

const schema = new Schema({..}, { bufferCommands: false });
04

Mengizinkan pengaturan opsi di tingkat skema, memberi kami cara untuk menerapkan default ke semua kueri yang berasal dari model

Alias ​​​​dari setiap pref juga diizinkan jadi daripada harus mengetik 'secondaryPreferred' dan salah mengeja, kita cukup meneruskan 'sp'

Opsi baca juga memungkinkan kita menentukan kumpulan tag. Ini memberi tahu pengemudi dari anggota set replika mana yang harus dicoba untuk dibaca. Baca lebih lanjut tentang kumpulan tag dan di sini

CATATAN. Anda juga dapat menentukan opsi preferensi baca driver saat menghubungkan

Mengizinkan pengaturan masalah tulis di tingkat skema

const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});

Opsi

const schema = new Schema({..}, { bufferCommands: false });
05 digunakan ketika kita memiliki arsitektur MongoDB yang dipecah. Setiap koleksi shard diberi kunci pecahan yang harus ada di semua operasi penyisipan/pembaruan. Kami hanya perlu menyetel opsi skema ini ke kunci beling yang sama dan kami akan siap

new Schema({ . }, { shardKey: { tag: 1, name: 1 }})

Perhatikan bahwa Mongoose tidak mengirimkan perintah

const schema = new Schema({..}, { bufferCommands: false });
06 untuk Anda. Anda harus mengonfigurasi pecahan Anda sendiri

Opsi ketat, (diaktifkan secara default), memastikan bahwa nilai yang diteruskan ke konstruktor model kami yang tidak ditentukan dalam skema kami tidak disimpan ke db

Ini juga memengaruhi penggunaan

const schema = new Schema({..}, { bufferCommands: false });
_07 untuk menetapkan nilai properti

Nilai ini dapat diganti pada tingkat instance model dengan meneruskan argumen boolean kedua

Opsi

const schema = new Schema({..}, { bufferCommands: false });
08 juga dapat disetel ke
const schema = new Schema({..}, { bufferCommands: false });
09 yang akan menyebabkan kesalahan dihasilkan alih-alih menjatuhkan data yang buruk

CATATAN. Set kunci/val apa pun pada instance yang tidak ada dalam skema Anda selalu diabaikan, terlepas dari opsi skema

Mongoose mendukung opsi

const schema = new Schema({..}, { bufferCommands: false });
_10 terpisah untuk menghindari mode ketat untuk filter kueri. Ini karena filter kueri kosong menyebabkan Mongoose mengembalikan semua dokumen dalam model, yang dapat menyebabkan masalah

Opsi

const schema = new Schema({..}, { bufferCommands: false });
08 berlaku untuk pembaruan. Opsi
const schema = new Schema({..}, { bufferCommands: false });
10 hanya untuk filter kueri

Mongoose memiliki opsi

const schema = new Schema({..}, { bufferCommands: false });
_10 terpisah untuk beralih mode ketat untuk parameter
const schema = new Schema({..}, { bufferCommands: false });
14 ke kueri

Secara umum, kami tidak menyarankan meneruskan objek yang ditentukan pengguna sebagai filter kueri

Di Mongoose 6,

const schema = new Schema({..}, { bufferCommands: false });
_10 sama dengan
const schema = new Schema({..}, { bufferCommands: false });
08 secara default. Namun, Anda dapat mengganti perilaku ini secara global

Di Mongoose 7,

const schema = new Schema({..}, { bufferCommands: false });
_10 nilai default akan dialihkan kembali ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0. Anda dapat mempersiapkan perubahan dengan menentukan

Persis sama dengan opsi tetapi hanya berlaku ketika metode ________0______19 dokumen dipanggil

Untuk melihat semua opsi

const schema = new Schema({..}, { bufferCommands: false });
_20 yang tersedia, baca

Dokumen memiliki metode yang mengubah dokumen luwak menjadi objek JavaScript biasa. Metode ini menerima beberapa opsi. Alih-alih menerapkan opsi ini berdasarkan per dokumen, kami dapat mendeklarasikan opsi di tingkat skema dan menerapkannya ke semua dokumen skema secara default

Agar semua virtual muncul di output

const schema = new Schema({..}, { bufferCommands: false });
21 Anda, setel opsi
const schema = new Schema({..}, { bufferCommands: false });
22 ke
const schema = new Schema({..}, { bufferCommands: false });
23

Untuk melihat semua opsi

const schema = new Schema({..}, { bufferCommands: false });
_22 yang tersedia, baca

Secara default, jika Anda memiliki objek dengan kunci 'ketik' dalam skema Anda, luwak akan menafsirkannya sebagai deklarasi tipe

Namun, untuk aplikasi seperti geoJSON, properti 'type' sangatlah penting. Jika Anda ingin mengontrol kunci mana yang digunakan mongoose untuk menemukan deklarasi tipe, atur opsi skema 'typeKey'

Secara default, dokumen secara otomatis divalidasi sebelum disimpan ke database. Ini untuk mencegah menyimpan dokumen yang tidak valid. Jika Anda ingin menangani validasi secara manual, dan dapat menyimpan objek yang tidak lolos validasi, Anda dapat menyetel

const schema = new Schema({..}, { bufferCommands: false });
25 ke false

const schema = new Schema({..}, { bufferCommands: false });
26 adalah properti yang ditetapkan pada setiap dokumen saat pertama kali dibuat oleh Mongoose. Nilai kunci ini berisi revisi internal dokumen. Opsi
const schema = new Schema({..}, { bufferCommands: false });
26 adalah string yang mewakili jalur yang akan digunakan untuk pembuatan versi. Standarnya adalah
const schema = new Schema({..}, { bufferCommands: false });
_28. Jika ini bertentangan dengan aplikasi Anda, Anda dapat mengonfigurasinya

Perhatikan bahwa pembuatan versi default Mongoose bukanlah solusi konkurensi optimis penuh. Versi default Mongoose hanya beroperasi pada larik seperti yang ditunjukkan di bawah ini

Jika Anda membutuhkan dukungan konkurensi yang optimis untuk

const schema = new Schema({..}, { bufferCommands: false });
29, Anda dapat menyetel

Pembuatan versi dokumen juga dapat dinonaktifkan dengan menyetel

const schema = new Schema({..}, { bufferCommands: false });
26 ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0. JANGAN nonaktifkan versi kecuali Anda tahu apa yang Anda lakukan

Mongoose hanya memperbarui kunci versi saat Anda menggunakan. Jika Anda menggunakan

const schema = new Schema({..}, { bufferCommands: false });
34,
const schema = new Schema({..}, { bufferCommands: false });
35, dll. Mongoose tidak akan memperbarui kunci versi. Sebagai solusinya, Anda dapat menggunakan middleware di bawah ini

schema.pre('findOneAndUpdate', function() {
  const update = this.getUpdate();
  if (update.__v != null) {
    delete update.__v;
  }
  const keys = ['$set', '$setOnInsert'];
  for (const key of keys) {
    if (update[key] != null && update[key].__v != null) {
      delete update[key].__v;
      if (Object.keys(update[key]).length === 0) {
        delete update[key];
      }
    }
  }
  update.$inc = update.$inc || {};
  update.$inc.__v = 1;
});

Konkurensi optimis adalah strategi untuk memastikan dokumen yang Anda perbarui tidak berubah antara saat Anda memuatnya menggunakan

const schema = new Schema({..}, { bufferCommands: false });
36 atau
const schema = new Schema({..}, { bufferCommands: false });
37, dan saat Anda memperbaruinya menggunakan
const schema = new Schema({..}, { bufferCommands: false });
29

Misalnya, Anda memiliki model

const schema = new Schema({..}, { bufferCommands: false });
_39 yang berisi daftar ________0______40, dan
const schema = new Schema({..}, { bufferCommands: false });
41 yang menunjukkan apakah rumah ini muncul dalam penelusuran. Misalkan sebuah rumah yang berstatus
const schema = new Schema({..}, { bufferCommands: false });
_42 harus memiliki setidaknya dua
const schema = new Schema({..}, { bufferCommands: false });
40. Anda mungkin menerapkan logika menyetujui dokumen rumah seperti yang ditunjukkan di bawah ini

async function markApproved(id) {
  const house = await House.findOne({ _id });
  if (house.photos.length < 2) {
    throw new Error('House must have at least two photos!');
  }
  
  house.status = 'APPROVED';
  await house.save();
}

Fungsi

const schema = new Schema({..}, { bufferCommands: false });
44 terlihat benar dalam isolasi, tetapi mungkin ada potensi masalah. bagaimana jika fungsi lain menghapus foto rumah antara panggilan
const schema = new Schema({..}, { bufferCommands: false });
37 dan panggilan
const schema = new Schema({..}, { bufferCommands: false });
29?

Jika Anda menyetel opsi

const schema = new Schema({..}, { bufferCommands: false });
30 pada skema model
const schema = new Schema({..}, { bufferCommands: false });
39, skrip di atas akan menimbulkan kesalahan

Menetapkan pemeriksaan default untuk setiap kueri dan agregasi. Berikut ini ikhtisar collations ramah-pemula

Jika Anda menyetel opsi

const schema = new Schema({..}, { bufferCommands: false });
_49 pada skema, Mongoose akan membuat koleksi deret waktu untuk model apa pun yang Anda buat dari skema tersebut

const schema = new Schema({..}, { bufferCommands: false });
50 memungkinkan mengecualikan jalur dari pembuatan versi (mis. e. , revisi internal tidak akan bertambah meskipun jalur ini diperbarui). JANGAN lakukan ini kecuali Anda tahu apa yang Anda lakukan. Untuk subdokumen, sertakan ini di dokumen induk menggunakan jalur yang sepenuhnya memenuhi syarat

Opsi

const schema = new Schema({..}, { bufferCommands: false });
51 memberi tahu Mongoose untuk menetapkan bidang
const schema = new Schema({..}, { bufferCommands: false });
52 dan
const schema = new Schema({..}, { bufferCommands: false });
53 ke skema Anda. Jenis yang diberikan adalah

Secara default, nama bidang adalah

const schema = new Schema({..}, { bufferCommands: false });
52 dan
const schema = new Schema({..}, { bufferCommands: false });
53. Sesuaikan nama bidang dengan menyetel
const schema = new Schema({..}, { bufferCommands: false });
_56 dan
const schema = new Schema({..}, { bufferCommands: false });
57

Cara

const schema = new Schema({..}, { bufferCommands: false });
_51 bekerja di bawah tenda adalah

  • Jika Anda membuat dokumen baru, luwak cukup menyetel
    const schema = new Schema({..}, { bufferCommands: false });
    
    52, dan
    const schema = new Schema({..}, { bufferCommands: false });
    
    53 ke waktu pembuatan
  • Jika Anda memperbarui dokumen, luwak akan menambahkan
    const schema = new Schema({..}, { bufferCommands: false });
    
    53 ke objek
    const schema = new Schema({..}, { bufferCommands: false });
    
    62
  • Jika Anda menyetel
    const schema = new Schema({..}, { bufferCommands: false });
    
    63 pada operasi pembaruan, luwak akan menggunakan operator
    const schema = new Schema({..}, { bufferCommands: false });
    
    64 untuk menambahkan
    const schema = new Schema({..}, { bufferCommands: false });
    
    52 ke dokumen jika operasi
    const schema = new Schema({..}, { bufferCommands: false });
    
    66 menghasilkan dokumen baru yang dimasukkan

Secara default, Mongoose menggunakan

const schema = new Schema({..}, { bufferCommands: false });
67 untuk mendapatkan waktu saat ini. Jika Anda ingin menimpa fungsi yang digunakan Mongoose untuk mendapatkan waktu saat ini, Anda dapat mengatur opsi
const schema = new Schema({..}, { bufferCommands: false });
68. Mongoose akan memanggil fungsi
const schema = new Schema({..}, { bufferCommands: false });
_68 kapan pun dibutuhkan untuk mendapatkan waktu saat ini

Mongoose mendukung mendefinisikan plugin global, plugin yang berlaku untuk semua skema

Terkadang, Anda mungkin hanya ingin menerapkan plugin tertentu ke beberapa skema. Dalam hal ini, Anda dapat menambahkan

const schema = new Schema({..}, { bufferCommands: false });
_70 ke skema

const schema1 = new Schema({
  name: String
}, { pluginTags: ['useMetaPlugin'] });

const schema2 = new Schema({
  name: String
});

Jika Anda memanggil

const schema = new Schema({..}, { bufferCommands: false });
_71 dengan opsi
const schema = new Schema({..}, { bufferCommands: false });
72, Mongoose hanya akan menerapkan plugin tersebut ke skema yang memiliki entri yang cocok di
const schema = new Schema({..}, { bufferCommands: false });
70

Secara default, Mongoose akan secara otomatis

const schema = new Schema({..}, { bufferCommands: false });
74 jalur terisi apa pun untuk Anda, kecuali jika Anda mengecualikannya secara eksplisit

Untuk menyisih dari pemilihan kolom berpopulasi secara default, setel

const schema = new Schema({..}, { bufferCommands: false });
75 ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0 di skema Anda

Untuk alasan lama, ketika ada kesalahan validasi di subjalur skema bersarang tunggal, Mongoose juga akan mencatat bahwa ada kesalahan validasi di jalur skema bersarang tunggal. Sebagai contoh

Setel

const schema = new Schema({..}, { bufferCommands: false });
_77 ke
const schema = new Schema({ name: String }, {
  writeConcern: {
    w: 'majority',
    j: true,
    wtimeout: 1000
  }
});
0 pada skema anak untuk membuat Mongoose hanya melaporkan kesalahan induk

Skema memiliki yang dapat Anda gunakan untuk membuat skema Mongoose dari kelas ES6

Berikut adalah contoh penggunaan

const schema = new Schema({..}, { bufferCommands: false });
_79 untuk membuat skema dari kelas ES6

Skema juga dapat dicolokkan yang memungkinkan kami mengemas fitur yang dapat digunakan kembali ke dalam plugin yang dapat dibagikan dengan komunitas atau hanya di antara proyek Anda

Inilah pengantar alternatif untuk skema Mongoose

Untuk mendapatkan hasil maksimal dari MongoDB, Anda perlu mempelajari dasar-dasar desain skema MongoDB. Desain skema SQL (bentuk normal ketiga) dirancang untuk meminimalkan biaya penyimpanan, sedangkan desain skema MongoDB adalah tentang membuat kueri umum secepat mungkin. Seri blog 6 Rules of Thumb for MongoDB Schema Design adalah sumber yang bagus untuk mempelajari aturan dasar untuk mempercepat kueri Anda

Pengguna yang ingin menguasai desain skema MongoDB di Node. js harus melihat ke Buku Desain Skema MongoDB Kecil oleh Christian Kvalheim, penulis asli MongoDB Node. driver js. Buku ini menunjukkan cara menerapkan skema performa untuk daftar cucian kasus penggunaan, termasuk e-niaga, wiki, dan pemesanan janji temu

Bagaimana cara membuat skema di Kompas MongoDB?

Anda dapat membuat koleksi baru di database yang sudah ada. .
Klik tombol Buat Koleksi. Dari layar Koleksi, klik tombol Buat Koleksi
Masukkan informasi koleksi. Dalam dialog Buat Koleksi, masukkan nama koleksi yang akan dibuat. .
Klik Buat Koleksi untuk membuat koleksi

Bisakah MongoDB memiliki skema?

MongoDB menggunakan model skema yang fleksibel , yang berarti bahwa dokumen dalam kumpulan tidak perlu memiliki bidang atau tipe data yang sama secara default. Setelah membuat skema aplikasi, Anda dapat menggunakan validasi skema untuk memastikan tidak ada perubahan skema yang tidak diinginkan atau tipe data yang tidak tepat.

Apa itu skema MongoDB?

Apa itu Skema? . Anda dapat menggunakan skema BSON Layanan Aplikasi Atlas, yang memperluas standar Skema JSON, untuk menentukan model data aplikasi Anda dan memvalidasi dokumen setiap kali dibuat, diubah, atau dihapus. a JSON object that defines the the structure and contents of your data. You can use Atlas App Services' BSON schemas, which extend the JSON Schema standard, to define your application's data model and validate documents whenever they're created, changed, or deleted.

Bagaimana cara mendapatkan skema basis data di MongoDB?

Kita bisa mendapatkan objek skema/dokumen pertama dari koleksi menggunakan. var schemaObj = db. pengguna. findOne();