MongoDB

创立数据库

- 格局：use DATABASE_NAME
    - use ruochen
    - db

创立数据库须要插入一条数据才会在列表中显示

    - db.ruochen.insert({'name': '若尘'})
    - show dbs

删除数据库

• 格局：db.dropDatabase()

  • use ruochen
  • db.dropDatabase()
  • show dbs

创立汇合

- 格局：db.createCollection(name, options)
- name: 要创立的汇合名称
- options: 可选参数，指定无关内存大小及索引的选项

在插入文档时，MongoDB 首先查看固定汇合的 size 字段，而后查看 max 字段

实例
# 在 test 数据库中创立 ruochen 汇合
use test
db.createCollection('ruochen')
# 查看已有汇合
show collections

db.createCollection('test', {capped: true, autoIndexId: true, size: 1024000, max: 10000})  # autoIndexId 已弃用，默认_id 增加索引

# 插入文档时，MongoDB 会主动创立汇合
db.ruochen.insert({'name': 'ruochen'})

删除汇合

• 格局：db.collection.drop()

  • use ruochen
  • db.createCollection(‘ruochen’) # 创立汇合
  • show tables
  • db.ruochen.drop()
  • show tables

插入文档

• 格局：db.COLLECTION_NAME.insert(document)

  • 办法 1
  • db.ruochen.insert({title: ‘MongoDB 教程 ’,

  description: ‘shu ju ku’,
  by: ‘ruochen’,
  tags: [‘mongodb’, ‘database’, ‘NoSQL’]
  })

  • db.ruochen.find()
  • 办法 2
  • document=({title: ‘mongodb’,

  description: ‘shu ju ku’,
  by: ‘ruochen’,
  tags: [‘mongodb’, ‘database’, ‘NoSQL’]
  })

  • db.ruochen.insert(document)
  • db.ruochen.find()
• db.collection.insertOne() # 向指定汇合中插入一条文档数据

• db.collection.insertMany() # 向指定汇合中插入多条文档数据

  • var document = db.ruochen.insertOne({“e”: 3})
  • document
  • var res = db.ruochen.insertMany([{‘a’: 1}, {‘b’: 2}])
  • res

• 一次插入多条数据

  • 先创立数组
  • 将数据放在数据中
  • 一次 insert 到汇合中

  • 案例

    • var arr = [];
    • for(var i = 1; i < 5; i++){
      arr.push({num:i});}
    • db.num.insert(arr);

更新文档

格局
db.collection.update(
    <query>,
    <update>,
    {
        upsert: <boolean>,
        multi: <boolean>,
        writeConcern: <ducument>
    }
)

query: update 的查问条件，相似 sql update 查问内 where 前面的
update: update 的对象和一些更新的操作符（如 $,$inc...）等，也能够了解为 sql update 查问内 set 前面的
upsert: 可选，这个参数的意思是，如果不存在 update 的记录，是否插入 objNew,true 为插入，默认是 false，不插入
multi: 可选，mongodb 默认是 false, 只更新找到的第一条记录，如果这个参数为 true, 就把按条件查出来多条记录全副更新
writeConcern: 可选，抛出异样的级别

案例
db.ruochen.insert({
    title: 'mongodb',
    description: 'Nosql 数据库',
    by: 'ruochen',
    tags: ['mongodb', 'databases', 'NoSQL']
})

db.ruochen.update({'title': 'mongodb'}, {$set:{'title': 'MongoDB'}})  # 只会批改第一条发现的文档
db.ruochen.find().pretty()

db.ruochen.update({'title': 'mongodb'}, {$set:{'title': 'MongoDB'}}，{multi:true})  # 批改多条雷同的文档


save() 办法: 通过传入的文档来替换已有文档
格局
db.collection.save(
    <document>,
    {writeConcern: <document>}
)
document: 文档数据
writeConcern: 可选，抛出异样的级别

案例
db.ruochen.save({"_id" : ObjectId("5e631a14c17b253e9cef40cc"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "Runoob",
    "url" : "http://www.runoob.com",
    "tags" : ["mongodb",]
})
db.ruochen.find().pretty()

删除文档

语法：db.collection.remove(
    <query>,
    <justOne>
)

2.6 版本当前语法格局
db.collection.remove(
    <query>
    {
        justOne: <boolean>,
        writeConcern: <document>
    }
)

参数阐明
query: (可选) 删除的文档的条件
justOne: (可选) 如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或应用默认值 false，则删除所有匹配条件的文档
writeConcern: (可选) 抛出异样的级别

db.ruochen.remove({'title': 'mongodb'})

# 只删除第一条找到的记录
db.COLLECTION_NAME.remove(DELETION_CRITHRIA, 1)

# 删除所有数据
db.ruochen.remove({})
db.ruochen.find()

# remove() 办法 并不会真正开释空间
# 须要执行 db.repairDatabase() 来回收磁盘空间
db.repairDatabase()
db.runCommand({repairDatabase: 1})

remove 办法曾经过期
# 删除汇合下所有文档
db.ruochen.deleteMany({})
# 删除 num 等于 1 的全副文档
db.ruochen.deleteMany({num: '1'})
# 删除 num 等于 1 的一个文档
db.ruochen.deleteOne({num: '1'})

查问文档

语法：db.collection.find(query, projection)
参数阐明
query: 可选，应用查问操作符指定查问条件
projection: 可选，应用投影操作符指定返回的键。查问时返回文档中所有键值，只需省略该参数即可（默认省略）# 以易读的形式读取数据
db.ruochen.find().pretty()

AND 条件

• find() 办法能够传入多个键 (key)，每个键(key) 以逗号隔开，即惯例 SQL 的 AND 条件

• 格局：

  • db.ruochen.find({key1: value1, key2: value2}).pretty()

• 案例

  • db.ruochen.find({‘by’: ‘ruochen’, ‘likes’: 200}).pretty()

相似于 where by=’ruochen’ and likes=200

or 条件

• 格局

  db.ruochen.find(
      {
          $or:[{key1: value1}, {key2: value2}
          ]
      }
  ).pretty()
  

• 案例

  • db.ruochen.find({$or:[{‘likes’: 2}, {‘likes’:200}]}).pretty()

AND 和 OR 联结

• db.ruochen.find({‘likes’: {$gt:100}, $or: [{‘likes’: 2}, {‘likes’: 200}]}).pretty()

条件操作符

db.ruochen.insert({
    title: 'python',
    description: 'i love python',
    by: 'ruochen',
    url: 'xxx',
    tags: ['python'],
    likes: 200
})

db.ruochen.insert({
    title: 'php',
    description: 'php 是世界上最好的语言',
    by: 'ruochen',
    url: 'xxx',
    tags: ['php'],
    likes: 150
})

db.ruochen.insert({
    title: 'MondoDB',
    description: 'NoSQL 数据库',
    by: 'ruochen',
    url: 'xxx',
    tags: ['mongodb'],
    likes: 100
})

# 获取 'ruochen' 汇合中 'likes' 大于 100 的数据
db.ruochen.find({likes: {$gt: 100}}).pretty()
# 相似于 SQL 语句
Select * from ruochen where likes > 100;


获取 'ruochen' 汇合中 'likes' 大于等于 100 的数据
db.ruochen.find({likes: {$gte: 100}}).pretty()
# 相似于 SQL 语句
Select * from ruochen where likes >= 100;


# 获取 'ruochen' 汇合中 'likes' 小于 150 的数据
db.ruochen.find({likes: {$lt: 150}}).pretty()
# 相似于 SQL 语句
Select * from ruochen where likes < 150;


# 获取 'ruochen' 汇合中 'likes' 小于等于 150 的数据
db.ruochen.find({likes: {$lte: 150}}).pretty()
# 相似于 SQL 语句
Select * from ruochen where likes <= 150;

MongoDB 应用 (<) 和 (>) 查问 – $lt 和 $gt

• 获取 ”ruochen” 汇合中 “likes” 大于 100，小于 200 的数据

  • db.ruochen.find({likes: {$lt: 200, $gt: 100}}).pretty()

  • 相似 SQL 语句

    • Select * from ruochen where likes > 100 and likes < 200;

含糊查问

• 查问 title 中蕴含 ‘py’ 的文档

  • db.ruochen.find({title:/py/}).pretty()

• 查问 title 字段以 ‘p’ 结尾的文档

  • db.ruochen.find({title:/^p/}).pretty()

• 查问 title 字段以 ‘p’ 结尾的文档

  • db.ruochen.find({title:/p$/}).pretty()

MongoDB $type 操作符

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

• 获取 “ruochen” 汇合中 title 为 String 的数据

  • db.ruochen.find({‘title’: {$type: 2}}).pretty()
  • db.ruochen.find({‘title’: {$type: String}}).pretty()

Limit 与 Skip 办法

Limit() 办法

• 在 MongoDB 中读取指定数量的数据记录, 应用 MongoDB 的 Limit 办法
• limit()办法承受一个数字参数，该参数指定从 MongoDB 中读取的记录条数

• 语法

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

• 案例

  • db.ruochen.find().limit(2)

Skip() 办法

• skip()办法跳过指定数量的数据
• skip 办法承受一个数字参数作为跳过的记录条数

• 语法

  • db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

• 案例

  • db.ruochen.find().limit(1).skip(1)

skip() 办法默认参数为 0

MongoDB 排序

• sort() 办法

  • sort() 办法能够通过参数指定排序的字段，并应用 1 和 -1 来指定排序的形式，其中 1 为升序排列，而 -1 是用于降序排列

  • 语法

    • db.COLLECTION_NAME.find().sort({key: 1})

  • 案例

    • ruochen 汇合中的数据按字段 likes 的降序排列
    • db.ruochen.find().sort({‘likes’: -1}).pretty()

skip(), limilt(), sort()三个放在一起执行的时候，执行的程序是先 sort(), 而后是 skip()，最初是显示的 limit()。

MongoDB 索引

• creatIndex() 办法

  • MongoDB 应用 createIndex() 办法来创立索引

  • 语法

    • db.collection.createIndex(keys, options)
    • Key 值为你要创立的索引字段, 1 为指定按升序创立索引, -1 为降序创立索引

  • 案例

    • db.ruochen.createIndex({‘title’: 1})
    • db.ruochen.createIndex({‘title’: 1, ‘description’: -1}) # 设置多个字段创立索引

createIndex() 接管可选参数，可选参数列表如下

MongoDB 聚合

• MongoDB 聚合 (aggregate) 次要用于解决数据(诸如统级平均值、求和等), 并返回计算后的数据后果。有点相似 sql 语句中的 count(*)

aggregate() 办法

• 语法

  • db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

• 实例

  • db.ruochen.aggregate([{$group: {_id: “$by”, num_tutorial: {$sum: 1}}}])

  • 相似于 mql 语句

    • select by, count(*) from ruochen group by by

聚合表达式

管道

• 管道在 Unix 和 Linux 中个别用于将以后命令的输入后果作为下一个命令的参数
• MongoDB 的聚合管道将 MongoDB 文档在一个管道处理完毕后将后果传递给下一个管道解决
• 管道操作是能够反复的

• 表达式：解决文档并输入

  • 表达式是无状态的，只能用于计算以后聚合管道的文档，不能解决其它的文档

• 罕用操作

  • $project：批改输出文档的构造。能够用来重命名、减少或删除域，也能够用于创立计算结果以及嵌套文档
  • $match：用于过滤数据，只输入符合条件的文档。$match 应用 MongoDB 的规范查问操作
  • $limit：用来限度 MongoDB 聚合管道返回的文档数
  • $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档
  • $unwind：将文档中的某一个数组类型字段拆分成多条，每条蕴含数组中的一个值
  • $group：将汇合中的文档分组，可用于统计后果
  • $sort：将输出文档排序后输入
  • $geoNear：输入靠近某一地理位置的有序文档

举例

• $project

  db.ruochen.aggregate(
      { $project: {
          title: 1,
          by: 1,    
      }}
  );
  只剩_id, title 和 by 三个字段，默认_id 字段被蕴含
  
  db.ruochen.aggregate(
      { $project: {
          _id: 0
          title: 2,
          by: 1,    
      }}
  );
  如此即可不蕴含_id, 非 0 可示意显示字段，正数也能够示意显示该字段
  

• $match

  
  获取分数大于 70 或小于等于 90 的记录，而后把符合条件的记录送到下一阶段 $group 管道操作符进行解决
  db.ruochen.aggregate([{$match: {score: {$gt: 70, $lte: 90}}},
      {$group: {_id: null, count: {$sum: 1}}}
  ])
  
  

当 match 条件和 group 同时存在时，程序会影响检索后果，必须先写 match 在后面

• $skip

  过滤前 5 个文档
  db.ruochen.aggregate({$skip: 5});