MongoDB

MongoDB: Cập nhật Document

Sử dụng phương thức update() hoặc save() dùng để cập nhật documents trong MongoDB

Phương thức update() sẽ cập nhật giá trị cho một hay nhiều document đã tồn tại. Phương thức save() sẽ thay thế một document bằng một document mới được truyền vào thông qua tham số

Tuy nhiên, update() cũng có thể thay thế toàn bộ một document. Điều này tùy thuộc vào các trường nằm trong tham số được truyền vào

Phương thức update()

Dưới đây là ví dụ sử dụng phương thức update().

Đầu tiên, chọn một bản ghi:

db.director.find({ _id: 5 }).pretty()

Kết quả:

{
  _id: 5,
  name: "David Fincher",
  age: 57,
  children: 1
}

 

MongoDB

MongoDB: Tạo mối quan hệ

Để tạo mối quan hệ (relationship) trong MongoDB, có thể nhúng (embed) hoặc tham chiếu (reference) đến Document khác.

MongoDB có cách hoạt động khác với cơ sở dữ liệu quan hệ, kể cả về mặt quan hệ giữa các phần tử (Relationships).

Cụ thể, để tạo relationship, chúng ta sẽ sử dụng 2 phương thức sau:

  • Embeded documents (Nhúng)
  • Referenced  documents (Tham chiếu)

Quan hệ nhúng

Trong MongoDB, chúng ta có thể nhúng document vào bên trong document khác. Khi đó, mỗi document sẽ tự chứa mối quan hệ của riêng nó. Giống như những gì chúng ta đã làm trong bài học trước Tạo mới Document.

Quan hệ một – một

Quan hệ 1 -1 là khi document cha có duy nhất 1 con, và document con cũng có duy nhất 1 cha.

Giả sử mỗi diễn viên chỉ có duy nhất 1 địa chỉ và một địa chỉ thuộc về duy nhất một diễn viên:

db.cast.insert({
  _id: 2,
  name: "Charlize Theron",
  address: {
    street: "Stack Road",
    city: "New York",
    country: "United States"
  }
})

Kết quả:

WriteResult({ "nInserted" : 1 })

Quan hệ một – nhiều

Quan hệ một – nhiều là khi một document cha có nhiều document con, nhưng một document con chỉ có duy nhất 1 document cha.

Ví dụ một một diễn viên có thể đóng vai chính nhiều bộ phim, nhưng một bộ phim chỉ có duy nhất 1 vai chính

db.cast.insert({
  _id: 3,
  name: "Seth Rogen",
  movies: [
    {
      movie: "Long Shot",
      year: 2019,
      genre: "Comendy"
    },
    {
      movie: "The Lion King",
      year: 2019,
      genre: "Animation"
    }
  ]
})

Kết quả:

WriteResult({ "nInserted" : 1 })

Quan hệ tham chiếu

Thay vì sử dụng quan hệ nhúng như chúng ta đã làm ở trên, khi sử dụng tham chiếu, document con sẽ tách biệt hoàn toàn với document cha:

Document cha

db.movie.insert({
  _id: 1,
  movieName: "True Detective"
})

Document con

db.cast.insert({
  _id: 4,
  name: "Matthew McConaughey",
  movie_id: 1
})
db.cast.insert({
  _id: 5,
  name: "Woody Harrelson",
  movie_id: 1
})
db.cast.insert({
  _id: 6,
  name: "Michelle Monaghan",
  movie_id: 1
})

 

MongoDB

MongoDB: Sắp xếp kết quả truy vấn

Trong MongoDB, Chúng ta có thể sắp xếp kết quả truy vấn sử dụng phương thức sort().

Phương thức sort() được sử dụng ngay phía sau db.collection.find().

Khi sử dụng sort(), chúng ta sẽ thêm các tham số để làm cơ sở cho việc sắp xếp. Tham số này thuộc kiểu JSON và có thể chứa nhiều hơn 1 trường (field), mỗi trường sẽ mang giá trị là 1 hoặc -1 (ascending or descending).

Ví dụ

Đầu tiên chúng ta sẽ thực hiện truy vấn mà không sử dụng sort()

Không dùng sort()

db.director.find()

Kết quả:

{_id: 1, name: "Steven Spielberg", age: 72, children: 6}
{_id: 2, name: "Christopher Nolan", age: 49, children: 4}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 4, name: "Jane Campion", age: 65, children: 2}
{ _id: 5, name: "David Fincher", age: 57, children: 1}
{ _id: 6, name: "Peter Jackson", age: 57, children: 2}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{ _id: 8, name: "Ron Howard", age: 65, children: 4}

Sử dụng sort()  sắp xếp tăng dần

Khi trong tham số có trường mang giá trị bằng 1, kết quả trả ra sẽ được sắp xếp tăng dần theo trường đó:

db.director.find().sort( { age: 1 })

Bên trên, chúng ta đang sắp xếp kết quả theo thứ tự tăng dần của trường age:

{_id: 2, name: "Christopher Nolan", age: 49, children: 4}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 5, name: "David Fincher", age: 57, children: 1}
{ _id: 6, name: "Peter Jackson", age: 57, children: 2}
{ _id: 4, name: "Jane Campion", age: 65, children: 2}
{ _id: 8, name: "Ron Howard", age: 65, children: 4}
{_id: 1, name: "Steven Spielberg", age: 72, children: 6}

Sử dụng sort() sắp xếp giảm dần

Tương tự như trên, -1 sẽ cho kết quả giảm dần:

db.director.find().sort( { age: -1 })

Kết quả:

{_id: 1, name: "Steven Spielberg", age: 72, children: 6}
{ _id: 8, name: "Ron Howard", age: 65, children: 4}
{ _id: 4, name: "Jane Campion", age: 65, children: 2}
{ _id: 5, name: "David Fincher", age: 57, children: 1}
{ _id: 6, name: "Peter Jackson", age: 57, children: 2}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{_id: 2, name: "Christopher Nolan", age: 49, children: 4}

Sắp xếp với nhiều trường (Multiple Fields)

Để sắp xếp sử dụng nhiều trường, chỉ cần phân tách chúng bằng đấu ‘,’. Khi làm như vậy, kết quả sẽ được sắp xếp bởi trường đứng đầu, sau đó đến các trường phía sau,cứ thế theo thứ tự lần lượt.

Ở ví dụ dưới đây, chúng ta sẽ sort theo trường age và children, nếu hai hoặc nhiều director có cùng độ tuổi (age) thì số con cái (children )sẽ quyết định đến thứ tự sắp xếp:

db.director.find().sort( { age: 1, children: 1 } )

Kết quả:

{_id: 2, name: "Christopher Nolan", age: 49, children: 4}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 5, name: "David Fincher", age: 57, children: 1}
{ _id: 6, name: "Peter Jackson", age: 57, children: 2}
{ _id: 4, name: "Jane Campion", age: 65, children: 2}
{ _id: 8, name: "Ron Howard", age: 65, children: 4}
{_id: 1, name: "Steven Spielberg", age: 72, children: 6}

Chúng ta cùng xem thêm ví dụ tiếp theo để hiểu rõ hơn về ảnh hưởng của trường thứ 2 (children) đến thứ tự kết quả:

db.director.find().sort( { age: 1, children: -1 } )

Kết quả:

{_id: 2, name: "Christopher Nolan", age: 49, children: 4}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 6, name: "Peter Jackson", age: 57, children: 2}
{ _id: 5, name: "David Fincher", age: 57, children: 1}
{ _id: 8, name: "Ron Howard", age: 65, children: 4}
{ _id: 4, name: "Jane Campion", age: 65, children: 2}
{_id: 1, name: "Steven Spielberg", age: 72, children: 6}

Sắp xếp và giới hạn

Chúng ta cũng có thể sử dụng đồng thời cả sort()limit() trong cùng một câu lệnh:

db.director.find().limit(4).sort( { age: 1, children: 1 } )

Kết quả:

{_id: 2, name: "Christopher Nolan", age: 49, children: 4}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 5, name: "David Fincher", age: 57, children: 1}

Tham khảo: https://docs.mongodb.com/manual/reference/bson-type-comparison-order/ để hiểu thêm về cách so sánh kiểu trong MongoDB.

 

MongoDB

MongoDB: Giới hạn kết quả truy vấn

Trả về kết quả với số lượng dữ liệu mà chúng ta mong muốn với phương thức limit()

Trong MongoDB, phương thức limit() xác định số document lớn nhất có thể trả về.

Thêm limit() vào sau truy vấn khi sử dụng db.collection.find() để xác định giới hạn số lượng document.

Ví dụ

Đầu tiên, chúng ta sẽ thực hiện truy vấn mà không sử dụng limit() 

Không có limit()

db.cast.find( { movies: { $exists: false } } )

Kết quả:

{ "_id" : ObjectId("5780fbf948ef8c6b3ffb0149"), "name" : "Brad Pitt" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014a"), "name" : "Chris Evans" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014b"), "name" : "Margot Robbie" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014c"), "name" : "Leonardo DiCaprio" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014d"), "name" : "Jack Black" }

Có Limit()

db.cast.find( { movies: { $exists: false } } ).limit(4)

Kết quả:

{ "_id" : ObjectId("5780fbf948ef8c6b3ffb0149"), "name" : "Brad Pitt" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014a"), "name" : "Chris Evans" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014b"), "name" : "Margot Robbie" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014c"), "name" : "Leonardo DiCaprio" }
Trong câu truy vấn trên có sử dụng toán tử $exists để kiểm tra sự tồn tại của một trường (fields) nào đó. $exists có giá trị là kiểu Boolean. Ở ví dụ trên, chúng ta đặt giá trị cho nó là false, đồng nghĩ với việc loại bỏ những document mà có tồn tại trường movies.

Ngược lại. Nếu sử dụng {$exists: true} thì kết quả trả về chỉ bao gồm những document nào chứa trường movies.

Phương thức skip()

Có thể sử dụng phương thức skip(<number of documents>) để loại bỏ những document ở phía trước. Nói cách khác, chúng ta có thể kiểm soát được vị trí mà MongoDB bắt đầu trả về kết quả. ví dụ:

db.cast.find( { movies: { $exists: false } } ).limit(4).skip(1)

Kết quả:

{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014a"), "name" : "Chris Evans" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014b"), "name" : "Margot Robbie" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014c"), "name" : "Leonardo DiCaprio" }

Có thể thấy ngay, kết quả đầu tiên đã bị loại bỏ (.skip(1))

Loại bỏ nhiều hơn 1 document:

db.cast.find( { movies: { $exists: false } } ).limit(4).skip(3)

3 kết quả đầu tiên sẽ bị loại bỏ:

{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014c"), "name" : "Leonardo DiCaprio" }

 

 

MongoDB

MongoDB: Truy vấn với trường chỉ định

Truy vấn với trường chỉ định là loại truy vấn mà chúng ta chỉ rõ những trường (fields) nào sẽ được trả về.

Trong MongoDB, Khi truy vấn sử dụng phương thức db.collection.find(), chúng ta có thể chỉ định trường trả về. Bằng cách thêm tên trường vào câu truy vấn với giá trị là 1 hoặc 0. (1 là bao gồm, 0 là loại trừ).

Ví dụ

Trước tiên, hãy cùng xem khi không chỉ định trường trả về kết quả sẽ như thế nào

Không chỉ định trường trả về:

db.cast.find({name: "Matt Damon"})

Kết quả:

{  
   "_id":ObjectId("5781c9ac48ef8c6b3ffb014a"),
   name:"Matt Damon",
   age:48,
   movies:[  
      {  
         movie:"The Martian",
         year:2015,
         genre:"Drama"
      }      {  
         movie:"Good Will Hunting",
         year:1997,
         genre:"Drama"
      }
   ]
}

Chỉ định trường trả về:

db.cast.find({name: "Matt Damon"}, { name: 1 } )

Kết quả:

{  
   "_id":ObjectId("5781c9ac48ef8c6b3ffb014a"),
   name:"Matt Damon",
}

Bao gồm (Inclusions) và Loại trừ (Exclusions)

Chúng ta không thể sử dụng 10 với nhau trong cùng một câu truy vấn (ngoại trừ _id). MongoDB sẽ trả về lỗi:

db.cast.find({name: "Matt Damon"}, { name: 1,  age: 0 } )

Kết quả:

Error: error: {
  "waitedMS" : NumberLong(0),
  "ok" : 0,
  "errmsg" : "Projection cannot have a mix of inclusion and exclusion.",
  "code" : 2
}

Đối với _id thì khác:

db.cast.find({name: "Matt Damon"}, { name: 1, _id: 0 } )

Kết quả:

{ name:"Matt Damon" }

 

MongoDB

MongoDB: Truy vấn trong Collection

MongoDB cung cấp phương thức db.collection.find() để truy vấn các document thuộc collection đó.

Phương thức db.collection.find()  sẽ select các document trong collection và trả về một cursor

Lấy ra toàn bộ Documents

Ví dụ dưới đây sẽ trả về toàn bộ document của  director:

db.director.find()

kết quả

{_id: 1, name: "Steven Spielberg", age: 72, children: 6}
{_id: 2, name: "Christopher Nolan", age: 49, children: 4}
{ _id: 3, name: "Quentin Tarantino", age: 56, children: 0}
{ _id: 4, name: "Jane Campion", age: 65, children: 2}
{ _id: 5, name: "David Fincher", age: 57, children: 1}
{ _id: 6, name: "Peter Jackson", age: 57, children: 2}
{ _id: 7, name: "Michael Bay", age: 54, children: 0}
{ _id: 8, name: "Ron Howard", age: 65, children: 4}

Câu lệnh trên trả về toàn bộ document bởi vì chúng ta không thêm bất kì tham số nào để lọc dữ liệu.

câu truy vấn trên là rút gọn của db.cast.find( {} ). Việc bỏ đi dấu ngoặc {} là cú pháp hoàn toàn đúng trong MongoDB.

Lọc dữ liệu

Giống như where trong sql, MongoDB cũng cung cấp cách thức để lọc dữ liệu khi truy vấn:

db.cast.find({name: "Matt Damon"})

Kết quả:

{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014a"), name: "Matt Damon", age: 48, movies: [ { movie: "The Martian", year: 2015, genre: "Drama" } { movie: "Good Will Hunting", year: 1997, genre: "Drama" } ] }

Định dạng kết quả

Có thể thấy ngay klết quả vừa hiển thị ở bên trên rất khó quan sát. Phương thức pretty() sẽ định dạng kết quả bên trên giúp chúng ta dễ theo dõi hơn:

db.cast.find({name: "Matt Damon"}).pretty()

Kết quả:

{  
   "_id":ObjectId("5781c9ac48ef8c6b3ffb014a"),
   name:"Matt Damon",
   age:48,
   movies:[  
      {  
         movie:"The Martian",
         year:2015,
         genre:"Drama"
      }      {  
         movie:"Good Will Hunting",
         year:1997,
         genre:"Drama"
      }
   ]
}
Lưu ý: Kể từ giờ trở đi, kết quả của các câu truy vấn sẽ được để ở dạng pretty() để tiện theo dõi.

Các tùy chọn lọc (filtering)

Dưới đây là một số điều kiện lọc quen thuộc:

Điều kiện và (AND)

And được sử dụng khi chúng ta muốn lấy ra document mà thỏa mãn nhiều điều kiện khác nhau

Trong ví dụ dưới đây, chúng ta sẽ lọc ra các diễn viên có tuổi lớn hơn 40 và tham gia thể loại phim hoạt hình:

db.cast.find( { genre: "animation", age: { $gt: 40 } })

Kết quả:

{
  "_id" : ObjectId("578217c248ef8c6b3ffb015b"),
  name: "Keanu Reeves",
  age: 54,
  movies: [
    {
      movie: "John Wick: Chapter 3 – Parabellum",
      year: 2019,
      genre: "Action"
    }{
      movie: "Toy Story 4",
      year: 2019,
      genre: "Animation"
    }
  ]
},

Điều kiện hoặc (OR)

Khi chúng ta muốn kết quả thỏa mãi một trong các điều kiện đặt ra. điều kiện hoặc sẽ được sử dụng.

Câu lệnh dưới đây sẽ lấy ra các diễn viên có tuổi đời lớn hơn 50 hoặc đã tham gia thể loại phim drama:

db.cast.find(
  {
    $or: [ { genre: "drama" }, { age: { $gt: 50 } } ]
  }
)

Kết quả:

{  
   "_id":ObjectId("578217c248ef8c6b3ffb015a"),
   name:"Keanu Reeves",
   age:54,
   movies:[  
      {  
         movie:"John Wick: Chapter 3 – Parabellum",
         year:2019,
         genre:"Action"
      }      {  
         movie:"Toy Story 4",
         year:2019,
         genre:"Animation"
      }
   ]
}
{
 "_id":ObjectId("578217c248ef8c6b3ffb015b"),
  name: "Matt Damon",
  age: 48,
  movies: [
    {
      movie: "The Martian",
      year: 2015,
      genre: "Drama"
    }
    {
      movie: "Good Will Hunting",
      year: 1997,
      genre: "Drama"
    }
  ]
}

Toán tử $in

Toán tử $in trả về documents nếu chúng chứa bất kì giá trị nào nằm trong danh sách đã cho:

db.director.find( { name: { $in: [ "Quentin Tarantino", "Jane Campion" ] } } )

Kết quả :

{
  _id: 3,
  name: "Quentin Tarantino",
  age: 56,
  children: 0
},
{
  _id: 4,
  name: "Jane Campion",
  age: 65,
  children: 2
}.

Truy vấn mảng Document

Chúng ta sẽ truy vấn ra những diễn viên đóng các bộ phim trước năm 2014

db.cast.find(
  {
    movies: {
      $elemMatch: {
        year: { $lt: 2014 }    
      } 
    }
  }
)

Kết quả:

{
  "_id": ObjectId("578217c248ef8c6b3ffb015d"),
  name: "Matt Damon",
  age: 48,
  movies: [
    {
      movie: "The Martian",
      year: 2015,
      genre: "Drama"
    }{
      movie: "Good Will Hunting",
      year: 1997,
      genre: "Drama"
    }
  ]
}
{
  "_id": ObjectId("578217c248ef8c6b3ffb015c"),
  name: "Adam Sandler",
  age: 52,
  movies: [
    {
      movie: "50 First Dates",
      year: 2004,
      genre: "Romance"
    }{
      movie: "Murder Mystery",
      year: 2019,
      genre: "Mystery/Crime"
    }
  ]
}

Có thể thấy kết quả bên trên bao gồm cả những bộ phim năm 2019 và 2015. Điều này hoàn toàn đúng. Bởi vì câu truy vấn sẽ trả về toàn bộ nội dung của một document, nếu một phần tử của nó thỏa mãn điều kiện truy vấn (Trong trường hợp này là một mảng).

Phương thức db.collection.findOne()

Như tên gọi của nó. Phương thức này được sử dụng để láy ra chỉ một Document thỏa mãn điều kiện cho trước.

Trong trường hợp có nhiều Document thỏa mãn điều kiện, sẽ lấy ra phần tử đầu tiên tìm được.

db.director.findOne().pretty()

Sẽ chỉ trả về kết quả đầu tiên:

{
   _id: 2,
   name: "Christopher Nolan",
   age: 49,
  children: 4
 }

Nếu sử dụng find() thay vì findOne():

db.director.find().pretty()

Chúng ta sẽ thấy tất cả các Document được trả về:

{
  _id: 1,
  name: "Steven Spielberg",
  age: 72,
  children: 6
}
{
  _id: 2,
  name: "Christopher Nolan",
  age: 49,
  children: 4
},
{
  _id: 3,
  name: "Quentin Tarantino",
  age: 56,
  children: 0
},
{
  _id: 4,
  name: "Jane Campion",
  age: 65,
  children: 2
},
{
  _id: 5,
  name: "David Fincher",
  age: 57,
  children: 1
},
{
  _id: 6,
  name: "Peter Jackson",
  age: 57,
  children: 2
},
{
  _id: 7,
  name: "Michael Bay",
  age: 54,
  children: 0
},
{
  _id: 8,
  name: "Ron Howard",
  age: 65,
  children: 4
}

 

 

MongoDB

MongoDB: Tạo mới Document

MongoDB cung cấp phương thức insert() (và 2 cách nữa) cho việc thêm documents vào database.

MongoDB cung cấp ba phương thức sau để thêm dữ liệu vào db:

  • insert()
  • insertOne()
  • insertMany()

Phương thức insert()

insert() method thêm một hay nhiều document vào collection. Mỗi document là một tham số, giống như chúng ta đã làm ở bài trước:

db.collectionName.insert({name: "value"})

Ở ví dụ trên, document là {name: “value”}. Đây là môt định dạng JSON. Bao gồm một cặp key/value, và được đóng mở bằng dấu {}.

MongoDB sử dụng kiểu JSON để lưu trữ dữ liệu, cho nên insert documents sẽ ở dạng này:

db.cast.insert({name: "Chris Evans"})

Bây giờ, nếu chúng ta show collection cast, hai document sau sẽ xuất hiện:

> db.cast.find()
{ "_id" : ObjectId("5780fbf948ef8c6b3ffb0149"), "name" : "Brad Pitt" }
{ "_id" : ObjectId("5781c9ac48ef8c6b3ffb014a"), "name" : "Chris Evans" }

Trường _id mà MongoDB cung cấp có giá trị là  12 byte ObjectId. Được tạo nên theo cấu trúc sau:

  • 4 byte giá trị biểu thị số giây theo Unix epoch
  • 3 byte định danh máy
  • 2 byte process id
  • 3 byte bộ đếm,  được bắt đầu bằng một giá trị ngẫu nhiên

(Tham khảo https://mongodb.github.io/node-mongodb-native/2.0/tutorials/objectid/ để hiểu rõ hơn về ObjectId)

Tạo mutiple Documents

Chúng ta có thể insert nhiều documents với chỉ một phương thức insert().

Trong ví dụ này, chúng ta sẽ thêm 3 documents:

db.cast.insert([
  {name: "Margot Robbie"},
  {name: "Leonardo DiCaprio"},
  {name: "Jack Black"},
])

Lưu ý rằng documents được thêm bằng một mảng. Đóng mở ngoặc [], và được phân cách bằng dấu phẩy

Chạy đoạn code trên sẽ cho ra kết quả:

BulkWriteResult({
  "writeErrors" : [ ],
  "writeConcernErrors" : [ ],
  "nInserted" : 3,
  "nUpserted" : 0,
  "nMatched" : 0,
  "nModified" : 0,
  "nRemoved" : 0,
  "upserted" : [ ]
})

Embedded Documents

Documents có thể chứa các document khác, mảng hay là mảng các documents

db.cast.insert({
  name: "Matt Damon",
  age: 48,
  movies: [
    {
      movie: "The Martian",
      year: 2015,
      genre: "Drama"
    }
    {
      movie: "Good Will Hunting",
      year: 1997,
      genre: "Drama"
    }
  ]
})

Kết quả:

WriteResult({ "nInserted" : 1 })

Phương thức InsertOne()

Chúng ta có thể sử dụng insertOne() để thêm một document vào collection:

db.director.insertOne({_id: 1, name: "Steven Spielberg", age:  72, children: 6})

Embedded Documents

Cũng giống như insert(), chúng ta có thể lồng document:

db.cast.insert({
  name: "Matt Damon",
  age: 48,
  movies: [
    {
      movie: "The Martian",
      year: 2015,
      genre: "Drama"
    }{
      movie: "Good Will Hunting",
      year: 1997,
      genre: "Drama"
    }
  ]
})

Phương thức insertMany()

Giống như tên gọi của nó, chúng ta có thể sử dụng insertMany() để insert multiple documents:

db.director.insertMany([
  {
    _id: 2,
    name: "Christopher Nolan",
    age: 49,
    children: 4
  },
  {
    _id: 3,
    name: "Quentin Tarantino",
    age: 56,
    children: 0
  },
  {
    _id: 4,
    name: "Jane Campion",
    age: 65,
    children: 2
  }.
])

Kết quả đầu ra sẽ khác so với khi sử dụng insert():

{
  "acknowledged" : true,
  "insertedIds" : [
    2,
    3,
    4,
  ]
}

Embedded Documents

db.cast.insert({
  [
    {
      name: "Vanessa Kirby",
      age: 31,
      movies: [
        {
          movie: "Hobbs And Shaw",
          year: 2019,
          genre: "Action"
        }{
          movie: "Mission: Impossible – Fallout",
          year: 2018,
          genre: "Action"
        }
      ]
    },
    {
      name: "Keanu Reeves",
      age: 54,
      movies: [
        {
          movie: "John Wick: Chapter 3 – Parabellum",
          year: 2019,
          genre: "Action"
        }{
          movie: "Toy Story 4",
          year: 2019,
          genre: "Animation"
        }
      ]
    },
    {
      name: "Adam Sandler",
      age: 52,
      movies: [
        {
          movie: "50 First Dates",
          year: 2004,
          genre: "Romance"
        }{
          movie: "Murder Mystery",
          year: 2019,
          genre: "Mystery/Crime"
        }
      ]
    },
  ]
})

kết quả:

{
  "acknowledged": true,
  "insertedIds": [
    ObjectId("578217c248ef8c6b3ffb015a"),
    ObjectId("578217c248ef8c6b3ffb015b"),
    ObjectId("578217c248ef8c6b3ffb015c"),
  ]
}

 

MongoDB

MongoDB – tạo mới Collection

Chúng ta có thể tạo một collection bằng cách sử dụng method createCollection() hoặc chỉ đơn giản là insert document.

Collections giống như một containers dùng để chứa các documents có mối liên hệ. Ví dụ, có thể tồn tại các collection như users, food, post, music,…

Khi tạo ra database, chúng ta đã tạo một collection là cast . Collection này được dùng để lưu documents của các diễn viên. Ví dụ như tên diễn viên, tuổi, giới tính, quốc tịch,…

Hai cách để tạo mới Collection

dưới đây là 2 cách chúng ta có thể sử dụng đẻ tạo mới collection:

  • Tạo collection ngầm định sử dụng insert() method
  • Tạo collection tường minh sử dụng createCollection() method.

Tạo Collection ngầm định

Khi sử dụng insert() method, phải nêu rõ collection nào sẽ được insert dữ liệu vào. Trong trường hợp collection chưa tồn tại, nó sẽ được tạo mới.

Đây cũng là phương thức chúng ta đã được sử dụng ở bài trước để tạo ra cast collection:

db.cast.insert({name: "Brad Pitt"})

Trong trường hợp này, cast collection chưa tồn tại trước đó cho nên nó sẽ tự động được tạo mới.

Tạo Collection tường minh

Chúng ta cũng có thể tạo mới collections sử dụng createCollection() method. Phương thức này cho phép chúng ta tạo ra một collection rỗng mà chưa cần insert bất kì dữ liệu nào ngay lập tức:

db.createCollection("director")

Sử dụng Options

Ngoài ra, createCollection cũng có thêm các tùy chọn bằng cú pháp db.createCollection(name, options)

ví dụ:

db.createCollection("house", {capped: true, szie: 500000, max: 5400})

Tham khảo Docs MongoDB để tìm hiểu thêm các trường mà options cung cấp.

 

MongoDB

MongoDB – Tạo một database mới

Trong Mongo không có câu lệnh CREATE DATABASE giống như trong SQL. Thay vào đó, Database được tạo mới bằng cách đổi sang sử dụng một DB (Database)  chưa tồn tại và insert dữ liệu vào DB đó.

Để chuyển đổi giữa các DB bằng câu lệnh use. Nếu như DB đó chưa tồn tại, MongoDB sẽ tự động tạo mới:

use movies

sẽ được kết quả là:

switched to db movies

Tuy nhiên, Databases chưa thật sự được tạo nếu chúng ta không insert dữ liệu vào:

db.cast.insert({name: "Brad Pitt"})

Câu lệnh trên sẽ tạo ra một collection mới và insert dữ liệu vào đó.

Kết quả là:

WriteResult({"nInserted": 1})

Để list ra tất cả Database, chạy:

show databases

Output là:

local 0.000GB
admin 0.000GB
movies 0.000GB

3 Database được hiển thị, trong đó có movies mà chúng ta mới tạo ở trên

Chúng ta cũng có thể chạy lệnh sau để xem tất cả dữ liệu có trong DB:

db.cast.find()

Sẽ cho kết quả:

{ "_id" : ObjectId("5780fbf948ef8c6b3ffb0149"), "name" : "Brad Pitt" }

Như bạn có thể thấy, cặp giá trị name/value đã được lưu trong DB, MongoDB cũng sẽ tự động thêm trường _id cho chúng ta.

 

 

MongoDB

Truy cập MongoDB

Chúng ta có thể truy cập MongoDB thông qua MongoDB shell, hoặc bên trong môi trường programming bằng trình điều khiển MongoDB.

MongoDB Shell (mongo)

Trong suốt series hướng dẫn này chúng ta sẽ sử dụng MongoDB Shell để kết nối và chạy MongoDB. Mongo shell là một giao diện JavaScript tương tác được với Mongo và bao gồm các package của MongoDB. Có thể sử dụng Mongo Shell để truy vấn và cập nhật dữ liệu cũng như thực hiện các chức năng quản trị.

Để chạy MongoDB, mở terminal/command và chạy mongo (Mac/Linux) hay mongo.exe (Window).

Kết nối từ Programming Environment

Chúng ta cũng có thể kết nối tớ MongoDB bên trong môi trường lập trình.

Website của MongoDB hiển thị một danh sách MongoDB drivers được sử dụng để kết nối tới MongoDB. Bao gồm các ngôn ngữ sau:

  • C
  • C++ (legacy)
  • C++11
  • C#
  • Java
  • Node.js
  • Perl
  • PHP
  • Python
  • Motor
  • Ruby
  • Scala

Sau khi hoàn tất chạy mongo, chúng ta có thể tạo một database mới để bắt đầu làm việc.

Ngoài ra chúng ta còn có thể truy cập Mongodb thông qua Mongo Atlas.

Subscribe

A lead capture sample form