MongoDB使用手册

一. 前言

1.1 使用环境

os: win10, 64bit pro

database version: 6.x

compass version: 1.34.2

shell version: 1.6.0

mongodump version: 100.6.1

mongorestore version: 100.6.1

Terminal: Fluent Terminal(Powershell, 5.1.19041.2364)

1.2 安装简介

mongodb的主程序安装包除了server之外, 其他组件均不集成在一起, 需要单独下载, 包括shell在内.

mongodb assistance tools download url

解压后, 添加到环境变量即可.

1.3 图形管理工具

• compass, 这是mongodb官方版本的GUI管理工具, 免费.

  

• navicat premium, 一款极其强大的综合性数据库管理工具, 付费.

  

  相比于compass, navicat对于嵌套文档的显示效果更为直观.

二. 基本概要

3.1 BSON

BSON是一种计算机数据交换格式, 主要被用作MongoDB数据库中的数据存储和网络传输格式。它是一种二进制表示形式，能用来表示简单数.
据结构、关联数组（MongoDB中称为“对象”或“文档”）以及MongoDB中的各种数据类型。BSON之名缘于JSON，含义为Binary JSON（二进制JSON）

Bson 单文档的大小及嵌套限制

• 单文档不超过16 MB
• 嵌套不能超过100 层

如果单条记录超过 16 M 怎么办？

第一种办法：先处理后存储。可以先做压缩，或者也可以对字符进行先哈希，然后再存储，这样大概率就不会超过 16 MB。

第二种方法：通常来说 16 MB 的记录都可以直接写到文本文件里面，然后再将文件存到 MongoDB GridFS 里面或者先业务层处理后存储。

2.2 数据类型

2.3 ObjectID

ObjectId

ObjectIds are small, likely unique, fast to generate, and ordered. ObjectId values are 12 bytes in length, consisting of:

• A 4-byte timestamp, representing the ObjectId's creation, measured in seconds since the Unix epoch.
• A 5-byte random value generated once per process. This random value is unique to the machine and process.
• A 3-byte incrementing counter, initialized to a random value.

ObjectID是在插入数据到mongodb时默认生成的ID.

其的组成:

• 4-byte, 时间戳
• 5-byte, 随机生成数
• 3-byte, 递增数(在一个随机初始化的数开始递增)

'63ae59def83e2624ec87bb3c'.length;
// 24

三. 基本概况

3.1 Shell

We’ve decided to switch from v8 and java to Spider Monkey for JavaScript. - 官方blog

mongodb的shell整合了一个浏览器引擎(firefox, Spider Monkey).

这意味着可以直接在shell环境下执行JavaScript代码, 如同和在chrome console上.

# console.log()
'test'.length;

注: 注意执行后js代码将从控制台中移除.

// 直接在控制台执行复杂的js代码, 支持ES6+
const datas = [];
for (let i = 0; i < 10; i++) {
	const info = {
		'id': i,
		'name': 'abc'
	}
	datas.push(info);
}
// 批量插入条数据
// db.student.insertMany(datas);

实际上, mongodb和JavaScript的关系, 可以一定程度认为JavaScript是mongodb的脚本语言

// nodejs
const cursor = collection.find({});
await cursor.forEach(doc => console.log(doc));


// shell
// 创建一个游标
const mycursor = db.shop.find()
// 对游标获取的对象(obj)进行遍历(forEach)打印(printjson)
mycursor.forEach(function(obj){printjson(obj)})

注意: mongodb默认状态下, 是开放状态的, 连接是不需要密码和用户名的.

3.2 预置数据库

• admin: admin数据库主要是保存 root用户和角色。例如，system.users 表存储用户，system.roles 表存储角色。一般不建议用户直接操作这个数据库。将一个用户添加到这个数据库，且使它拥有 admin 库上的名为 dbAdminAnyDatabase 的角色权限，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如关闭服务器。
• local: local 数据库是不会被复制到其他分片的，因此可以用来存储本地单台服务器的任意 collection。一般不建议用户直接使用 local 库存储任何数据，也不建议进行 CRUD 操作，因为数据无法被正常备份与恢复。
• config: 当 MongoDB 使用分片设置时，config 数据库可用来保存分片的相关信息。

3.3 创建用户/安全管理

默认状态下, 使用的是已经内置创建的test数据库

# 管理员账户
use admin
db.createUser(
  {
    user: "myUserAdmin",
    pwd: passwordPrompt(), // or cleartext password
    roles: [
      { role: "userAdminAnyDatabase", db: "admin" },
      { role: "readWriteAnyDatabase", db: "admin" }
    ]
  }
)

# 普通账户
use test
db.createUser(
  {
    user: "myTester",
    pwd:  passwordPrompt(),   // or cleartext password
    roles: [ { role: "readWrite", db: "test" },
             { role: "read", db: "reporting" } ]
  }
)

• 参考连接
• users & roles

3.4 MySQL的对比

• 数据库, 依然还是数据库, database
• 表(Table), 则可以认为是转换成collection
• 行(row), 则可以认为转换成document
• index还是index
• 字段(column)勉强和field相对应

mongodb对于使用数据库/集合(表)的处理方式是, 当对应的数据存在时就访问, 当数据不存在时, 就临时创建, 假如不插入数据, 则临时文件会自动删除掉.

相比于MySQL需要在建库, 建表时需要各种考虑细节, mongodb可以开盖直接使用, 但是需要注意这种自由带来的数据混乱和不标准的问题.(特别是多人同时使用同一数据库时)

如果在具体执行中, 假如输入的内容错误(常见的拼写错误), 也不会报错.

例如:

这种问题也可以看到mongodb"自由"的代价.

db.students.insertMany()
# 而你的数据输入出现拼写错误或者是漏写/多写的错误, 也不会报错
db.student.insertMany()
# 将会直接创建对应名称的集合, 插入数据到这个集合

这需要在权限管理上进行限制, 以避免这种错误导致的数据混乱.

• 最佳实践| 一文读懂《MongoDB 使用规范及最佳实践》原理

3.5 基本命令

show dbs;
# 等价于mysql语句, 但同时也支持show databases;
# mysql
show databases;
# 查看集合
show collections;
# 删除数据库, 在当前数据库, 即可删除掉数据库
db.dropDatabase()
# 删除集合
db.collection.drop()
# 清空集合, 对应的集合将会自动回收(删除)
use db_name;
# 切换使用的数据库, 和mysql一样.

由于mongodb的字段(field)是不固定结构的, 所以并没有和MySQL与之对应的概念.

show full columns from table_name;
# 查看表的字段的情况

一些常用的管理命令

# 查看数据库的情况
db.stats();
# query, 返回具体的检索文档的数量
db.collection.countDocuments({?query});
# 查看数据库连接状态
db.serverStatus().connections
# 类似于netstat命令, 查看连接的状态

# 执行语句的解析
db.student.find({'id': 1}).explain();

其他命令

# command generates a list of all database commands implemented for the current mongod or mongos instance.
# 查看所有的命令
db.listCommands();
# 运行命令
# 查找student(collection_name), 过滤掉没有name的项, 返回两个结果
db.runCommand({"find":"student","filter":{"name":{$exists:true}},"limit" : 2});

四. 其他事项

4.1 游标

The following functions directly return cursors:

返回的是游标的函数

• Collection.find()
• Collection.aggregate()
• Collection.listIndexes()
• Db.aggregate()
• Db.listCollections()

Other methods such as Collection.findOne() and Collection.watch() use cursors internally, and return the results of the operations instead of a cursor.

c = collection.find()
print(c)
# <pymongo.cursor.Cursor at 0x217493afb80>
# find_one() 返回的是dict or None

4.2 索引

• db.collection.createIndex(keys, options, commitQuorum)

支持的索引类型

• 单个索引
• 复合索引
• 多键索引(基于数组来创建索引, 但是对于一个复合多键索引,「每个索引最多可以包含一个数组」)
• 地理空间索引(专门针对LBS信息检索的)
• 文本索引(全文检索, 不支持中文)
• Hashed索引

索引的特性

• 唯一索引(_id, 默认状态下的唯一索引)

• 部分索引(部分索引仅索引集合中符合指定过滤器表达式的文档, 如仅当某些数据大于某值时)

  # children 表中，将 age 大于 5 数据创建一个升序索引
  db.children.createIndex(
  {age:1},
  {partialFilterExpression: {age: {$gt:5}}})
  

• 稀疏索引

  索引的稀疏属性可确保索引仅包含具有索引字段的文档的条目。索引会跳过没有索引字段的文档。创建方式就是加上 sparse: true

  db.children.createIndex( { "age": 1 }, { sparse: true } )
  

• TTL索引(时效)

  TTL 索引是 MongoDB 可以使用的特殊索引，它可以在一定时间后自动从集合中删除文档.

  db.children.createIndex( { "lastModifiedDate": 1 }, { expireAfterSeconds: 5 } )
  

• 覆盖索引

  所有需要查询的数据都在索引当中，不需要从数据页中再去寻找数据

  # 简单理解, 就是索引即内容
  # 比如我此时为 children 表的时间创建了一个索引
  db.children.createIndex({ age : 1 })
  # 在此时我查找年龄为两岁的孩子时，就不需要从数据页中去寻找数据了
  db.children.find({ age : 2 })
  

• 前缀索引

  所有的前缀索引都可以被这条索引所覆盖，不需要再去针对这些前缀建立额外的索引，避免额外的开销
  比如我此时为 children 表的时间创建了「一个复合索引(多字段索引)」

  db.children.createIndex({ age : 1，name : 1，address : 1})
  # 等价于
  db.children.createIndex({ age : 1 })
  db.children.createIndex({ age : 1，name : 1 })
  db.children.createIndex({ age : 1，name : 1，address : 1})
  

常用索引命令/示例

图示: compass索引的创建

# 查看索引
db.student.getIndexes();
# 默认带有的索引是 "_id", 即数据库自带的
# 查看索引的大小
db.student.totalIndexSize();
# 删除所有的index
db.col.dropIndexes();
# 删除指定的索引
db.col.dropIndex("index_name")

# 创建单个索引
db.collection.createIndex({ id : 1 })
# 复合索引
db.collection.createIndex({ id : 1，name : 1 })
# 多键索引
db.collection.createIndex({"grades:math":1})

# -------------------------------------------------------   #
db.testindex2.insertMany([
{ id: 5, type: "food", item: "aaa", ratings: [ 5, 8, 9 ] },
{ id: 6, type: "food", item: "bbb", ratings: [ 5, 9 ] },
{ id: 7, type: "food", item: "ccc", ratings: [ 9, 5, 8 ] },
{ id: 8, type: "food", item: "ddd", ratings: [ 9, 5 ] },
{ id: 9, type: "food", item: "eee", ratings: [ 5, 9, 5 ] }
]);

下面基于ratings列创建一个多键索引:
db.testindex2.createIndex( { ratings: 1 } );

查询数组上为5, 9的文档
db.testindex2.find( { ratings: [ 5, 9 ] } );

下面查看其执行计划
db.testindex2.find( { ratings: [ 5, 9 ] } ).explain();
# 注意关键字: 「stage 为 IXSCAN」
{
  explainVersion: '1',
  queryPlanner: {
    namespace: 'test_db.testindex2',
    indexFilterSet: false,
    parsedQuery: { ratings: { '$eq': [ 5, 9 ] } },
    queryHash: 'E0BF65C3',
    planCacheKey: '2FB9799A',
    maxIndexedOrSolutionsReached: false,
    maxIndexedAndSolutionsReached: false,
    maxScansToExplodeReached: false,
    winningPlan: {
      stage: 'FETCH',
      filter: { ratings: { '$eq': [ 5, 9 ] } },
      inputStage: {
        stage: 'IXSCAN',
        keyPattern: { ratings: 1 },
        indexName: 'ratings_1',
        isMultiKey: true,
        multiKeyPaths: { ratings: [ 'ratings' ] },
        isUnique: false,
        isSparse: false,
        isPartial: false,
        indexVersion: 2,
        direction: 'forward',
        indexBounds: { ratings: [ '[5, 5]', '[[ 5, 9 ], [ 5, 9 ]]' ] }
      }
    },
    rejectedPlans: []
  },
  command: {
    find: 'testindex2',
    filter: { ratings: [ 5, 9 ] },
    '$db': 'test_db'
  },
  serverInfo: {
    host: 'DESKTOP-F6VO5U4',
    port: 27017,
    version: '6.0.2',
    gitVersion: '94fb7dfc8b974f1f5343e7ea394d0d9deedba50e'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600
  },
  ok: 1
}

4.2.1 索引的解析

图示: compass中的explain执行

常见的explain的内容解析

• 参考链接-A
• 参考链接_B

4.2.2 全文索引

需要注意的是全文索引, 并不支持中文

指定语言为全文索引

db.quotes.createIndex(
   { content : "text" },
   { default_language: "spanish" }
)

对于中文全文检索有较高要求的, 备用选择, MongoDB和Elasticsearch的各使用场景对比

4.2.3 索引限制

• 单个集合最多包含 64 个索引

• 单个索引记录不超过 1024 字节, failIndexKeyTooLong 默认 true 控制是否报错

• 多列索引列个数最多不超过 31

• 前台模式 createIndexes内存限制500 MB,（maxIndexBuildMemoryUsageMegabytes 可调整）

• 不允许创建多列数组的组合索引

实际上为什么有这个限制呢？

MongoDB 如果索引字段是数组，那我们可以理解为对每个数组元素创建索引。如果要是多个数组字段建组合索引，就意味着它可能会产生笛卡尔级数据量的索引。所以为了避免这种索引的爆炸性增长，需要对此做了相应的一个限制。

• TTL 索引如果是复合索引则过期将会失效

通常你想创建一个 TTL 索引，但创建的时候构建了多个字段的组合索引，那么 TTL 就会失效。

• Hash 索引只支持单列 [version <= 4.4]

另外需要记住的就是哈希索引只支持单例，这个是在 4.4 之前的一个限制，到后面是做了调整，所以在这里也需要给大家提一下。我们本次分享为大部分内容的前提是小于等于 4.2 版本，主要原因在于 4.4 及其以上的 MongoDB 版本其实有很多企业里面都没有使用。

4.3 时间

ISODate("2019-07-26T16:55:36.000Z")

时间在插入数据库后, 相应的时区会被修改为UTC00:00(Z)

# 在python中直接将字符串转为datetime
student = {
    'id': '2017010x',
    'name': 'Jordap',
    'age': 21,
    'gender': 'male',
    'data': datetime.strptime('2022-12-27 14:29:26', '%Y-%m-%d %H:%M:%S')
}

# 插入后检索数据
test_db> db.students.findOne({'id': '2017010x'});
{
  _id: ObjectId("63aaae7b995a3a30dffe2a7d"),
  id: '2017010x',
  name: 'Jordap',
  age: 21,
  gender: 'male',
  data: ISODate("2022-12-27T14:29:26.000Z")
}

# 注意日期
# 在pymongo中将数据导出
{'_id': ObjectId('63aaae7b995a3a30dffe2a7d'), 'id': '2017010x', 'name': 'Jordap', 'age': 21, 'gender': 'male', 'data': datetime.datetime(2022, 12, 27, 14, 29, 26)}

# 返回的date对象是不带有时区信息的

4.4 $操作符

$ (projection)

Definition

• $

  The positional $ operator limits the contents of an <array> to return the first element that matches the query condition on the array.Use $ in the projection document of the find() method or the findOne() method when you only need one particular array element in selected documents.See the aggregation operator $filter to return an array with only those elements that match the specified condition.

4.5 高阶操作

• 事务

  For transactions:

  • You can specify read/write (CRUD) operations on existing collections. For a list of CRUD operations, see CRUD Operations.

  • Starting in MongoDB 4.4, you can create collections and indexes in transactions. For details, see Create Collections and Indexes In a Transaction

  • The collections used in a transaction can be in different databases.

    NOTE

    You cannot create new collections in cross-shard write transactions. For example, if you write to an existing collection in one shard and implicitly create a collection in a different shard, MongoDB cannot perform both operations in the same transaction.

  • You cannot write to capped collections. (Starting in MongoDB 4.2)

  • You cannot use read concern "snapshot" when reading from a capped collection. (Starting in MongoDB 5.0)

  • You cannot read/write to collections in the config, admin, or local databases.

  • You cannot write to system.* collections.

  • You cannot return the supported operation's query plan (i.e. explain).

  • For cursors created outside of a transaction, you cannot call getMore inside the transaction.

  • For cursors created in a transaction, you cannot call getMore outside the transaction.

  • Starting in MongoDB 4.2, you cannot specify killCursors as the first operation in a transaction.

  Operations that affect the database catalog, such as creating or dropping a collection or an index, are not allowed in multi-document transactions. For example, a multi-document transaction cannot include an insert operati

• 连表查询

  和MySQL不同的是, mongodb并无联表查询的概念(提供有$lookup操作符来实现类似功能), 多是采用内嵌文档的方式实现.

• 分片

  在Mongodb里面存在另一种集群，就是分片技术,可以满足MongoDB数据量大量增长的需求。

  当MongoDB存储海量的数据时，一台机器可能不足以存储数据，也可能不足以提供可接受的读写吞吐量。这时，我们就可以通过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据。

  

  • Shard:

    用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障

  • Config Server:

    mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。

  • Query Routers:

    前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用可以透明使用。

• 技术干货| MongoDB 全方位知识图谱

五. 基本操作

mongodb在API接口上一般提供: 操作单个(One)文档; 操作多个(Many)文档. 在操作上直接做了区分, 更为方便易用.

5.1 增

• insertOne
• insertMany

# 单一内容插入
db.collection.insertOne({'id': 1, 'name': 'alex'}) 
# 批量插入内容
db.collection.insertMany([{'id': 1, 'name': 'alex'}, {'id': 2, 'name': 'tom'}])

5.2 删

• deleteOne
• deleteMany

# 批量删除id小于5的内容
db.student.deleteMany({"id":{$lt:5}});

5.3 改

db.collection.updateOne（filter，update，options）

• update
• updateOne
• replacceOne

db.student.updateOne({"id": 11}, {"gender" : "female"});
# MongoInvalidArgumentError: Update document requires atomic operators

mongodb为了防止意外的修改, 不允许直接覆盖式更新(上述内容可能只是想更新其中某个字段, 但是却会导致这个部分的文档被覆盖新的内容).

假如需要真的执行对文档的覆盖更新, 使用的式replaceOne

• 操作符, $set

# 整个文档覆盖更新
db.student.replaceOne({"id": 11}, {"gender" : "female"});
# 只更更新其中的项
db.student.updateOne({'id': 6}, {$set: {'name': 'alex'}});

• 操作符, $setOnInsert

$setOnInsert当数据不存在则写入, 当数据存在则不操作.

# 数据存在则更新, 不存在则写入
db.student.updateOne({'id': 7}, {$set: {'name': 'alex'}}, { upsert: true });

db.student.updateOne(
  { id: 31 },
  {
     $set: { item: "apple" },
     $setOnInsert: { defaultQty: 100 }
  },
  { upsert: true }
);

db.student.updateOne(
  { id: 31 },
  {
     $set: { item: "meta" },
     $setOnInsert: { defaultQty: 120 }
  },
  { upsert: true }
);

5.4 查

5.4.1 简单查询

• find
• findOne
• limit
• skip

# 返回id对应的所有项
db.collection_name.find({'id': 12345});
# 返回一条结果
db.collection_name.findOne({'id': 12345});
# 等价于
db.collection_name.find({'id': 12345}).limit(1);

# 只展示部分的字段, url_id
db.group.find({}, {'url_id': true});
# 展示除了url_id之外的其他的所有字段
db.group.find({}, {'url_id': false});

# 排序
# 查找具体项的最大值
# 不限于数字, 日期也可以
db.group.find().sort({'commentCount': -1}).limit(1)
# -1, 逆序
#  1, 正序


# 返回author_id的独一无二值
# db.collection.distinct(field, query, options)
db.group.distinct('author_id');
# 注意错误
# Error: distinct too big, 16mb cap
db.group.distinct('comments.author_id', {'url_id': '280793330'});

5.4.2 type

$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。

# 返回gender中数据类型为string的项
db.student.find({'gender': {$type: 2}})

5.4.3 条件(数学)操作符

{
    _id: ObjectId("63ac018e8ec05aca7ba5c922"),
    id: 10,
    name: 'tony',
    grades: { math: 12, english: 10 }
}
# 嵌套了一个字典层级
# 查找math下等于12的项目
db.student.findOne({'grades.math': 12});
# 查找math小于20的项目
db.student.find({'grades.math': {$lt: 20}});

5.4.4 复杂查询

常见操作符

# 查找多个项目
db.group.find({'url_id': {$in: ['102117210', '280826584']}})
# where
# 执行复杂的语句判断, 速度可能会受到影响
# 先判断name是否存在, 存在, 则返回name数组长度大于1的项
# 但是需要注意的是, 由于js中, 存在length属性的项并不止于数组, 字符串同样也有length, 
# 所以这种判断会同时返回满足要求的数据, 需要判断是否为数组isArray()
db.student.find({'name': {'$exists':true}, '$where':'this.name.length>=1'});

5.5 聚合

db.collection.aggregate(pipeline, options)

pipeline, 顾名思义, 管道, 数据通过在管道中逐级传递, 层层对数据进行处理, 用于返回需要经过复杂处理的数据.

注: pipeline的概念使用非常广泛, 如powerhell.

# 跳过前面2个文档
db.sales.aggregate({ $skip: 2 });
# 等价于
db.sales.find().skip(2);

# 相类似的
db.sales.find().limit(2);
# 等价于
db.sales.aggregate({ $limit: 2});

5.5.1 条件表达运算符

5.5.2 阶段操作符

5.5.3 $project

Passes along the documents with the requested fields to the next stage in the pipeline. The specified fields can be existing fields from the input documents or newly computed fields.

管道操作符, 用于传递字段的数据到下一环节

# 对返回结果的字段名称进行修改
db.students.aggregate([{ "$project": { "学生名称": "$name", "age": 1 }}]);
# $name, 在数据库中的字段的名称, name => 学生名称
[
  {
    _id: ObjectId("63a9585765f3c97e328cc915"),
    age: 20,
    '学生名称': 'Jordan'
  },
  {
    _id: ObjectId("63aaae7b995a3a30dffe2a7d"),
    age: 21,
    '学生名称': 'Jordap'
  }
]
# 控制返回的结果内容
db.students.aggregate([{ "$project": {  "age": 1 }}]);
# 将默认的_id字段也清除掉
db.students.aggregate([{ "$project": {  "age": 1, '_id': 0 }}]);
# 等价于
db.students.find({}, { "age": 1, '_id': 0 });

# ------------------------------------------------------------------------------- #


test_db> db.sales.insertMany([
... { "id" : 1, "item" : "abc", "price" : 10, "quantity" : 2, "date" : ISODate("2014-03-01T08:00:00Z") },
... { "id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1, "date" : ISODate("2014-03-01T09:00:00Z") },
... { "id" : 3, "item" : "xyz", "price" : 5, "quantity" : 10, "date" : ISODate("2014-03-15T09:00:00Z") },
... { "id" : 4, "item" : "xyz", "price" : 5, "quantity" : 20, "date" : ISODate("2014-04-04T11:21:39.736Z") },
... { "id" : 5, "item" : "abc", "price" : 10, "quantity" : 10, "date" : ISODate("2014-04-04T21:23:13.331Z") }
... ]);

# $multiply, 乘积
db.sales.aggregate([{ $project : { "id": 0, "item" : 1 , "price" : 1, "quantity": {"qty" : { "$multiply" :
["$quantity", 2] }} } }]);
# 注意这里出现的错误
# Invalid $project :: caused by :: Cannot do inclusion on field item in exclusion projection
# 没有开启_id:false，默认会生成ObjectId格式的_id，把0赋值给它会出错

# 没问题
db.sales.aggregate([{ $project : { "id": 1, "item" : 1 , "price" : 1, "quantity": {"qty" : { "$multiply" :
["$quantity", 2] }} } }]);
# 没问题
# qyt只是嵌套了别名
db.sales.aggregate([{ $project : { "_id": 0, "item" : 1 , "price" : 1, "quantity": {"qty" : { "$multiply" : ["$quantity", 2] }} } }]);

[
  { item: 'abc', price: 10, quantity: { qty: 4 } },
  { item: 'jkl', price: 20, quantity: { qty: 2 } },
  { item: 'xyz', price: 5, quantity: { qty: 20 } },
  { item: 'xyz', price: 5, quantity: { qty: 40 } },
  { item: 'abc', price: 10, quantity: { qty: 20 } }
]

db.sales.aggregate([{ $project : { "_id": 0, "item" : 1 , "price" : 1, "quantity": {"$multiply" : ["$quantity", 2] } } }]);
[
  { item: 'abc', price: 10, quantity: 4 },
  { item: 'jkl', price: 20, quantity: 2 },
  { item: 'xyz', price: 5, quantity: 20 },
  { item: 'xyz', price: 5, quantity: 40 },
  { item: 'abc', price: 10, quantity: 20 }
]
# total, 对返回字段重命名
db.sales.aggregate([{ $project : { "_id": 0, "item" : 1 , "price" : 1, "total": {"$multiply" : ["$quantity", 2] } } }]);

# 对 ["$quantity", "$price"] 两个字段进行运算
db.sales.aggregate([{ $project : { "_id": 0, "item" : 1 , "price" : 1, "total": {"$multiply" : ["$quantity", "$price"] } } }]);

5.5.4 其他操作示例

# 返回数组最长的两项
# Adds new fields to documents. 
# $addFields outputs documents that contain all existing fields from the input documents and newly added fields.
db.group.aggregate([
  { $addFields: { comments: { "$size": { "$ifNull": [ "$comments", [] ] } } } },
  { $sort: { comments: -1 } },
  { $limit: 2}
]);
# 等价于, 这两个添加字段的操作符是等价的
db.group.aggregate([
  { $set: { comments: { "$size": { "$ifNull": [ "$comments", [] ] } } } },
  { $sort: { comments: -1 } },
  { $limit: 2}
]);
# 验证结果的准确
db.group.aggregate([ { "$project" : { "count": { "$size": { "$ifNull": [ "$comments", [] ] } } } } ]).sort({'count': -1});
# 等价于
db.group.aggregate([
  { "$project" : { "count": { "$size": { "$ifNull": [ "$comments", [] ] } } } },
  { $sort: { "count": -1 } },
  { $limit: 2}
]);

db.test_a.insertMany([
{ "_id" : ObjectId("512bc95fe835e68f199c8686"), "author" : "dave", "score" : 80, "views" : 100 },
{ "_id" : ObjectId("512bc962e835e68f199c8687"), "author" : "dave", "score" : 85, "views" : 521 },
{ "_id" : ObjectId("55f5a192d4bede9ac365b257"), "author" : "ahn", "score" : 60, "views" : 1000 },
{ "_id" : ObjectId("55f5a192d4bede9ac365b258"), "author" : "li", "score" : 55, "views" : 5000 },
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b259"), "author" : "annT", "score" : 60, "views" : 50 },
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b25a"), "author" : "li", "score" : 94, "views" : 999 },
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b25b"), "author" : "ty", "score" : 95, "views" : 1000 }  
]);
# 先匹配score在70-90之间的, 亦或者views大于等于1000的
# group分组
db.test_a.aggregate( [
  { $match: { $or: [ { score: { $gt: 70, $lt: 90 } }, { views: { $gte: 1000 } } ] } },
  { $group: { _id: null, count: { $sum: 1 } } }
] );

group搭配的操作符

The <accumulator> operator must be one of the following accumulator operators:

group和distinct一个限制不能返回超过16M的数据

# 统计某个id出现的次数
db.group.aggregate({
	$group: {
		_id: "$author_id", 
		count: {$sum: 1}
	}
});

# 出现次数最多的项
db.group.aggregate([
	{$group: {_id: "$author_id", count: {$sum: 1}}},
	{$sort: {count: -1}},
	{$limit: 2}
]);

# 统计嵌套内容中某个项出现的次数

db.group.aggregate([
   {$unwind : "$comments"},
   {$group : { _id: "$comments.author_id", count: {$sum : 1}}},
   {$sort : {count: -1}},
   {$limit: 1}
]);

# 取出嵌套内容中的某个项对应的全部内容
db.group.aggregate([
	{$unwind : "$comments"},
	{$match: {'comments.author_id': '160661798'}},
	{$project: {'comments.comment': 1, _id: 0, title: 1}}
]);

六. 备份和恢复

mongorestore版本要和mongodump版本一致

mongodump --version
mongorestore --version

不管是文件的备份还是恢复, 均支持压缩的形式.

# 备份数据, 数据以bson文件存储
mongodump -h dbhost -d dbname -o dbdirectory  

mongodump -h localhost -d test_db -o 'C:\Users\Lian\Desktop\test_dump'

# 对文件进行压缩备份
mongodump -h localhost -d test_db -o "C:\Users\Lian\Desktop\test_dump" --gzip

# 恢复数据
mongorestore -h localhost "C:\Users\Lian\Desktop\test_dump"

参考连接

七. pymongo

注意: client = pymongo.MongoClient("mongodb://localhost:27017/"), 假如MongoDB service没有启动, 这一步并没有触发Exception.

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
# 等价于
client = pymongo.MongoClient(host="localhost",port=27017)
# client类似于mysql, connection

# 获取需要使用的database
db = client['db_name']
# client.database
# 访问集合
collection = db['collection_name']
# db.colllection
# 具体的操作
# 类似于mysql, cursor

cursor = collection.find(query_string)

# 聚合操作
'''
cl.aggregate(

    pipeline: Sequence[Mapping[str, Any]],
    session: Optional[ForwardRef('ClientSession')] = None,
    let: Optional[Mapping[str, Any]] = None,
    comment: Optional[Any] = None,
    **kwargs: Any,
) -> pymongo.command_cursor.CommandCursor[~_DocumentType]
'''
data = cl.aggregate([{ "$skip": 2 }]);
data
# <pymongo.command_cursor.CommandCursor at 0x1cd7e2d43d0>

pipe = [
   {'$unwind' : "$comments"},
   {'$group' : { '_id': "$comments.author_id", 'count': {'$sum' : 1}}},
   {'$sort' : {'count': -1}},
   {'$limit': 1}
]
data = cl.aggregate(pipeline=pipe)

cl.estimated_document_count()
# 返回文档的数量

# 注意排序的参数, 并不是{}
# 顺序参数
# 两个常量
# pymongo.DESCENDING, -1
# pymongo.ASCENDING, 1
data = cl.find().sort('price', -1)

# 关闭退出
client.close()

• API Documentation — PyMongo 4.3.3 documentation