MongoDB 使用教程

Posted 路遥万里

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了MongoDB 使用教程相关的知识,希望对你有一定的参考价值。

文章目录

MongoDB的使用

数据库操作

一个mongodb中可以建立多个数据库。
MongoDB的默认数据库为"test",该数据库存储在data目录中。
MongoDB的单个实例可以容纳多个独立的数据库,每一个都有自己的集合和权限,不同的数据库也放置在不同的文件中。

show dbs

#显示所有数据的列表

> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB

这些数据库名是保留的,可以直接访问这些有特殊作用的数据库。

  • admin: 从权限的角度来看,这是"root"数据库。要是将一个用户添加到这个数据库,这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行,比如列出所有的数据库或者关闭服务器。
  • local: 这个数据永远不会被复制,可以用来存储限于本地单台服务器的任意集合
  • config: 当Mongo用于分片设置时,config数据库在内部使用,用于保存分片的相关信息。

db

#显示当前数据库对象或集合
> db
test

use

#连接到一个指定的数据库,没有则创建
> use local
local

use可创建数据库

> use mydb
switched to db mydb
> db
mydb
> show dbs  #只有当真正有文档数据写入时才会显示
admin   0.000GB
config  0.000GB
local   0.000GB

可以看到,我们刚创建的数据库 mydb并不在数据库的列表中, 要显示它,我们需要向 mydb 数据库插入一些数据。

> db.mydb.insert("name":"goudan")   #mydb是集合名称,没有则会自动创建
WriteResult( "nInserted" : 1 )
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
mydb    0.000GB

db.dropDatabase()删除当前数据库

#删除当前数据库,默认为 test,可以使用 db 命令查看当前数据库名
> db
mydb
> db.dropDatabase()
 "dropped" : "mydb", "ok" : 1 
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
> db   #任然在当前mydb中
mydb

集合操作

集合就是 MongoDB 文档组,类似于 RDBMS (关系数据库管理系统:Relational Database Management System)中的表格。

集合存在于数据库中,集合没有固定的结构,这意味着你在对集合可以插入不同格式和类型的数据,但通常情况下我们插入集合的数据都会有一定的关联性。

如我们可以将以下不同数据结构的文档插入到集合中:

"id":1
"id":1,"name":"goudan"
"id":1,"name":"goudan", "address":"beijing"

当第一个文档插入时,集合就会被创建。

db.createCollection(name, options)

参数说明:

  • name: 要创建的集合名称
  • options: 可选参数, 指定有关内存大小及索引的选项。options 如下参数:
    在插入文档时,MongoDB 首先检查固定集合的 size 字段,然后检查 max 字段。
字段类型描述
capped布尔(可选)如果为 true,则创建固定集合。固定集合是指有着固定大小的集合,当达到最大值时,它会自动覆盖最早的文档。 当该值为 true 时,必须指定 size 参数。
autoIndexId布尔3.2 之后不再支持该参数。(可选)如为 true,自动在 _id 字段创建索引。默认为 false。
size数值(可选)为固定集合指定一个最大值,即字节数。 如果 capped 为 true,也需要指定该字段。
max数值(可选)指定固定集合中包含文档的最大数量。
> use mydb
switched to db mydb
> db.createCollection("test")
 "ok" : 1 
> db.createCollection("myTbl",  capped : true, autoIndexId : true, size:6142800, max : 10000 )

	"note" : "The autoIndexId option is deprecated and will be removed in a future release",
	"ok" : 1

show collectionsshow tables

> show collections
myTable
myTbl

db.collection.drop()

#如果成功删除选定集合,则 drop() 方法返回 true,否则返回 false。
> db.myTbl.drop()
true

文档操作

1. 文档介绍

文档的数据结构和 JSON 基本一样。
所有存储在集合中的数据都是 BSON 格式。
BSON 是一种类似 JSON 的二进制形式的存储格式,是 Binary JSON 的简称。
文档是一组键值(key-value)对(即 BSON),一个简单的文档例子如下:

"id":1,"name":"goudan", "address":"beijing"

2. MongoDB 数据类型

下表为MongoDB中常用的几种数据类型。

数据类型描述
String字符串。存储数据常用的数据类型。在 MongoDB 中,UTF-8 编码的字符串才是合法的。
Integer整型数值。用于存储数值。根据你所采用的服务器,可分为 32 位或 64 位。
Boolean布尔值。用于存储布尔值(真/假)。
Double双精度浮点值。用于存储浮点值。
Min/Max keys将一个值与 BSON(二进制的 JSON)元素的最低值和最高值相对比。
Array用于将数组或列表或多个值存储为一个键。
Timestamp时间戳。记录文档修改或添加的具体时间。
Object用于内嵌文档。
Null用于创建空值。
Symbol符号。该数据类型基本上等同于字符串类型,但不同的是,它一般用于采用特殊符号类型的语言。
Date日期时间。用 UNIX 时间格式来存储当前日期或时间。你可以指定自己的日期时间:创建 Date 对象,传入年月日信息。
Object ID对象 ID。用于创建文档的 ID。
Binary Data二进制数据。用于存储二进制数据。
Code代码类型。用于在文档中存储 javascript 代码。
Regular expression正则表达式类型。用于存储正则表达式。

ObjectId

ObjectId 类似唯一主键,可以很快的去生成和排序,包含 12 bytes,含义是:

  • 前 4 个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间,比北京时间晚了 8 个小时
  • 接下来的 3 个字节是机器标识码
  • 紧接的两个字节由进程 id 组成 PID
  • 最后三个字节是随机数

MongoDB 中存储的文档必须有一个 _id 键。这个键的值可以是任何类型的,默认是个 ObjectId 对象

由于 ObjectId 中保存了创建的时间戳,所以你不需要为你的文档保存时间戳字段,你可以通过 getTimestamp 函数来获取文档的创建时间:

> var newObject = ObjectId()
> newObject.getTimestamp()
ISODate("2022-05-10T10:17:55Z")

ObjectId 转为字符串

> newObject.str
62a46bd34c256eb2b320f207

3. 插入文档

MongoDB 使用 insert() 或 save() 方法向集合中插入文档,语法如下:

db.COLLECTION_NAME.insert(document)
或
db.collection.insertOne() 和 db.collection.insertMany()   #3.2 版本之后新增
或
db.COLLECTION_NAME.save(document)
  • save():如果 _id 主键存在则更新数据,如果不存在就插入数据。该方法新版本中已废弃,可以使用 db.collection.insertOne()db.collection.replaceOne() 来代替。
  • insert(): 若插入的数据主键已经存在,则会抛 org.springframework.dao.DuplicateKeyException 异常,提示主键重复,不保存当前数据。

db.collection.insertMany() 用于向集合插入一个新文档,语法格式如下:

db.collection.insertMany(
   [ <document 1> , <document 2>, ... ],   -- insertOne()时这儿就一个文档,不需要数组即可
   
      writeConcern: <document>,
      ordered: <boolean>
   
)

参数说明:

  • document:要写入的文档。
  • writeConcern:写入策略,默认为 1,即要求确认写操作,0 是不要求。
  • ordered:指定是否按顺序写入,默认 true,按顺序写入。

案例

-- myTable中添加1个文档
> db.myTable.insert("id":1,"name":"goudan", "address":"beijing")
WriteResult( "nInserted" : 1 )

-- myTable中添加1个文档
> db.myTable.insertOne("id":2,"name":"mz", "address":"beijing")

	"acknowledged" : true,
	"insertedId" : ObjectId("62a46e194c256eb2b320f209")


-- myTable中添加2个文档
> db.myTable.insertMany(["id":3,"name":"shanjige", "address":"beijing","id":4,"name":"haonan", "address":"jianshazui"])

	"acknowledged" : true,
	"insertedIds" : [
		ObjectId("62a46e644c256eb2b320f20a"),
		ObjectId("62a46e644c256eb2b320f20b")
	]


-- myTable中添加1个文档
> db.myTable.save("id":5,"name":"renzha", "address":"tangshan")
WriteResult( "nInserted" : 1 )

> db.myTable.find()
 "_id" : ObjectId("62a46dee4c256eb2b320f208"), "id" : 1, "name" : "goudan", "address" : "beijing" 
 "_id" : ObjectId("62a46e194c256eb2b320f209"), "id" : 2, "name" : "mz", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "shanjige", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20b"), "id" : 4, "name" : "haonan", "address" : "jianshazui" 
 "_id" : ObjectId("62a46eae4c256eb2b320f20c"), "id" : 5, "name" : "renzha", "address" : "tangshan" 

4. MongoDB更新文档

MongoDB 使用 update()save() 方法来更新集合中的文档。

update() 更新

db.collection.update(
   <query>,
   <update>,
   
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   
)

参数说明:

  • query : update的查询条件,类似sql update查询内where后面的。
  • update : update的对象和一些更新的操作符(如 , , ,inc…)等,也可以理解为sql update查询内set后面的
  • upsert : 可选,这个参数的意思是,如果不存在update的记录,是否插入objNew,true为插入,默认是false,不插入。
  • multi : 可选,mongodb 默认是false,只更新找到的第一条记录,如果这个参数为true,就把按条件查出来多条记录全部更新。
  • writeConcern :可选,抛出异常的级别。
-- 更新name值shanjige为sjg
> db.myTable.update("name":"shanjige",$set:"name":"sjg")
WriteResult( "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 )

save() 更新
save() 方法通过传入的文档来替换已有文档,_id 主键存在就更新,不存在就插入。语法格式如下:

db.collection.save(
   <document>,
   
     writeConcern: <document>
   
)

参数说明:

  • document : 文档数据。
  • writeConcern :可选,抛出异常的级别。
-- 更新文档name值renzha为rz
> db.myTable.save( "_id" : ObjectId("62a46eae4c256eb2b320f20c"), "id" : 5, "name" : "rz", "address" : "tangshan" )
WriteResult( "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 )

-- 格式化查询myTable所有数据
> db.myTable.find().pretty()

	"_id" : ObjectId("62a46dee4c256eb2b320f208"),
	"id" : 1,
	"name" : "goudan",
	"address" : "beijing"


	"_id" : ObjectId("62a46e194c256eb2b320f209"),
	"id" : 2,
	"name" : "mz",
	"address" : "beijing"


	"_id" : ObjectId("62a46e644c256eb2b320f20a"),
	"id" : 3,
	"name" : "sjg",
	"address" : "beijing"


	"_id" : ObjectId("62a46e644c256eb2b320f20b"),
	"id" : 4,
	"name" : "haonan",
	"address" : "jianshazui"


	"_id" : ObjectId("62a46eae4c256eb2b320f20c"),
	"id" : 5,
	"name" : "rz",
	"address" : "tangshan"

5. MongoDB 查询文档

MongoDB 查询文档使用 find() 方法。find() 方法以非结构化的方式来显示所有文档。find()查询数据的语法格式如下:

db.collection.find(query, projection)[.pretty()]
  • query :可选,使用查询操作符指定查询条件
  • projection :可选,使用投影操作符指定返回的键。查询时返回文档中所有键值, 只需省略该参数即可(默认省略)。
  • .pretty() : 美化查询结果。
  • 除find()外,还有findOne() 方法,它只返回一个文档。

MongoDB 与 RDBMS Where 语句比较

MongoDB与常规的 SQL 数据条件查询类似,通过下表可以更好的理解 MongoDB 的条件语句查询:

操作格式范例RDBMS中的类似语句
等于<key>:<value>db.col.find("by":"goudan").pretty()where by = 'goudan'
小于<key>:$lt:<value>db.col.find("likes":$lt:50).pretty()where likes < 50
小于或等于<key>:$lte:<value>db.col.find("likes":$lte:50).pretty()where likes <= 50
大于<key>:$gt:<value>db.col.find("likes":$gt:50).pretty()where likes > 50
大于或等于<key>:$gte:<value>db.col.find("likes":$gte:50).pretty()where likes >= 50
不等于<key>:$ne:<value>db.col.find("likes":$ne:50).pretty()where likes != 50

MongoDB and条件

MongoDB 的 find() 方法可以传入多个键(key),每个键(key)以逗号隔开,即常规 SQL 的 AND 条件。

>db.col.find(key1:value1, key2:value2).pretty()

MongoDB OR 条件

MongoDB OR 条件语句使用了关键字 $or,

>db.col.find(
   
      $or: [
         key1: value1, key2:value2
      ]
   
).pretty()

查询案例

-- 查询myTable所有数据
> db.myTable.find()
 "_id" : ObjectId("62a46dee4c256eb2b320f208"), "id" : 1, "name" : "goudan", "address" : "beijing" 
 "_id" : ObjectId("62a46e194c256eb2b320f209"), "id" : 2, "name" : "mz", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "sjg", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20b"), "id" : 4, "name" : "haonan", "address" : "jianshazui" 
 "_id" : ObjectId("62a46eae4c256eb2b320f20c"), "id" : 5, "name" : "rz", "address" : "tangshan" 

-- 查询myTable name=sjg的数据
> db.myTable.find("name":"sjg")
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "sjg", "address" : "beijing" 

-- 查询myTable name=sjg and address=beijing的数据
> db.myTable.find("name":"sjg","address":"beijing")
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "sjg", "address" : "beijing" 

-- 查询myTable name = sjg or address=beijing的数据
> db.myTable.find($or:["name":"sjg","address":"beijing"])
 "_id" : ObjectId("62a46dee4c256eb2b320f208"), "id" : 1, "name" : "goudan", "address" : "beijing" 
 "_id" : ObjectId("62a46e194c256eb2b320f209"), "id" : 2, "name" : "mz", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "sjg", "address" : "beijing" 

-- 查询myTable id > 1 and (name=sjg or address=beijing)的数据
> db.myTable.find("id":$gt:1,$or:["name":"sjg","address":"beijing"])
 "_id" : ObjectId("62a46e194c256eb2b320f209"), "id" : 2, "name" : "mz", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "sjg", "address" : "beijing" 

-- 查询myTable第一条数据
> db.myTable.findOne()

	"_id" : ObjectId("62a46dee4c256eb2b320f208"),
	"id" : 1,
	"name" : "goudan",
	"address" : "beijing"


-- 查询myTable满足name=sjg or address=beijing条件的第一条数据
> db.myTable.findOne($or:["name":"sjg","address":"beijing"])

	"_id" : ObjectId("62a46dee4c256eb2b320f208"),
	"id" : 1,
	"name" : "goudan",
	"address" : "beijing"

6. 文档删除

官方推荐使用 deleteOne() 和 deleteMany() 方法。

删除 name 等于 sjg 的全部文档:

> db.myTable.deleteMany( name : "sjg" )
 "acknowledged" : true, "deletedCount" : 1 

删除 name 等于 gouda的一个文档:

> db.myTable.deleteOne(  name: "goudan"  )
 "acknowledged" : true, "deletedCount" : 1 

> db.myTable.find()
 "_id" : ObjectId("62a46e194c256eb2b320f209"), "id" : 2, "name" : "mz", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20b"), "id" : 4, "name" : "haonan", "address" : "jianshazui" 
 "_id" : ObjectId("62a46eae4c256eb2b320f20c"), "id" : 5, "name" : "rz", "address" : "tangshan" 

如删除集合下全部文档:

> db.myTable.deleteMany()
 "acknowledged" : true, "deletedCount" : 3 
> db.myTable.find()
> db.myTable.count()
0

MongoDB中limit和skip

MongoDB Limit() 方法
如果你需要在MongoDB中读取指定数量的数据记录,可以使用MongoDB的Limit方法,limit()方法接受一个数字参数,该参数指定从MongoDB中读取的记录条数。limit()方法基本语法如下所示:

>db.COLLECTION_NAME.find().limit(NUMBER)

MongoDB Skip() 方法

我们除了可以使用limit()方法来读取指定数量的数据外,还可以使用skip()方法来跳过指定数量的数据,skip方法同样接受一个数字参数作为跳过的记录条数。skip() 方法脚本语法格式如下:

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)  -- skip默认数量为0

查询案例

> db.myTable.find().limit(2)
 "_id" : ObjectId("62a46dee4c256eb2b320f208"), "id" : 1, "name" : "goudan", "address" : "beijing" 
 "_id" : ObjectId("62a46e194c256eb2b320f209"), "id" : 2, "name" : "mz", "address" : "beijing" 
> db.myTable.find().limit(2).skip(2)
 "_id" : ObjectId("62a46e644c256eb2b320f20a"), "id" : 3, "name" : "sjg", "address" : "beijing" 
 "_id" : ObjectId("62a46e644c256eb2b320f20b"), "id" : 4, "name" : "haonan", "address" : "jianshazui" 

聚合查询

MongoDB 中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等),并返回计算后的数据结果。
有点类似 SQL 语句中的 count(*)
aggregate() 方法

MongoDB中聚合的方法使用aggregate()。aggregate() 方法的基本语法格式如下所示:

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

查询案例

-- 根据address过滤,统计每个城市人数
> db.myTable.aggregate([$group : _id : "$address", addr_users : $sum : 1])
 "_id" : "tangshan", "addr_users" : 1 
 "_id" : "jianshazui", "addr_users" : 1 
 "_id" : "beijing", "addr_users" : 3 

-- 查询总的数据条数
> db.myTable.count()
5

MongoDB入门实战教程

本系列教程目录:

MongoDB入门实战教程(1)

MongoDB入门实战教程(2)

MongoDB入门实战教程(3)

MongoDB入门实战教程(4)

MongoDB入门实战教程(5)

MongoDB入门实战教程(6)

前面我们学习了聚合查询,本篇我们来看看在模型设计中如何应用引用模式来提高查询效率。

1内嵌模式

在进行MongoDB的模型设计中,基于JSON文档模型,我们很容易就可以设计出一个内嵌模式的文档模型出来。

可以不夸张地说,80%~90%的场景下,我们优先都会使用内嵌对象 或 内嵌数组 的方式来设计文档模型的所谓的1-1、1-N、N-N的关系

例如下面这个Contacts的文档模型,它描述了一个联系人的关系建模:

Contacts

{
  name: "Edison Zhou",
  company: "CSCEC YZW",
  title: ".NET Engineer",
  portraits: {
    mimetype: xxx,
    data: xxxx
  },
  addresses: [
    { type: home, … },
    { type: work, … }
  ],
  groups: [
    {name: "YZW Football Assocation" },
    {name: "YZW .NET Assocation" }
  ]
}

可以看到,所谓的内嵌类 其实 类似于 预先聚合(关联)这样的操作(引用+冗余)其实对读操作更有性能优势

但是,内嵌设计有一个大前提限制:即内嵌后文档大小不能超过16MB。

此外,如果内嵌的数组(通常是数组)的长度太大,比如数万或更多的时候,也是不适合采用内嵌模式的。

那么,此时我们应该怎么设计呢?

2 引用模式

万级长度的内嵌数组

这里我们仍然适用上面提到的Contacts模型,假设其中的groups是一个内嵌数组,这个groups的数据可能有百万级的长度,且每个Contacts文档都需要冗余这么一份数据,而且groups数据还面临着频繁修改的需求。

Contacts

{
  name: "Edison Zhou",
  company: "CSCEC YZW",
  title: ".NET Engineer",
  ......
  // 假设下面groups有百万级,且一个group的信息改动会引发百万级的DB操作
  groups: [
    {name: "YZW Football Assocation" },
    {name: "YZW .NET Assocation" }
  ]
}

适当使用引用模式解决

解决方案很简单,就是针对groups使用单独的collection来存储,在Contancts模型中添加对group id的集合的引用。

Collection 1 - Contacts:

Contacts

{
  name: "Edison Zhou",
  company: "CSCEC YZW",
  title: ".NET Engineer",
  ......
  // 假设下面groups有百万级,且一个group的信息改动会引发百万级的DB操作
  group_ids: [1,2,3,4,5...]
}

Collection 2 - Groups:

Groups

{
  groups_id,
  name
}

这样的设计其实类似于关系型数据库模型的设计,用Id来关联,我们再熟悉不过了。

但是,在MQL中,我们就需要额外使用$lookup来实现类似SQL中的关联查询了,严格来说,应该算是LEFT OUTER JOIN查询。

嗯,这又是一种聚合操作:

db.Contacts.aggregate([
{
  $lookup:
  {
    from: "groups",
    localField: "group_ids",
    foreignField: "group_id",
    as: "groups"
  }
}]);

这个查询会得到如下图所示的结果:

.NET中的Lookup操作:

上面讲解了如何通过MQL进行操作,那么,在.NET中如何实现$lookup的效果呢?

好在MongoDB Driver已经帮我们提供了这样的一个LookUp,且看下面的代码示例:

假设我们的实体定义如下:

public class Contact
{
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }

    public string Name { get; set; }

    public string Company { get; set; }

    public string Title { get; set; }

    public int[] GroupIds { get; set; }

    public IList<Group> Groups { get; set; }
}

public class Group
{
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }

    public int GroupId { get; set; }

    public string Name { get; set; }
}

那么,可以通过Driver实现以下操作:

public async Task<IList<Contact>> GetAsync()
{
    return await _contacts
        .Aggregate()
        .Lookup<Contact, Group, Contact>(
            _groups,
            local => local.GroupIds,
            from => from.GroupId,
            result => result.Groups)
        .ToListAsync();
}

完整示例github地址:https://github.com/EdisonChou/EDT.Mongo.Sample

运行结果如下所示:

什么时候使用引用模式

综上所述,当满足以下条件之一时,你可以开始考虑引用模式设计文档模型:

(1)当内嵌后的文档太大,有可能超过16MB限制的时候;

(2)内嵌的文档 或 数组元素 有可能会频繁修改的时候;

(3)内嵌数组元素 有可能会持续增长且没有封顶的时候;

引用模式设计的限制

引用模式也并非银弹,它存在以下一些限制:

(1)MongoDB对于使用引用的集合之间没有所谓的外键检查;

(2)MongoDB使用聚合框架的$lookup来模仿关联查询;

(3)$lookup只支持LEFT OUTER JOIN,且关联目标(from)不能是分片表;

db.Contacts.aggregate([
{
  $lookup:
  {
    from: "groups", // 这里的from不能是分片表
    ......
  }
}]);

总结

本文简单介绍了MongoDB的模型设计中的内嵌模式和引用模式,探讨了引用模式的使用、何时使用 及 使用限制。

下一篇,我们会学习MongoDB的模式设计中的一些设计模式并套用这些设计模式简化设计难度。

参考资料

唐建法,《MongoDB高手课》(极客时间)

郭远威,《MongoDB实战指南》(图书)

△推荐订阅学习

 

以上是关于MongoDB 使用教程的主要内容,如果未能解决你的问题,请参考以下文章

MongoDB--》MongoDB数据库以及可视化工具的安装与使用—保姆级教程

MongoDB最简单的入门教程之五-通过Restful API访问MongoDB

《MongoDB入门教程》第01篇 MongoDB简介

MongoDB和MongoDB Compass的安装配置教程

MongoDB快速入门教程 (4.1)

《MongoDB入门教程》第04篇 MongoDB客户端