MongoDB(二)术语与基本操作crud

雨点打透心脏的1/2处 2023-02-08 12:43 18阅读 0赞

# MongoDB 术语与基本操作 #

MongoDB术语与关系型数据术语的对比

<table> 
 <thead> 
  <tr> 
   <th align="left">SQL术语/概念</th> 
   <th align="left">MongoDB术语/概念</th> 
   <th align="left">解释/说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">database</td> 
   <td align="left">database</td> 
   <td align="left">数据库</td> 
  </tr> 
  <tr> 
   <td align="left">table</td> 
   <td align="left">collection</td> 
   <td align="left">数据库表/集合</td> 
  </tr> 
  <tr> 
   <td align="left">row</td> 
   <td align="left">document</td> 
   <td align="left">数据记录行/文档</td> 
  </tr> 
  <tr> 
   <td align="left">column</td> 
   <td align="left">field</td> 
   <td align="left">数据字段/域</td> 
  </tr> 
  <tr> 
   <td align="left">index</td> 
   <td align="left">index</td> 
   <td align="left">索引</td> 
  </tr> 
  <tr> 
   <td align="left">table joins</td> 
   <td align="left"></td> 
   <td align="left">表连接,MongoDB不支持</td> 
  </tr> 
  <tr> 
   <td align="left">primary key</td> 
   <td align="left">primary key</td> 
   <td align="left">主键,MongoDB自动将_id字段设置为主键</td> 
  </tr> 
 </tbody> 
</table>

## MongoDB 数据库 ##

一个MongoDB 的实例下可以建多个数据库，不同的数据库存储在不同的文件中, 使用`use <dbname>`可以新建并切换到该数据库（切换数据库也使用该命令）

test> use mymongo
    switched to db mymongo

一个MongoDB 的实例默认有三个数据库, 可以使用`show dbs`查看所有的数据库（默认进入是`test`数据库，新建的数据库有数据才会在显示）

test> show dbs
    admin      41 kB
    config    111 kB
    local    73.7 kB
    
    # admin 
    # config Mongodb分片设置时，用于保存分片的相关信息
    # local 不会被复制的数据库，可以存储本地

在数据库中`db`表示当前数据库，在shell中输入`db`命令会返回当前数据库的名称

test> db
    test

数据库的基本操作

# 创建数据库
    test> use mymongo
    switched to db mymongo
    
    # 删除数据库
    mymongo> db.dropDatabase()
    {
         ok: 1, dropped: 'mymongo' }
    
    # 查看数据库的版本
    test> db.version()
    5.0.4
    
    # 查看当前数据库的状态
    test> db.stats()
    {
        
      db: 'test',
      collections: 0,
      views: 0,
      objects: 0,
      avgObjSize: 0,
      dataSize: 0,
      storageSize: 0,
      totalSize: 0,
      indexes: 0,
      indexSize: 0,
      scaleFactor: 1,
      fileSize: 0,
      fsUsedSize: 0,
      fsTotalSize: 0,
      ok: 1
    }
    
    # 获取shell帮助 
    test> help 
    
    # 获取数据库帮助
    test> db.help()

## MongoDB 集合 ##

创建集合的基本语法: `db.createCollection(name, options)`

*  name: 集合名称
 *  options: 可选参数

options 可以是如下参数：

<table> 
 <thead> 
  <tr> 
   <th align="left">字段</th> 
   <th align="left">类型</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">capped</td> 
   <td align="left">布尔</td> 
   <td align="left">（可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。 <strong>当该值为 true 时，必须指定 size 参数。</strong></td> 
  </tr> 
  <tr> 
   <td align="left">autoIndexId</td> 
   <td align="left">布尔</td> 
   <td align="left">3.2 之后不再支持该参数。（可选）如为 true，自动在 _id 字段创建索引。默认为 false。</td> 
  </tr> 
  <tr> 
   <td align="left">size</td> 
   <td align="left">数值</td> 
   <td align="left">（可选）为固定集合指定一个最大值，即字节数。 <strong>如果 capped 为 true，也需要指定该字段。</strong></td> 
  </tr> 
  <tr> 
   <td align="left">max</td> 
   <td align="left">数值</td> 
   <td align="left">（可选）指定固定集合中包含文档的最大数量。</td> 
  </tr> 
 </tbody> 
</table>

MongoDB 集合的基本操作

# 创建集合
    mymongo> db.createCollection("col01")
    {
         ok: 1 }
    
    # 创建集合 带可选参数
    mymongo> db.createCollection("col02",{
        capped: true, size: 102400, max: 100})
    {
         ok: 1 }
    
    # 查看所有集合
    mymongo> show collections
    col01
    col02
    
    # 集合中插入数据
    mymongo> db.col01.insertOne({
        "name":"doc01"})
    {
        
      acknowledged: true,
      insertedId: ObjectId("61a711a16c91e78d3f263570")
    }
    
    # 删除集合
    mymongo> db.col01.drop()
    true
    
    # 查看集合中的所有数据
    mymongo> db.col02.find()
    [ {
         _id: ObjectId("61a714476c91e78d3f263571"), name: 'doc02' } ]
    
    # 查询集合中文档的总数
    mymongo> db.col02.count()
    DeprecationWarning: Collection.count() is deprecated. Use countDocuments or estimatedDocumentCount.
    1
    mymongo> db.col02.countDocuments()
    1

## MongoDB 文档 ##

MongoDB 文档的数据结构是BSON 格式，和 JSON 基本一样。

BSON 是一种类似 JSON 的二进制形式的存储格式，是 Binary JSON 的简称。

官方文档：https://docs.mongodb.com/manual/crud/

### MongoDB 插入文档 ###

插入文档的基本语法：`db.COLLECTION_NAME.insert(document) 或 db.COLLECTION_NAME.save(document)`

*  save()：如果 \_id 主键存在则更新数据，如果不存在就插入数据。该方法新版本中已废弃，可以使用 `db.collection.insertOne()` 或 `db.collection.replaceOne()`来代替。
 *  insert(): 若插入的数据主键已经存在，则会抛 `org.springframework.dao.DuplicateKeyException` 异常，提示主键重复，不保存当前数据。

注意：insert()是要过期的不建议使用，3.2 版本之后新增了 db.collection.insertOne() 和 db.collection.insertMany()。

db.collection.insertOne() 用于向集合插入一个新文档，语法格式如下：

db.collection.insertOne(
       <document>,
       {
          writeConcern: <document>
       }
    )

db.collection.insertMany() 用于向集合插入一个多个文档，语法格式如下：

db.collection.insertMany(
       [ <document 1> , <document 2>, ... ],
       {
          writeConcern: <document>,
          ordered: <boolean>
       }
    )

参数说明：

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

MongoDB 插入文档的基本操作：

# 插入单个文档
    mymongo> db.col01.insertOne({
        name: "doc00"})
    {
        
      acknowledged: true,
      insertedId: ObjectId("61a716cc6c91e78d3f263576")
    }
    
    # 批量插入文档
    mymongo> db.col01.insertMany([{
        name: "doc01"},{
        name: "doc02"},{
        name: "doc03"}])
    {
        
      acknowledged: true,
      insertedIds: {
        
        '0': ObjectId("61a7166f6c91e78d3f263573"),
        '1': ObjectId("61a7166f6c91e78d3f263574"),
        '2': ObjectId("61a7166f6c91e78d3f263575")
      }
    }

### MongoDB 更新文档 ###

更新文档的基本语法：`db.COLLECTION_NAME.update(document) 或 db.COLLECTION_NAME.save(document)`

3.2 版本之后新增了 `db.collection.updateOne()` 和 `db.collection.updateMany()` 和`db.collection.replaceOne()`。

db.collection.updateOne() 用于更新一个文档，语法格式如下：

db.collection.updateOne(
       <filter>,
       <update>,
       {
         upsert: <boolean>,
         writeConcern: <document>,
         collation: <document>,
         arrayFilters: [ <filterdocument1>, ... ],
         hint:  <document|string>        // Available starting in MongoDB 4.2.1
       }
    )

db.collection.updateMany() 用于更新多个文档，语法格式如下：

db.collection.updateMany(
       <filter>,
       <update>,
       {
         upsert: <boolean>,
         writeConcern: <document>,
         collation: <document>,
         arrayFilters: [ <filterdocument1>, ... ],
         hint:  <document|string>        // Available starting in MongoDB 4.2.1
       }
    )

参数说明：

*  **filter** : 过滤条件，类似sql update查询where条件。
 *  **update** : 应用的修改，update的字段和一些更新的操作符（如 , , ,inc…）等，可以理解为sql update查询内set后面的赋值操作。
 *  **upsert** : 可选的参数。当为true时，updateOne()可以: 如果没有匹配筛选器的文档，则创建一个新文档。默认值为false，当没有找到匹配时不会插入新文档。。
 *  **writeConcern** :可选的。抛出异常的级别。
 *  **collation** : 可选的。指定操作要使用的排序规则。排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。3.4 新版功能。
 *  **arrayFilters**: 可选的。筛选器文档的数组，它确定在数组字段的更新操作中要修改哪些数组元素。3.6 新版功能。
 *  **hint**: 可选的。指定用于支持查询谓词的索引的文档或字符串。该选项可以接受索引规范文档或索引名称字符串。如果指定的索引不存在，则操作错误。4.2.1新版功能。

writeConcern的值:

*  **WriteConcern.NONE:** 没有异常抛出
 *  **WriteConcern.NORMAL**: 仅抛出网络错误异常，没有服务器错误异常
 *  **WriteConcern.SAFE**: 抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
 *  **WriteConcern.MAJORITY**: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
 *  **WriteConcern.FSYNC\_SAFE**: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
 *  **WriteConcern.JOURNAL\_SAFE**: 抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
 *  **WriteConcern.REPLICAS\_SAFE**: 抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。

MongoDB 更新文档的基本操作：

# 构造一些数据
    db.col00.insertMany([
    	{
        "name":"a","age":"10","status":"open"},
    	{
        "name":"b","age":"20","status":"open"},
    	{
        "name":"c","age":"30","status":"open"},
    	{
        "name":"d","age":"40","status":"open"},
    	{
        "name":"e","age":"50","status":"open"}
    ])
    
    # 更新一条文档
    mymongo> db.col00.updateOne( {
         name: "a" }, {
         $set: {
         age: "35" } })
    {
        
      acknowledged: true,
      insertedId: null,
      matchedCount: 1,
      modifiedCount: 1,
      upsertedCount: 0
    }
    
    
    # 更新多条文档
    mymongo> db.col00.updateMany( {
         age: {
         $lt: "40" } }, {
         $set: {
         status: "close" } })
    {
        
      acknowledged: true,
      insertedId: null,
      matchedCount: 3,
      modifiedCount: 3,
      upsertedCount: 0
    }

### MongoDB 删除文档 ###

删除文档的基本语法： `db.collection.remove()`

3.2 版本之后新增了 `db.collection.deleteOne()` 和 `db.collection.deleteMany()` 。

db.collection.deleteOne() 用于删除一个文档，语法格式如下：

db.collection.deleteOne(
       <filter>,
       {
        
          writeConcern: <document>,
          collation: <document>,
          hint: <document|string>        // Available starting in MongoDB 4.4
       }
    )

db.collection.deleteMany() 用于删除多个文档，语法格式如下：

db.collection.deleteMany(
       <filter>,
       {
          writeConcern: <document>,
          collation: <document>
       }
    )

参数解释见MongoDB 更新文档的参数解释

MongoDB 删除文档的基本操作

# 删除一条文档
    mymongo>  db.col00.deleteOne({
        name: "a"})
    {
         acknowledged: true, deletedCount: 1 }
    
    # 删除多条文档
    mymongo> db.col00.deleteMany({
         age: {
         $lt: "40" } })
    {
         acknowledged: true, deletedCount: 2 }
    
    # 删除所有文档
    db.col00.deleteMany({
        })

### MongoDB 查询文档 ###

官方文档：https://docs.mongodb.com/manual/tutorial/query-documents/

查询文档的基本语法：`db.collection.find(query, projection)`

参数解释：

*  query：可选的。使用查询操作符指定选择筛选器。若要返回集合中的所有文档，请忽略此参数或传递一个空文档(\{\})。
 *  projection：可选的。指定要在文档中返回的与查询筛选器匹配的字段。若要返回匹配文档中的所有字段，请忽略此参数

查询文档基本操作

# 查询所有的文档
    mymongo> db.col00.find()
    [
    {
        _id:ObjectId("61a729ff254f0000c90068ed"),name:'a',age:'10',status:'open'},{
        _id:ObjectId("61a729ff254f0000c90068ee"),name:'b',age:'20',status:'open'},{
        _id:ObjectId("61a729ff254f0000c90068ef"),name:'c',age:'30',status:'open'},{
        _id:ObjectId("61a729ff254f0000c90068f0"),name:'d',age:'40',status:'open'},{
        _id:ObjectId("61a729ff254f0000c90068f1"),name:'e',age:'50',status:'open'}
    ]
    
    # 条件查询
    mymongo> db.col00.find({
        age: '40'})
    [
    {
        _id:ObjectId("61a729ff254f0000c90068f0"),name:'d',age:'40',status:'open'}
    ]
    
    # 指定返回字段
    mymongo> db.col00.find({
        age: '40'}, {
        name: 1, _id: 0})
    [ {
         name: 'd' } ]
    
    mymongo> db.col00.find({
        age: '40'}, {
        name: true, _id: false})
    [ {
         name: 'd' } ]
    
    # 查询返回指定条数
    mymongo> db.col00.find({
        }, {
        name: true, _id: false}).limit(3)
    [ {
         name: 'a' }, {
         name: 'b' }, {
         name: 'c' } ]
    
    # 查询并排序
    mymongo> db.col00.find({
        }, {
        name: true, _id: false}).sort({
        name: 1})
    [
      {
         name: 'a' },
      {
         name: 'b' },
      {
         name: 'c' },
      {
         name: 'd' },
      {
         name: 'e' }
    ]
    # 倒序
    mymongo> db.col00.find({
        }, {
        name: true, _id: false}).sort({
        name: -1})
    [
      {
         name: 'e' },
      {
         name: 'd' },
      {
         name: 'c' },
      {
         name: 'b' },
      {
         name: 'a' }
    ]

MongoDB 与 RDBMS Where 语句比较

<table> 
 <thead> 
  <tr> 
   <th align="left">操作</th> 
   <th align="left">格式</th> 
   <th align="left">范例</th> 
   <th align="left">RDBMS中的类似语句</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">等于</td> 
   <td align="left"><code>{&lt;key&gt;:&lt;value&gt;</code>}</td> 
   <td align="left">db.col00.find({"age ":“40”})</td> 
   <td align="left">where age = ‘40’</td> 
  </tr> 
  <tr> 
   <td align="left">小于</td> 
   <td align="left"><code>{&lt;key&gt;:{$lt:&lt;value&gt;}}</code></td> 
   <td align="left">db.col00.find({"age ":{$lt:40}})</td> 
   <td align="left">where age &lt; ‘40’</td> 
  </tr> 
  <tr> 
   <td align="left">小于或等于</td> 
   <td align="left"><code>{&lt;key&gt;:{$lte:&lt;value&gt;}}</code></td> 
   <td align="left">db.col00.find({"age ":{$lte:40}})</td> 
   <td align="left">where age &lt;= ‘40’</td> 
  </tr> 
  <tr> 
   <td align="left">大于</td> 
   <td align="left"><code>{&lt;key&gt;:{$gt:&lt;value&gt;}}</code></td> 
   <td align="left">db.col00.find({"age ":{$gt:40}})</td> 
   <td align="left">where age &gt; ‘40’</td> 
  </tr> 
  <tr> 
   <td align="left">大于或等于</td> 
   <td align="left"><code>{&lt;key&gt;:{$gte:&lt;value&gt;}}</code></td> 
   <td align="left">db.col00.find({"age ":{$gte:40}})</td> 
   <td align="left">where age &gt;= ‘40’</td> 
  </tr> 
  <tr> 
   <td align="left">不等于</td> 
   <td align="left"><code>{&lt;key&gt;:{$ne:&lt;value&gt;}}</code></td> 
   <td align="left">db.col00.find({"age ":{$ne:40}})</td> 
   <td align="left">where age != ‘40’</td> 
  </tr> 
 </tbody> 
</table>