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 collections 或 show 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入门实战教程
本系列教程目录:
前面我们学习了聚合查询,本篇我们来看看在模型设计中如何应用引用模式来提高查询效率。
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