Bagaimana cara menemukan skema koleksi di mongodb?

Pada intinya, aplikasi web menawarkan kepada penggunanya tampilan ke dalam, dan cara untuk memodifikasi, kumpulan data yang persisten. Apakah mengelola daftar todos, atau memesan mobil untuk menjemput Anda, Anda berinteraksi dengan lapisan data yang permanen namun terus berubah

Di Meteor, lapisan data tersebut biasanya disimpan di MongoDB. Satu set data terkait di MongoDB disebut sebagai "kumpulan". Di Meteor Anda mengakses MongoDB melalui , menjadikannya mekanisme persistensi utama untuk data aplikasi Anda

Namun, koleksi lebih dari sekadar cara untuk menyimpan dan mengambil data. Mereka juga memberikan inti dari pengalaman pengguna yang interaktif dan terhubung yang diharapkan pengguna dari aplikasi terbaik. Meteor membuat pengalaman pengguna ini mudah diterapkan

Dalam artikel ini, kita akan mencermati cara kerja koleksi di berbagai tempat dalam kerangka kerja, dan cara memanfaatkannya secara maksimal

Koleksi sisi server

Saat Anda membuat koleksi di server

Todos = new Mongo.Collection('todos');

Anda membuat koleksi di dalam MongoDB, dan antarmuka ke koleksi tersebut untuk digunakan di server. Ini adalah lapisan yang cukup mudah di atas driver Node MongoDB yang mendasarinya, tetapi dengan API sinkron

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Koleksi sisi klien

Di klien, saat Anda menulis baris yang sama

Todos = new Mongo.Collection('todos');

Itu melakukan sesuatu yang sama sekali berbeda

Pada klien, tidak ada koneksi langsung ke database MongoDB, dan sebenarnya API sinkron untuk itu tidak mungkin (atau mungkin yang Anda inginkan). Sebagai gantinya, pada klien, koleksi adalah cache sisi klien dari database. Hal ini dicapai berkat perpustakaan Minimongo—sebuah implementasi dalam memori, semua JS, dari MongoDB API

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

Cara Anda memindahkan data dari koleksi server (dan yang didukung MongoDB) ke koleksi klien (dalam memori) adalah subjek dari artikel pemuatan data. Secara umum, Anda berlangganan publikasi, yang mendorong data dari server ke klien. Biasanya, Anda dapat berasumsi bahwa klien berisi salinan terbaru dari beberapa subset dari koleksi lengkap MongoDB

Untuk menulis data kembali ke server, Anda menggunakan Metode, subjek dari artikel metode

Koleksi lokal

Ada cara ketiga untuk menggunakan koleksi di Meteor. Di klien atau server, jika Anda membuat koleksi dengan salah satu dari dua cara ini

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

Ini menciptakan koleksi lokal. Ini adalah koleksi Minimongo yang tidak memiliki koneksi database (biasanya koleksi akan terhubung langsung ke database di server, atau melalui langganan di klien)

Koleksi lokal adalah cara mudah untuk menggunakan kekuatan penuh perpustakaan Minimongo untuk penyimpanan dalam memori. Misalnya, Anda mungkin menggunakannya sebagai pengganti larik sederhana jika Anda perlu menjalankan kueri kompleks atas data Anda. Atau Anda mungkin ingin memanfaatkan reaktivitasnya pada klien untuk mendorong beberapa UI dengan cara yang terasa alami di Meteor

Mendefinisikan skema

Meskipun MongoDB adalah database tanpa skema, yang memungkinkan fleksibilitas maksimum dalam penataan data, umumnya praktik yang baik menggunakan skema untuk membatasi konten koleksi Anda agar sesuai dengan format yang diketahui. Jika tidak, maka Anda cenderung perlu menulis kode defensif untuk memeriksa dan mengonfirmasi struktur data Anda saat keluar dari database, bukan saat masuk ke database. Seperti dalam kebanyakan hal, Anda cenderung membaca data lebih sering daripada menulisnya, sehingga biasanya lebih mudah, dan lebih sedikit buggy untuk menggunakan skema saat menulis

Di Meteor, paket skema unggulan adalah paket npm simpl-schema. Ini adalah skema ekspresif berbasis MongoDB yang digunakan untuk menyisipkan dan memperbarui dokumen. Alternatif lain adalah jagi. astronomi yang merupakan lapisan Object Model (OM) lengkap yang menawarkan definisi skema, validator sisi server/klien, metode objek, dan penangan peristiwa

Anggaplah kita memiliki koleksi

Todos = new Mongo.Collection('todos');

Todos = new Mongo.Collection('todos');

Todos = new Mongo.Collection('todos');

Todos = new Mongo.Collection('todos');

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

Contoh dari aplikasi Todos ini mendefinisikan skema dengan beberapa aturan sederhana

1. Kami menentukan bahwa bidang

   Todos = new Mongo.Collection('todos');
   

   _9 dari daftar diperlukan dan harus berupa string
2. Kami menentukan

   // This line is changing an in-memory Minimongo data structure
   Todos.insert({_id: 'my-todo'});
   // And this line is querying it
   const todo = Todos.findOne({_id: 'my-todo'});
   // So this happens right away!
   console.log(todo);
   

   _0 adalah angka, yang pada penyisipan diatur ke

   // This line is changing an in-memory Minimongo data structure
   Todos.insert({_id: 'my-todo'});
   // And this line is querying it
   const todo = Todos.findOne({_id: 'my-todo'});
   // So this happens right away!
   console.log(todo);
   

   1 jika tidak ditentukan lain
3. Kami menetapkan bahwa

   // This line is changing an in-memory Minimongo data structure
   Todos.insert({_id: 'my-todo'});
   // And this line is querying it
   const todo = Todos.findOne({_id: 'my-todo'});
   // So this happens right away!
   console.log(todo);
   

   _2, yang bersifat opsional, harus berupa string yang terlihat seperti ID dokumen pengguna

Kami melampirkan skema ke namespace

Todos = new Mongo.Collection('todos');

Anda dapat melihat bahwa dengan kode yang relatif sedikit, kami berhasil membatasi format daftar secara signifikan. Anda dapat membaca lebih lanjut tentang hal-hal yang lebih rumit yang dapat dilakukan dengan skema di dokumen Skema Sederhana

Memvalidasi terhadap skema

Sekarang kami memiliki skema, bagaimana kami menggunakannya?

Cukup mudah untuk memvalidasi dokumen dengan skema. Kita bisa menulis

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

Dalam hal ini, karena daftar valid menurut skema, baris

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

Kemudian panggilan

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

`ValidationError`

Apa itu

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

Merancang skema data Anda

Sekarang setelah Anda terbiasa dengan API dasar Skema Sederhana, ada baiknya mempertimbangkan beberapa batasan sistem data Meteor yang dapat memengaruhi desain skema data Anda. Meskipun secara umum Anda dapat membuat skema data Meteor seperti skema data MongoDB lainnya, ada beberapa detail penting yang perlu diingat

Pertimbangan terpenting terkait dengan cara DDP, protokol pemuatan data Meteor, mengkomunikasikan dokumen melalui kabel. Hal utama yang harus disadari adalah bahwa DDP mengirimkan perubahan ke dokumen di tingkat bidang dokumen tingkat atas. Artinya, jika Anda memiliki subbidang yang besar dan kompleks pada dokumen yang sering berubah, DDP dapat mengirim perubahan yang tidak perlu melalui kabel

Misalnya, dalam MongoDB "murni" Anda dapat merancang skema sehingga setiap dokumen daftar memiliki bidang bernama

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

Masalah dengan skema ini adalah karena perilaku DDP yang baru saja disebutkan, setiap perubahan pada item todo apa pun dalam daftar akan memerlukan pengiriman seluruh rangkaian todo untuk daftar itu melalui jaringan. Ini karena DDP tidak memiliki konsep "ubah bidang

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

Denormalisasi dan banyak koleksi

Implikasi dari hal di atas adalah kita perlu membuat lebih banyak koleksi untuk memuat sub-dokumen. Dalam kasus aplikasi Todos, kami membutuhkan koleksi

Todos = new Mongo.Collection('todos');

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

Di Meteor, sering kali melakukan hal ini lebih sedikit masalah daripada di aplikasi MongoDB pada umumnya, karena mudah untuk menerbitkan kumpulan dokumen yang tumpang tindih (kita mungkin memerlukan satu kumpulan pengguna untuk merender satu layar aplikasi kita, dan kumpulan yang berpotongan . Jadi dalam skenario itu ada keuntungan memisahkan subdokumen dari induknya

Namun, mengingat MongoDB sebelum versi 3. 2 tidak mendukung kueri pada banyak koleksi ("bergabung"), kami biasanya harus mendenormalisasi beberapa data kembali ke koleksi induk. Denormalisasi adalah praktik menyimpan potongan informasi yang sama dalam database berkali-kali (berlawanan dengan bentuk "normal" yang tidak berlebihan). MongoDB adalah database tempat denormalisasi didorong, dan dengan demikian dioptimalkan untuk praktik ini

Dalam kasus aplikasi Todos, karena kami ingin menampilkan jumlah todos yang belum selesai di sebelah setiap daftar, kami perlu melakukan denormalisasi

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

Denormalisasi lain yang terkadang diperlukan oleh arsitektur ini dapat berasal dari dokumen induk ke sub-dokumen. Misalnya, di Todos, karena kami menegakkan privasi daftar todo melalui atribut

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

Merancang untuk masa depan

Aplikasi, terutama aplikasi web, jarang selesai, dan sangat berguna untuk mempertimbangkan potensi perubahan di masa mendatang saat mendesain skema data Anda. Seperti dalam kebanyakan hal, menambahkan bidang jarang merupakan ide yang baik sebelum Anda benar-benar membutuhkannya (seringkali apa yang Anda perkirakan tidak benar-benar terjadi pada akhirnya)

Namun, sebaiknya pikirkan terlebih dahulu bagaimana skema dapat berubah seiring waktu. Misalnya, Anda mungkin memiliki daftar string pada dokumen (mungkin sekumpulan tag). Meskipun tergoda untuk membiarkannya sebagai subbidang pada dokumen (dengan asumsi mereka tidak banyak berubah), jika ada kemungkinan besar mereka akan menjadi lebih rumit di masa mendatang (mungkin tag akan memiliki pembuat, atau subtag nanti

Jumlah pandangan jauh ke depan yang Anda masukkan ke dalam desain skema Anda akan bergantung pada batasan individual aplikasi Anda, dan perlu menjadi keputusan penilaian di pihak Anda

Menggunakan skema saat menulis

Meskipun ada berbagai cara untuk menjalankan data melalui Skema Sederhana sebelum mengirimkannya ke koleksi Anda (misalnya Anda dapat memeriksa skema di setiap pemanggilan metode), yang paling sederhana dan paling dapat diandalkan adalah menggunakan paket

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

Untuk melakukannya, kami menggunakan

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

Lists.attachSchema(Lists.schema);

Artinya, sekarang setiap kali kita memanggil

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

`defaultValue` dan pembersihan data

Satu hal yang dilakukan Collection2 adalah sebelum mengirimkannya ke database. Ini termasuk tetapi tidak terbatas pada

1. Jenis pemaksaan - mengubah string menjadi angka
2. Menghapus atribut yang tidak ada dalam skema
3. Menetapkan nilai default berdasarkan

   import SimpleSchema from 'simpl-schema';
   
   Lists.schema = new SimpleSchema({
     name: {type: String},
     incompleteCount: {type: Number, defaultValue: 0},
     userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
   });
   

   _8 dalam definisi skema

Namun, terkadang berguna untuk melakukan inisialisasi yang lebih rumit ke dokumen sebelum memasukkannya ke dalam koleksi. Misalnya, di aplikasi Todos, kami ingin menyetel nama daftar baru menjadi

import SimpleSchema from 'simpl-schema';

Lists.schema = new SimpleSchema({
  name: {type: String},
  incompleteCount: {type: Number, defaultValue: 0},
  userId: {type: String, regEx: SimpleSchema.RegEx.Id, optional: true}
});

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

Untuk melakukannya, kita dapat membuat subkelas

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Kait saat menyisipkan/memperbarui/menghapus

Teknik di atas juga dapat digunakan untuk menyediakan lokasi untuk "menghubungkan" fungsionalitas ekstra ke dalam koleksi. Misalnya, saat menghapus daftar, kami selalu ingin menghapus semua todo-nya secara bersamaan

Kita juga dapat menggunakan subkelas untuk kasus ini, menggantikan metode

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Teknik ini memiliki beberapa kelemahan

1. Mutator bisa menjadi sangat lama ketika Anda ingin melakukan hook berkali-kali
2. Terkadang satu fungsi dapat tersebar di beberapa mutator
3. Ini bisa menjadi tantangan untuk menulis hook dengan cara yang sepenuhnya umum (yang mencakup setiap kemungkinan pemilih dan pengubah), dan mungkin tidak diperlukan untuk aplikasi Anda (karena mungkin Anda hanya pernah memanggil mutator itu dengan satu cara)

Cara mengatasi poin 1. dan 2. adalah memisahkan kumpulan kait ke dalam modulnya sendiri, dan menggunakan mutator sebagai titik untuk memanggil modul itu dengan cara yang masuk akal. Kita akan melihat contohnya

Poin 3. biasanya dapat diselesaikan dengan menempatkan hook di Metode yang memanggil mutator, bukan di hook itu sendiri. Meskipun ini adalah kompromi yang tidak sempurna (karena kita perlu berhati-hati jika kita menambahkan Metode lain yang memanggil mutator itu di masa mendatang), ini lebih baik daripada menulis sekumpulan kode yang tidak pernah benar-benar dipanggil (yang dijamin tidak akan berfungsi. ), atau memberi kesan bahwa hook Anda lebih umum dari yang sebenarnya

Mengabstraksi denormalizer

Denormalisasi mungkin perlu terjadi pada berbagai mutator dari beberapa koleksi. Oleh karena itu, masuk akal untuk mendefinisikan logika denormalisasi di satu tempat, dan menghubungkannya ke setiap mutator dengan satu baris kode. Keuntungan dari pendekatan ini adalah logika denormalisasi berada di satu tempat daripada tersebar di banyak file, tetapi Anda masih dapat memeriksa kode untuk setiap kumpulan dan memahami sepenuhnya apa yang terjadi pada setiap pembaruan

Dalam aplikasi contoh Todos, kami membuat

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Kami kemudian dapat menghubungkan denormalizer ke dalam mutasi koleksi

SelectedTodos = new Mongo.Collection(null);
SelectedTodos = new Mongo.Collection('selectedtodos', {connection: null});

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Perhatikan bahwa kami hanya menangani mutator yang benar-benar kami gunakan dalam aplikasi—kami tidak berurusan dengan semua cara yang memungkinkan jumlah todo pada daftar dapat berubah. Misalnya, jika Anda mengubah

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

// This line is changing an in-memory Minimongo data structure
Todos.insert({_id: 'my-todo'});
// And this line is querying it
const todo = Todos.findOne({_id: 'my-todo'});
// So this happens right away!
console.log(todo);

Berurusan dengan setiap kemungkinan operator MongoDB sulit dilakukan dengan benar, karena MongoDB memiliki bahasa pengubah yang kaya. Alih-alih, kami fokus menangani pengubah yang kami tahu akan kami lihat di aplikasi kami. Jika ini menjadi terlalu rumit, maka memindahkan pengait untuk logika ke dalam Metode yang benar-benar membuat modifikasi yang relevan bisa masuk akal (walaupun Anda harus rajin memastikan Anda melakukannya di semua tempat yang relevan, baik sekarang maupun saat aplikasi berubah

Mungkin masuk akal jika ada paket untuk sepenuhnya mengabstraksi beberapa teknik denormalisasi umum dan benar-benar berusaha menangani semua kemungkinan modifikasi. Jika Anda menulis paket seperti itu, beri tahu kami

Bermigrasi ke skema baru

Seperti yang telah kita bahas di atas, mencoba memprediksi semua persyaratan skema data Anda di masa mendatang adalah hal yang mustahil. Tak pelak, saat sebuah proyek matang, akan tiba saatnya Anda perlu mengubah skema database. Anda harus berhati-hati tentang cara melakukan migrasi ke skema baru untuk memastikan aplikasi Anda bekerja dengan lancar selama dan setelah migrasi

Menulis migrasi

Paket yang berguna untuk menulis migrasi adalah

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

Misalkan, sebagai contoh, kami ingin menambahkan bidang

const list = {
  name: 'My list',
  incompleteCount: 3
};

Lists.schema.validate(list);

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Migrasi ini, yang diurutkan menjadi migrasi pertama yang berjalan di atas database, akan, saat dipanggil, memperbarui setiap daftar dengan hitungan todo saat ini

Untuk mengetahui lebih lanjut tentang API dari paket Migrasi, lihat dokumentasinya

Perubahan massal

Jika migrasi Anda perlu mengubah banyak data, dan terutama jika Anda perlu menghentikan server aplikasi Anda saat sedang berjalan, sebaiknya gunakan Operasi Massal MongoDB

Keuntungan dari operasi massal adalah hanya memerlukan satu perjalanan pulang pergi ke MongoDB untuk penulisan, yang biasanya berarti jauh lebih cepat. Sisi negatifnya adalah jika migrasi Anda rumit (yang biasanya terjadi jika Anda tidak dapat melakukan

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

Artinya, jika pengguna mengakses situs saat pembaruan sedang disiapkan, kemungkinan besar situs tersebut tidak akan berfungsi. Selain itu, pembaruan massal akan mengunci seluruh koleksi saat sedang diterapkan, yang dapat menyebabkan blip yang signifikan dalam pengalaman pengguna Anda jika perlu beberapa saat. Karena alasan ini, Anda sering kali harus menghentikan server dan memberi tahu pengguna bahwa Anda sedang melakukan pemeliharaan saat pembaruan sedang berlangsung

Kami dapat menulis migrasi kami di atas seperti itu (perhatikan bahwa Anda harus menggunakan MongoDB 2. 6 atau lebih baru agar operasi pembaruan massal ada). Kami dapat mengakses API MongoDB asli melalui

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Perhatikan bahwa kami dapat membuat migrasi ini lebih cepat dengan menggunakan Agregasi untuk mengumpulkan kumpulan awal jumlah todo

Menjalankan migrasi

Untuk menjalankan migrasi terhadap database pengembangan Anda, paling mudah menggunakan shell Meteor

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Jika migrasi mencatat apa pun ke konsol, Anda akan melihatnya di jendela terminal yang menjalankan server Meteor

Untuk menjalankan migrasi terhadap basis data produksi Anda, jalankan aplikasi Anda secara lokal dalam mode produksi (dengan setelan produksi dan variabel lingkungan, termasuk setelan basis data), dan gunakan shell Meteor dengan cara yang sama. Apa yang dilakukan adalah menjalankan fungsi

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

Cara yang baik untuk melakukan hal di atas adalah dengan menjalankan mesin virtual yang dekat dengan database Anda yang telah menginstal Meteor dan akses SSH (instance EC2 khusus yang Anda mulai dan hentikan untuk tujuan tersebut adalah opsi yang masuk akal), dan menjalankan perintah setelah penembakan . Dengan begitu latensi apa pun antara mesin Anda dan database akan dihilangkan, tetapi Anda masih bisa sangat berhati-hati tentang cara menjalankan migrasi

Perhatikan bahwa Anda harus selalu membuat cadangan basis data sebelum menjalankan migrasi apa pun

Melanggar perubahan skema

Terkadang saat kami mengubah skema aplikasi, kami melakukannya dengan cara yang melanggar – sehingga skema lama tidak berfungsi dengan baik dengan basis kode baru. Misalnya, jika kita memiliki beberapa kode UI yang sangat bergantung pada semua daftar yang memiliki

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

Cara sederhana untuk mengatasi masalah ini adalah dengan menghentikan aplikasi selama periode antara penerapan dan penyelesaian migrasi. Ini jauh dari ideal, terutama mengingat beberapa migrasi dapat memakan waktu berjam-jam untuk dijalankan (walaupun menggunakan mungkin sangat membantu di sini)

Pendekatan yang lebih baik adalah penyebaran multi-tahap. Ide dasarnya adalah itu

1. Terapkan versi aplikasi Anda yang dapat menangani skema lama dan baru. Dalam kasus kami, ini akan menjadi kode yang tidak mengharapkan

   const list = {
     name: 'My list',
     incompleteCount: 3,
     madeUpField: 'this should not be here'
   };
   
   Lists.schema.validate(list);
   

   4 ada di sana, tetapi memperbaruinya dengan benar saat todo baru dibuat
2. Jalankan migrasi. Pada titik ini Anda harus yakin bahwa semua daftar memiliki

   const list = {
     name: 'My list',
     incompleteCount: 3,
     madeUpField: 'this should not be here'
   };
   
   Lists.schema.validate(list);
   

   4
3. Terapkan kode baru yang bergantung pada skema baru dan tidak lagi mengetahui cara menangani skema lama. Sekarang kami aman untuk mengandalkan

   const list = {
     name: 'My list',
     incompleteCount: 3
   };
   
   Lists.schema.validate(list);
   

   _9 di UI kami

Hal lain yang harus diperhatikan, terutama dengan penyebaran multi-tahap seperti itu, adalah penting untuk bersiap untuk melakukan rollback. Untuk alasan ini, paket migrasi memungkinkan Anda menentukan fungsi

const list = {
  name: 'My list',
  incompleteCount: 3,
  madeUpField: 'this should not be here'
};

Lists.schema.validate(list);

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

Jadi jika kami ingin membalikkan migrasi kami di atas, kami akan lari

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Jika Anda merasa perlu mengembalikan versi kode Anda, Anda harus berhati-hati dengan datanya, dan melangkah dengan hati-hati melalui langkah-langkah penerapan Anda secara terbalik

Peringatan

Beberapa aspek dari strategi migrasi yang diuraikan di atas mungkin bukan cara yang paling ideal untuk melakukan sesuatu (walaupun mungkin sesuai dalam banyak situasi). Berikut adalah beberapa hal lain yang perlu diperhatikan

1. Biasanya lebih baik tidak mengandalkan kode aplikasi Anda dalam migrasi (karena aplikasi akan berubah seiring waktu, dan migrasi seharusnya tidak). Misalnya, membuat migrasi Anda melewati koleksi Collection2 Anda (dan dengan demikian memeriksa skema, menyetel nilai otomatis, dll.) kemungkinan akan merusaknya seiring waktu karena skema Anda berubah seiring waktu.

   Salah satu cara untuk menghindari masalah ini adalah dengan tidak menjalankan migrasi lama di database Anda. Ini sedikit membatasi tetapi dapat dibuat untuk bekerja

2. Menjalankan migrasi di mesin lokal Anda mungkin akan memakan waktu lebih lama karena mesin Anda tidak sedekat mungkin dengan database produksi

Menyebarkan "aplikasi migrasi" khusus ke perangkat keras yang sama dengan aplikasi Anda yang sebenarnya mungkin merupakan cara terbaik untuk menyelesaikan masalah di atas. Akan luar biasa jika aplikasi semacam itu melacak migrasi mana yang berjalan, dengan log dan menyediakan UI untuk memeriksa dan menjalankannya. Mungkin aplikasi boilerplate untuk melakukannya dapat dibuat (jika Anda melakukannya, beri tahu kami dan kami akan menautkannya di sini. )

Asosiasi antara koleksi

Seperti yang telah kita bahas sebelumnya, sangat umum dalam aplikasi Meteor untuk memiliki asosiasi antar dokumen dalam koleksi yang berbeda. Akibatnya, sangat umum juga untuk menulis kueri yang mengambil dokumen terkait setelah Anda memiliki dokumen yang Anda minati (misalnya semua todo yang ada dalam satu daftar)

Untuk membuatnya lebih mudah, kita dapat melampirkan fungsi ke prototipe dokumen milik koleksi tertentu, untuk memberi kita "metode" pada dokumen (dalam pengertian berorientasi objek). Kami kemudian dapat menggunakan metode ini untuk membuat kueri baru untuk menemukan dokumen terkait

Untuk membuatnya lebih mudah, kita dapat menggunakan paket

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Ini memungkinkan kami untuk mengambil daftar dengan benar beserta todo-nya

// This line won't complete until the insert is done
Todos.insert({_id: 'my-todo'});
// So this line will return something
const todo = Todos.findOne({_id: 'my-todo'});
// Look ma, no callbacks!
console.log(todo);

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

Todos = new Mongo.Collection('todos');

Grapher mendukung kueri isomorfik (reaktif dan non-reaktif), memiliki fitur keamanan bawaan, bekerja dengan banyak jenis hubungan, dan banyak lagi. Lihat dokumentasi Grapher untuk detail lebih lanjut

Pembantu koleksi

Kita dapat menggunakan paket

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

Todos = new Mongo.Collection('todos');

Setelah kami melampirkan pembantu ini ke koleksi

Todos = new Mongo.Collection('todos');

Lists.schema = new SimpleSchema({
  name: {type: String},
  todos: {type: [Object]}
});

Bagaimana cara memeriksa skema pengumpulan di MongoDB?

Apakah ada skema di MongoDB?

Bagaimana cara melihat skema di Kompas MongoDB?

Apa itu skema MongoDB?