Apa skema di mongodb

Mongoose adalah library Object Data Modeling (ODM) untuk MongoDB dan Node. js. Itu mengelola hubungan antara data, menyediakan validasi skema, dan digunakan untuk menerjemahkan antar objek dalam kode dan representasi objek tersebut di MongoDB

Pemetaan Objek antara Node dan MongoDB dikelola melalui Mongoose

MongoDB adalah database dokumen NoSQL tanpa skema. Ini berarti Anda dapat menyimpan dokumen JSON di dalamnya, dan struktur dokumen ini dapat bervariasi karena tidak diberlakukan seperti database SQL. Ini adalah salah satu keuntungan menggunakan NoSQL karena mempercepat pengembangan aplikasi dan mengurangi kerumitan penerapan

Di bawah ini adalah contoh bagaimana data disimpan di Mongo vs. Basis Data SQL

Dokumen NoSQL vs. Tabel Relasional dalam SQL

Terminologi

Koleksi

'Koleksi' di Mongo setara dengan tabel di database relasional. Mereka dapat menyimpan banyak dokumen JSON

Dokumen

'Dokumen' setara dengan catatan atau baris data dalam SQL. Sementara baris SQL dapat mereferensikan data di tabel lain, dokumen Mongo biasanya menggabungkannya dalam dokumen

Bidang

'Bidang' atau atribut mirip dengan kolom dalam tabel SQL

Skema

Sementara Mongo tanpa skema, SQL mendefinisikan skema melalui definisi tabel. 'Skema' Mongoose adalah struktur data dokumen (atau bentuk dokumen) yang ditegakkan melalui lapisan aplikasi

Model

'Model' adalah konstruktor tingkat tinggi yang mengambil skema dan membuat turunan dokumen yang setara dengan catatan dalam database relasional

Mulai

Instalasi Monggo

Sebelum memulai, mari siapkan Mongo. Anda dapat memilih salah satu opsi berikut (kami menggunakan opsi #1 untuk artikel ini)

1. Unduh versi MongoDB yang sesuai untuk Sistem Operasi Anda dari dan ikuti petunjuk pemasangannya
2. Buat langganan basis data kotak pasir gratis di mLab
3. Instal Mongo menggunakan Docker jika Anda lebih suka menggunakan buruh pelabuhan

Mari telusuri beberapa dasar Mongoose dengan menerapkan model yang merepresentasikan data untuk buku alamat yang disederhanakan

Saya menggunakan Kode Visual Studio, Node 8. 9, dan NPM5. 6. Jalankan IDE favorit Anda, buat proyek kosong, dan mari kita mulai. Kami akan menggunakan sintaks ES6 terbatas di Node, jadi kami tidak akan mengonfigurasi Babel

Instal NPM

Mari kita pergi ke folder proyek dan menginisialisasi proyek kita

npm init -y

Mari instal Mongoose dan pustaka validasi dengan perintah berikut

npm install mongoose validator

_

Perintah install di atas akan menginstal versi terbaru dari library. Sintaks Mongoose dalam artikel ini khusus untuk Mongoose v5 dan seterusnya

Koneksi Basis Data

Buat file

let mongoose = require('mongoose')

_1 di bawah root proyek

Selanjutnya kita akan menambahkan class sederhana dengan method yang terhubung ke database

String koneksi Anda akan bervariasi berdasarkan instalasi Anda

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Panggilan

let mongoose = require('mongoose')

_2 di atas mengembalikan objek Singleton. Ini berarti bahwa pertama kali Anda memanggil

let mongoose = require('mongoose')

_2, itu membuat turunan dari kelas Mongoose dan mengembalikannya. Pada panggilan berikutnya, itu akan mengembalikan instance yang sama yang dibuat dan dikembalikan kepada Anda pertama kali karena cara kerja impor/ekspor modul di ES6

Impor modul/membutuhkan alur kerja

Demikian pula, kami telah mengubah kelas Database kami menjadi singleton dengan mengembalikan instance kelas dalam pernyataan

let mongoose = require('mongoose')

4 karena kami hanya memerlukan satu koneksi ke database

ES6 sangat memudahkan kita untuk membuat pola singleton (instance tunggal) karena cara kerja pemuat modul dengan menyimpan respons dari file yang diimpor sebelumnya ke dalam cache

Skema Mongoose vs. Model

Model Mongoose adalah pembungkus skema Mongoose. Skema Mongoose menentukan struktur dokumen, nilai default, validator, dll. , sedangkan model Mongoose menyediakan antarmuka ke database untuk membuat, membuat kueri, memperbarui, menghapus rekaman, dll.

Membuat model Mongoose terutama terdiri dari tiga bagian

1. Referensi Mongoose

let mongoose = require('mongoose')

Referensi ini akan sama dengan yang dikembalikan saat kita terhubung ke database, yang berarti definisi skema dan model tidak perlu terhubung secara eksplisit ke database

2. Mendefinisikan Skema

Skema mendefinisikan properti dokumen melalui objek di mana nama kunci sesuai dengan nama properti dalam koleksi

let emailSchema = new mongoose.Schema({
  email: String
})

_

Di sini kita mendefinisikan properti bernama email dengan tipe skema String yang memetakan ke validator internal yang akan dipicu saat model disimpan ke database. Itu akan gagal jika tipe data dari nilai bukan tipe string

Jenis Skema berikut diizinkan

• Himpunan
• Boolean
• Penyangga
• Tanggal
• Campuran (Tipe data umum/fleksibel)
• Nomor
• ObjectId
• Rangkaian

Mixed dan ObjectId didefinisikan di bawah

let mongoose = require('mongoose')

5

3. Mengekspor Model

Kita perlu memanggil konstruktor model pada instance Mongoose dan meneruskannya dengan nama koleksi dan referensi ke definisi skema

module.exports = mongoose.model('Email', emailSchema)

Mari gabungkan kode di atas menjadi

let mongoose = require('mongoose')

6 untuk menentukan konten model email dasar

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

Definisi skema harus sederhana, tetapi kerumitannya biasanya didasarkan pada persyaratan aplikasi. Skema dapat digunakan kembali dan dapat berisi beberapa skema anak juga. Pada contoh di atas, nilai properti email adalah tipe nilai sederhana. Namun, itu juga bisa menjadi tipe objek dengan properti tambahan di dalamnya

Kita dapat membuat instance dari model yang kita definisikan di atas dan mengisinya menggunakan sintaks berikut

let EmailModel = require('./email')

let msg = new EmailModel({
  email: '[email protected]'
})

Mari tingkatkan skema Email untuk membuat properti email menjadi bidang wajib yang unik dan mengonversi nilainya menjadi huruf kecil sebelum menyimpannya. Kami juga dapat menambahkan fungsi validasi yang akan memastikan bahwa nilainya adalah alamat email yang valid. Kami akan merujuk dan menggunakan pustaka validator yang diinstal sebelumnya

let mongoose = require('mongoose')
let validator = require('validator')

let emailSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    validate: (value) => {
      return validator.isEmail(value)
    }
  }
})

module.exports = mongoose.model('Email', emailSchema)

Operasi Dasar

Mongoose memiliki API yang fleksibel dan menyediakan banyak cara untuk menyelesaikan tugas. Kami tidak akan fokus pada variasi karena itu di luar cakupan artikel ini, tetapi ingat bahwa sebagian besar operasi dapat dilakukan dengan lebih dari satu cara baik secara sintaksis atau melalui arsitektur aplikasi

Buat Rekam

Mari buat contoh model email dan simpan ke database

let EmailModel = require('./email')

let msg = new EmailModel({
  email: '[email protected]'
})

msg.save()
   .then(doc => {
     console.log(doc)
   })
   .catch(err => {
     console.error(err)
   })

Hasilnya adalah dokumen yang dikembalikan setelah penyimpanan berhasil

npm install mongoose validator

_0

Bidang berikut dikembalikan (bidang internal diawali dengan garis bawah)

1. Bidang

   let mongoose = require('mongoose')

   _7 dihasilkan secara otomatis oleh Mongo dan merupakan kunci utama dari koleksi. Nilainya adalah pengidentifikasi unik untuk dokumen tersebut
2. Nilai bidang

   let mongoose = require('mongoose')

   _8 dikembalikan. Perhatikan bahwa ini menggunakan huruf kecil karena kami menentukan atribut

   let mongoose = require('mongoose')

   9 dalam skema

3. let emailSchema = new mongoose.Schema({
     email: String
   })

   0 adalah properti versionKey yang ditetapkan pada setiap dokumen saat pertama kali dibuat oleh Mongoose. Nilainya berisi revisi internal dokumen

Jika Anda mencoba mengulangi operasi penyimpanan di atas, Anda akan mendapatkan kesalahan karena kami telah menetapkan bahwa bidang email harus unik

Ambil Rekam

Mari kita coba mengambil record yang kita simpan ke database tadi. Kelas model memaparkan beberapa metode statis dan instan untuk melakukan operasi pada database. Kami sekarang akan mencoba menemukan catatan yang kami buat sebelumnya menggunakan metode temukan dan meneruskan email sebagai istilah pencarian

npm install mongoose validator

_1

Dokumen yang dikembalikan akan serupa dengan yang ditampilkan saat kami membuat rekaman

npm install mongoose validator

_0

Perbarui Catatan

Mari ubah catatan di atas dengan mengubah alamat email dan menambahkan bidang lain ke dalamnya, semuanya dalam satu operasi. Untuk alasan kinerja, Mongoose tidak akan mengembalikan dokumen yang telah diperbarui, jadi kami harus memberikan parameter tambahan untuk memintanya

npm install mongoose validator

_3

Dokumen yang dikembalikan akan berisi email yang diperbarui

npm install mongoose validator

_4

Hapus Catatan

Kami akan menggunakan panggilan

let emailSchema = new mongoose.Schema({
  email: String
})

_1 untuk menghapus catatan. Ini mengembalikan dokumen asli yang telah dihapus

npm install mongoose validator

_5

Pembantu

Kami telah melihat beberapa fungsi dasar di atas yang dikenal sebagai operasi CRUD (Buat, Baca, Perbarui, Hapus), tetapi Mongoose juga menyediakan kemampuan untuk mengonfigurasi beberapa jenis metode dan properti pembantu. Ini dapat digunakan untuk lebih menyederhanakan bekerja dengan data

Mari buat skema pengguna di

let emailSchema = new mongoose.Schema({
  email: String
})

2 dengan bidang

let emailSchema = new mongoose.Schema({
  email: String
})

3 dan

let emailSchema = new mongoose.Schema({
  email: String
})

4

npm install mongoose validator

_6

Properti Virtual

Properti virtual tidak dipertahankan ke database. Kami dapat menambahkannya ke skema kami sebagai pembantu untuk mendapatkan dan menetapkan nilai

Mari buat properti virtual bernama

let emailSchema = new mongoose.Schema({
  email: String
})

5 yang dapat digunakan untuk menetapkan nilai pada

let emailSchema = new mongoose.Schema({
  email: String
})

3 dan

let emailSchema = new mongoose.Schema({
  email: String
})

4 dan mengambilnya sebagai nilai gabungan saat dibaca

npm install mongoose validator

_7

Panggilan balik untuk mendapatkan dan mengatur harus menggunakan kata kunci fungsi karena kita perlu mengakses model melalui kata kunci

let emailSchema = new mongoose.Schema({
  email: String
})

8. Menggunakan fungsi panah gemuk akan mengubah apa yang dimaksud ________8______8

Sekarang, kita dapat menyetel

let emailSchema = new mongoose.Schema({
  email: String
})

3 dan

let emailSchema = new mongoose.Schema({
  email: String
})

4 dengan menetapkan nilai ke

let emailSchema = new mongoose.Schema({
  email: String
})

5

npm install mongoose validator

_8

Kode di atas akan menampilkan berikut ini

npm install mongoose validator

_9

Metode Instance

Kami dapat membuat metode pembantu khusus pada skema dan mengaksesnya melalui contoh model. Metode ini akan memiliki akses ke objek model dan dapat digunakan dengan cukup kreatif. Misalnya, kita dapat membuat metode untuk menemukan semua orang yang memiliki nama depan yang sama dengan instance saat ini

Dalam contoh ini, mari buat fungsi untuk mengembalikan inisial untuk pengguna saat ini. Mari tambahkan metode pembantu khusus yang disebut

module.exports = mongoose.model('Email', emailSchema)

3 ke skema

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

0

Metode ini akan dapat diakses melalui instance model

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

1

Metode Statis

Mirip dengan metode instance, kita dapat membuat metode statis pada skema. Mari buat metode untuk mengambil semua pengguna di database

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

2

Memanggil

module.exports = mongoose.model('Email', emailSchema)

_4 pada kelas Model akan mengembalikan semua pengguna dalam database

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

_3

Menambahkan metode instance dan statis adalah pendekatan yang bagus untuk mengimplementasikan antarmuka ke interaksi basis data pada koleksi dan catatan

Middleware

Middleware adalah fungsi yang berjalan pada tahapan tertentu dari sebuah pipeline. Mongoose mendukung middleware untuk operasi berikut

• Agregat
• Dokumen
• Model
• Pertanyaan

Misalnya, model memiliki fungsi

module.exports = mongoose.model('Email', emailSchema)

_5 dan

module.exports = mongoose.model('Email', emailSchema)

6 yang menggunakan dua parameter

1. Jenis peristiwa ('init', 'validate', 'save', 'remove')
2. Callback yang dijalankan dengan mereferensikan instance model ini

Contoh Middleware (a. k. a. kait pra dan pasca)

Mari kita coba sebuah contoh dengan menambahkan dua bidang bernama

module.exports = mongoose.model('Email', emailSchema)

7 dan

module.exports = mongoose.model('Email', emailSchema)

8 ke skema kita

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

_4

Saat

module.exports = mongoose.model('Email', emailSchema)

_9 dipanggil, ada peristiwa

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

0 dan

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

1 yang dipicu. Untuk parameter kedua, Anda bisa melewatkan fungsi yang dipanggil saat peristiwa dipicu. Fungsi-fungsi ini mengambil parameter ke fungsi berikutnya dalam rantai middleware

Mari tambahkan kait pra-simpan dan tetapkan nilai untuk

module.exports = mongoose.model('Email', emailSchema)

7 dan

module.exports = mongoose.model('Email', emailSchema)

8

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

5

Mari buat dan simpan model kita

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

6

Anda akan melihat nilai untuk

module.exports = mongoose.model('Email', emailSchema)

_7 dan

module.exports = mongoose.model('Email', emailSchema)

8 saat rekaman yang dibuat dicetak

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

_7

Plugin

Misalkan kita ingin melacak kapan record dibuat dan terakhir diperbarui pada setiap koleksi di database kita. Alih-alih mengulangi proses di atas, kita dapat membuat plugin dan menerapkannya ke setiap skema

Mari buat file

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

_6 dan replikasi fungsi di atas sebagai modul yang dapat digunakan kembali

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

8

Untuk menggunakan plugin ini, kami cukup meneruskannya ke skema yang harus diberi fungsi ini

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

_9

Gedung Kueri

Mongoose memiliki API yang sangat kaya yang menangani banyak operasi kompleks yang didukung oleh MongoDB. Pertimbangkan kueri tempat kami dapat membuat komponen kueri secara bertahap

Dalam contoh ini, kita akan

1. Temukan semua pengguna
2. Lewati 100 rekaman pertama
3. Batasi hasil hingga 10 rekaman
4. Urutkan hasilnya berdasarkan kolom firstName
5. Pilih nama depan
6. Jalankan kueri itu

let mongoose = require('mongoose')

0

Penutupan

Kami baru saja menggores permukaan menjelajahi beberapa kemampuan Mongoose. Ini adalah perpustakaan kaya yang penuh dengan fitur berguna dan canggih yang membuatnya menyenangkan untuk bekerja dengan model data di lapisan aplikasi

Meskipun Anda dapat berinteraksi dengan Mongo secara langsung menggunakan Mongo Driver, Mongoose akan menyederhanakan interaksi tersebut dengan memungkinkan Anda membuat model hubungan antar data dan memvalidasinya dengan mudah

Fakta Menyenangkan. Mongoose dibuat oleh Valeri Karpov yang merupakan insinyur yang sangat berbakat. Dia menciptakan istilah The MEAN Stack

Jika artikel ini bermanfaat, ???

Anda mungkin juga menyukai bengkel saya di youtube. Cara Membangun REST API dengan Node. Cepat. Mongo

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

IKLAN

---

Jika artikel ini bermanfaat, tweetlah

Belajar kode secara gratis. Kurikulum open source freeCodeCamp telah membantu lebih dari 40.000 orang mendapatkan pekerjaan sebagai pengembang. Memulai

Apakah MongoDB memiliki skema?

Mengapa menggunakan skema di MongoDB?

Bagaimana Anda mendefinisikan skema?

Bagaimana cara membuat skema di MongoDB?