=== mongo 语法 start ===

=== 创建数据库

use 数据库
show dbs

ps:插入数据才会显示，集合插入数据才会真的创建
db.lyj.insert({"name":"mongo教程"})

=== 删除数据库

db.dropDatabase()

use 数据库
db.dropDatabase()
```

## === 创建集合 增

```
db.数据表.insert({"name":"数据表"})

// 插入一行
db.users.insert({
    name: "John Doe",
    email: "john.doe@example.com",
    age: 30
})


// 插入多行
db.users.insertMany([
    {
        "name" : "John Doe",
        "email": "john.doe@example.com",
        "age"  : 31
    },
    {
        "name" : "张三",
        "email": "john.doe@example.com",
        "age"  : 23
    },
    {
        "name" : "lisi",
        "email": "john.doe@example.com",
        "age"  : 33
    }
])
    
```

## === 删除集合\数据  删

```
db.数据表.drop() 

db.collection.remove(<query>)
db.users.remove({ "name": "John" })
db.users.remove([{ "age": 25 }, { "age": 30 }])


需要注意的是，remove命令在默认情况下会永久删除匹配的文档，而且无法撤销。在执行remove命令之前，请确保你已经备份了重要的数据，并且要谨慎使用该命令。
```

## === 更新文档  改

```
// 更新数据 语法
db.collection.update(  
   <query>,  
   {  
      $set: {  
         <field1>: <value1>,  
         <field2>: <value2>,  
         ...  
      }  
   }  
)

// 更新数据
db.users.update(
    {
        name: "John Doe9"
    },
    {
        $set: {
            age  : 44,
            email: "john@example.com"
        }
    },
    false,
    true
)


// 替换整个文档
db.users.replaceOne(
{
    _id: "123457",
}, 
{    
    name : "John Doe9",
    email: "john.doe@example.com",
    age  : 30
})

// 允许更新字段
db.users.updateOne({
    _id: "123457",
    
}, {
    $set: {
        age: 22
    }
})

update操作适用于仅更新部分字段的情况，可以按需对文档进行修改，不需要提供一个完整的新文档。update操作更加灵活，可以通过不同的操作符进行精准地字段级别的更新。然而，由于update操作是在原始文档的基础上进行修改，因此可能会引入一些潜在的风险，例如并发更新可能导致数据不一致问题。

replace操作适用于需要一次性完全替换整个文档的情况，确保文档的结构和内容都完全满足新的需求。replace操作相对来说更加安全，一次更新操作可以保证数据的一致性。然而，替换整个文档可能需要提供完整的数据，可能会引起一些额外的开销。

要选择合适的操作来更新或替换文档，需要考虑到具体的需求和业务场景。


// 与insert命令不同的是，如果插入的文档已有唯一索引，save方法将更新该文档，而不会抛出重复键错误。
db.collection.save(document)

db.users.save({name: "John", age: 25}) 
```

## === 查询文档（数据） 查

```
db.collection.find(<query>)

// 查询所有
db.collection.find({})

// 查询特定字段
db.collection.find({ field: <value> })

// 查询多个字段 
db.collection.find({ field1: <value1>, field2: <value2> })

// 查询特定字段的  不等于 !=
db.collection.find({ field: { $ne: <value> } })

// 查询特定字段的   等于   ==
db.collection.find({ field: { $eq: <value> } }) 

// 查询特定字段的  大于或等于 >=
db.collection.find({ field: { $gte: <value> } })

// 查询特定字段的  小于或等于 <=
db.collection.find({ field: { $lte: <value> } })

// 查询特定字段的值  包含 in 
db.collection.find({ field: { $in: [<value1>, <value2>, ...] } })

// 查询特定字段的值  不包含 not in
db.collection.find({ field: { $nin: [<value1>, <value2>, ...] } })

// 查询符合    多个条件 and or
db.collection.find({ $and: [ {field1: <value1>}, {field2: <value2>} ] })
db.collection.find({ $or: [ {key1: value1}, {key2: value2} ] })

// or 和 and 组合使用
db.users.find({  
  $or: [  
    {  
      $and: [  
        { age: { $gt: 25 } },  
        { gender: "male", country: "USA" }  
      ]  
    },  
    {  
      $and: [  
        { age: { $gt: 30 } },  
        { gender: "female", country: "UK" }  
      ]  
    }  
  ]  
})


// 查询特定字段匹配正则
db.collection.find({ field: /regex/ })

```

 

## === 操作符

``` 
$match: 用于筛选文档。它相当于SQL中的WHERE子句。
    db.collection.find({ $match: { field: value } })

$eq: 等于操作符，用于比较字段的值是否相等。
    db.collection.find({ field: { $eq: value } })

$ne: 不等于操作符，用于比较字段的值是否不相等。
    db.collection.find({ field: { $ne: value } })

$gt、$lt: 大于、小于操作符，用于比较字段的值。
    db.collection.find({ field: { $gt: value } })  
    db.collection.find({ field: { $lt: value } })

$gte: 大于等于操作符，用于比较字段的值是否大于或等于给定值。
    db.collection.find({ field: { $gte: value } })

$lte: 小于等于操作符，用于比较字段的值是否小于或等于给定值。
    db.collection.find({ field: { $lte: value } })

$in: 用于判断字段的值是否在给定值列表中。
    db.collection.find({ field: { $in: [value1, value2, ...] } })

$nin: 用于判断字段的值是否不在给定值列表中。
    db.collection.find({ field: { $nin: [value1, value2, ...] } })

$regex: 正则表达式操作符，用于匹配字段的值与正则表达式。
    db.collection.find({ field: { $regex: /pattern/ } })

$all: 用于判断字段的值是否包含所有给定值。
    db.collection.find({ field: { $all: [value1, value2, ...] } })

$elemMatch: 用于在一个数组字段中匹配多个条件。
    db.collection.find({ arrayField: { $elemMatch: { field1: value1, field2: value2 } } })

$or: 或操作符，用于组合多个查询条件，只要有一个条件满足即可返回文档。
    db.collection.find({ $or: [query1, query2, ...] })

$and: 与操作符，用于组合多个查询条件，只有当所有条件都满足时才返回文档。
    db.collection.find({ $and: [query1, query2, ...] })

$not: 非操作符，用于对查询条件取反。
    db.collection.find({ field: { $not: query } })

$set: 用于更新文档中的字段值。
    db.collection.updateOne({ field: value }, { $set: { field: newValue } })

$unset: 用于删除文档中的字段。
    db.collection.updateOne({ field: value }, { $unset: { field: true } })

$inc: 用于增加或减少文档中的字段值。
    db.collection.updateOne({ field: value }, { $inc: { field: increment } })

$push: 用于向数组字段中添加一个元素。
    db.collection.updateOne({ field: value }, { $push: { field: newValue } })

$pop: 用于从数组字段中删除最后一个元素。
    db.collection.updateOne({ field: value }, { $pop: { field: true } })

$slice: 用于截取数组字段的子集。
    db.collection.updateOne({ field: value }, { $slice: { field: start, end } })

$sort: 用于对数组字段进行排序。
    db.collection.updateOne({ field: value }, { $sort: { field: 1  } })  // 升序  
    db.collection.updateOne({ field: value }, { $sort: { field: -1 } })  // 降序

$bitwise: 用于执行位运算操作。
    db.collection.updateOne({ field: value }, { $bitwise: { op: "AND", operand: mask } }) 

$regex: 用于在一个字符串字段中执行正则表达式匹配。
    db.collection.find({ field: { $regex: /pattern/ } })

$elemMatch: 用于在一个数组字段中匹配多个条件。
    db.collection.find({ arrayField: { $elemMatch: { field1: value1, field2: value2 } } })

$all: 用于在一个数组字段中匹配多个值。
    db.collection.find({ field: { $all: [value1, value2, ...] } })

$in: 用于在一个字段中匹配多个值。
    db.collection.find({ field: { $in: [value1, value2, ...] } })

$or: 用于组合多个查询条件，只要有一个条件满足即可返回文档。
    db.collection.find({ $or: [query1, query2, ...] })

$and: 用于组合多个查询条件，只有当所有条件都满足时才返回文档。
    db.collection.find({ $and: [query1, query2, ...] })

$nor: 用于组合多个查询条件，只有当所有条件都不满足时才返回文档。
    db.collection.find({ $nor: [query1, query2, ...] }) 

 
`$eq`                  : 等于    db.test.find({"name": {"$eq": '张三'}})
`$ne`                  : 不等于  db.test.find({"name": {"$ne": '张三'}})
`$gt`                  : 匹配字段值 大于 指定值的文档。  db.test.find({"name": {"$gt": '张三'}})
`$lt`                  : 匹配字段值 小于 指定值的文档。  db.test.find({"name": {"$lt": '张三'}})
`$gte`                 : 匹配字段值 大于等于 指定值的文档。 db.test.find({"name": {"$gte": '张三'}})
`$lte`                 : 匹配字段值 小于等于 指定值的文档。 db.test.find({"name": {"$lte": '张三'}})
`$in`                  : 匹配字段值 包含 指定数组中的任何值的文档。 db.test.find({"name": {"$in": ['张三','lishi']}})
`$nin`                 : 匹配字段值 不包含 在指定数组中的文档。     db.test.find({"name": {"$nin": ['张三','lishi']}})
`$or`                  : 多个查询条件中至少满足一个的文档。 db.test.find({"$or": [{"name":'zhangsan'}, {'name':'lisi'}]})
`$and`                 : 多个查询条件必须同时满足的文档。          db.test.find({"$and": [{"name":'zhangsan'}, {'name':'lisi'}]})
`$not`                 : 排除满足指定查询条件的文档。              db.test.find({"age": {"$not": {"$eq":11}}})
`$nor`                 : 排除满足所有指定查询条件的文档。
`$where`               : 通过JavaScript代码自定义查询条件的文档。
`$exists`              : 匹配字段存在（包括字段值为null）的文档。
`$type`                : 匹配字段值为指定数据类型的文档。
`$mod`                 : 匹配字段值被除有指定余数的文档。
`$regex`               : 正则表达式可以匹配到的文档。
`$text`                : 针对创建了全文索引的字段进行文本搜索。
`$elemMatch`           : 在数组字段中匹配多个查询条件的文档。
`$size`                : 匹配具有指定长度的数组的文档。
`$all`                 : 匹配包含所有指定值的数组字段的文档。
`$with`                : 在聚合管道操作符中启用聚合框架的文档。
`$group`               : 在聚合管道操作符中对输入文档进行分组的文档。
`$sum`                 : 在聚合管道操作符中计算指定字段的总和的文档。
`$avg`                 : 在聚合管道操作符中计算指定字段的平均值的文档。
`$min`                 : 在聚合管道操作符中找出指定字段的最小值的文档。
`$max`                 : 在聚合管道操作符中找出指定字段的最大值的文档。
`$limit`               : 在聚合管道操作符中限制返回的文档数量的文档。
`$skip`                : 在聚合管道操作符中跳过指定数量的文档的文档。
`$notequal`            : 匹配不等于指定值的文档，与`$ne`相反。
`$gt_unsigned`         : 匹配无符号类型字段大于指定值的文档。
`$lt_unsigned`         : 匹配无符号类型字段小于指定值的文档。
`$gte_unsigned`        : 匹配无符号类型字段大于等于指定值的文档。
`$lte_unsigned`        : 匹配无符号类型字段小于等于指定值的文档。
`$regex_match`         : 用于在字段上执行正则表达式匹配的操作符。
`$regex_test`          : 用于测试正则表达式是否匹配文档的操作符。
`$regex_contains`      : 用于判断一个字段的值是否包含指定正则表达式的操作符。
`$regex_search`        : 用于在文本字段上执行正则表达式搜索的操作符。
`$text_search`         : 用于在文本字段上执行文本搜索的操作符。
`$text_match`          : 用于在文本字段上执行匹配文本搜索的操作符。
`$text_contains`       : 用于判断一个文本字段是否包含指定关键词的操作符。
`$text_search_contains`: 用于判断一个文本字段是否包含指定搜索条件的结果的操作符。
`$near`                : 用于在地理位置字段上搜索附近的文档的操作符。
`$geoWithin`           : 用于在地理位置字段上搜索多边形区域内的文档的操作符。
`$geoIntersects`       : 用于在地理位置字段上搜索与多边形区域交集的文档的操作符。
`$all_with`            : 用于在数组字段上匹配所有数组元素的操作符。
`$all_elemMatch`       : 用于在数组字段上匹配满足指定条件的所有元素的操作符。
`$all_size`            : 用于获取数组字段长度等于指定值的文档的操作符。
`$all_eq`              : 用于获取数组字段包含指定值的文档的操作符。
`$elemMatch`           : 在数组字段中匹配多个查询条件的文档。
`$all`                 : 匹配包含所有指定值的数组字段的文档。
`$some`                : 匹配至少包含指定条件的数组字段的文档。
`$none`                : 匹配不包含指定条件的数组字段的文档。
`$in`                  : 匹配字段值在指定数组中的文档。
`$nin`                 : 匹配字段值不在指定数组中的文档。
`$or`                  : 多个查询条件中至少满足一个的文档。
`$and`                 : 多个查询条件必须同时满足的文档。
`$not`                 : 排除满足指定查询条件的文档。
`$nor`                 : 排除满足所有指定查询条件的文档。
`$mod`                 : 匹配字段值被除有指定余数的文档。
`$regex`               : 正则表达式可以匹配到的文档。 
`.`                    : 用于访问嵌套的文档字段。
`$elemMatch`           : 在数组字段中匹配多个查询条件的文档。
`$size`                : 匹配具有指定长度的数组的文档。
`$all`                 : 匹配包含所有指定值的数组字段的文档。
`$with`                : 在聚合管道操作符中启用聚合框架的文档。
`$group`               : 在聚合管道操作符中对输入文档进行分组的文档。
`$sum`                 : 在聚合管道操作符中计算指定字段的总和的文档。
`$avg`                 : 在聚合管道操作符中计算指定字段的平均值的文档。
`$min`                 : 在聚合管道操作符中找出指定字段的最小值的文档。
`$max`                 : 在聚合管道操作符中找出指定字段的最大值的文档。
`$limit`               : 在聚合管道操作符中限制返回的文档数量的文档。
`$skip`                : 在聚合管道操作符中跳过指定数量的文档的文档。
`$sort`                : 在聚合管道操作符中对输入文档进行排序的文档。
`$project`             : 在聚合管道操作符中修改输入文档结构的文档。
`$group`               : 在聚合管道操作符中根据指定字段对输入文档进行分组的文档。
`$sum`                 : 在聚合管道操作符中计算指定字段的总和的文档。
`$avg`                 : 在聚合管道操作符中计算指定字段的平均值的文档。
`$push`                : 在聚合管道操作符中将指定字段的值添加到数组中的文档。
`$addtoset`            : 在聚合管道操作符中将指定字段的值添加到数组中，但不会重复的文档。
`$pull`                : 在聚合管道操作符中从数组中移除指定字段的值。
`$pullAll`             : 在聚合管道操作符中从数组中移除多个指定的值。
`$each`                : 在聚合管道操作符中迭代输入文档多次，并将每次迭代的结果输出为一个数组的文档。
`$set`                 : 在聚合管道操作符中设置输入文档的指定字段的值。
`$unset`               : 在聚合管道操作符中删除输入文档的指定字段。
`$rename`              : 在聚合管道操作符中重命名输入文档的指定字段。
`$bit`                 : 在聚合管道操作符中执行位运算操作。
`$split`               : 在聚合管道操作符中拆分字符串并返回一个数组。
`$lower`               : 在聚合管道操作符中将字符串转换为小写。
`$upper`               : 在聚合管道操作符中将字符串转换为大写。
`$concat`              : 在聚合管道操作符中连接字符串。
`$expr`                : 在聚合管道操作符中执行复杂的表达式。
```



## === 聚合 基本语法 === 

```
db.collection.aggregate(pipeline, options)
```

### === project ===
```
1表示展示某字段
0表示不展示某字段

db.book.aggregate({
    $project: {
        "_id": 0,
        "book_name": 1,
        "borrowerIds": "$borrowers.id",
        "borrowerNames": "$borrowers.name"
    }
}) 

```

### === limit ===

```
只展示一个投影结果

db.book.aggregate([
    {
        $project: {
            "_id": 0,
            "book_name": 1,
            "borrowerIds": "$borrowers.id",
            "borrowerNames": "$borrowers.name"
        }
    },
    {
        $limit: 1
    }
])
 

```

### === skip === 
```
跳过一个且只展示一个投影结果

db.book.aggregate([
    {
        $project: {
            "_id": 0,
            "book_name": 1,
            "borrowerIds": "$borrowers.id",
            "borrowerNames": "$borrowers.name"
        }
    },
    {
        $skip: 1
    },
    {
        $limit: 1
    }
]) 

```

### === sort === 
```
排序

db.book.aggregate([
    {
        $project: {
            "_id": 1,
            "book_name": 1,
            "library_id": 1
        }
    },
    {
        $sort: {
            "library_id": - 1,             // 降序
            "_id": 1                       // 升序
        }
    }
]) 

MongoDB内存排序有100M限制，如果排序数据过多需要设置选项allowDiskUse=true，表示数据可以写入临时文件进行排序

db.book.aggregate([
    {
        $project: {
            "_id": 1,
            "book_name": 1,
            "library_id": 1
        }
    },
    {
        $sort: {
            "library_id": - 1,
            "_id": 1
        }
    }
], {
    allowDiskUse: true
})


```

### === out ===
```
投影结果输出到新集合
db.book.aggregate([
    {
        $project: {
            "_id": 0,
            "book_name": 1,
            "borrowerIds": "$borrowers.id",
            "borrowerNames": "$borrowers.name"
        }
    },
    {
        $out: "newCollection"
    }
])

db.newCollection.find() 

```


### === match ===
```
匹配

db.book.aggregate([
    {
        $match: {
            $and: [
                {
                    "library_id": 2
                },
                {
                    "book_price": {
                        $gt: 25
                    }
                }
            ]
        }
    },
    {
        $project: {
            "_id": 1,
            "book_name": 1,
            "library_id": 1,
            "book_price": 1
        }
    }
]) 

```

### === unwind ===
```
文档按照借阅人数铺平

db.book.aggregate([
    {
        $unwind: {
            path: "$borrowers",
            includeArrayIndex: "idx"
        }
    }
]) 
```

### === lookup ===
```
实现连表查询

MongoDB 3.4之前聚合语法:
    from:待关联集合【book】
    localField: 本集合关联键【library】
    foreignField:待关联键【book】
    as:待关联集合数据【book】

db.library.aggregate([
    {
        $lookup: 
        {
            from: "book",
            localField: "_id",
            foreignField: "library_id",
            as: "books_info"
        }
    }
]) 

MongoDB 3.4之后聚合语法:
    from:待关联集合【book】
    let:声明本集合字段在管道使用
    pipeline:操作管道   

db.library.aggregate([
    {
        $lookup: 
        {
            from: "book",
            let: {
                "lid": "$_id"
            },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            $and: [
                                {
                                    $eq: ["$$lid", "$library_id"]
                                }
                            ]
                        }
                    }
                }
            ],
            as: "books_info"
        }
    }
]) 
```

### === group ===
```
分组统计

db.book.aggregate([
    {
        $group: {
            _id: "$book_type",
            count: {
                $sum: 1
            }
        }
    }
]) 

db.book.aggregate([
    {
        $group: {
            _id: "$book_type",
            type_count: {
                $sum: 1
            },
            type_book_count: {
                $sum: "$book_count"
            },
            minTotalPrice: {
                $min: {
                    $multiply: ["$book_price", "$book_count"]
                }
            },
            maxTotalPrice: {
                $max: {
                    $multiply: ["$book_price", "$book_count"]
                }
            },
            totalPrice: {
                $sum: {
                    $multiply: ["$book_price", "$book_count"]
                }
            },
            avgPrice: {
                $avg: "$book_price"
            }
        }
    }
]) 

// 空分组键  _id:空分组键表示统计全量数据
db.book.aggregate([
    {
        $group: {
            _id: null,
            type_count: {
                $sum: 1
            },
            type_book_count: {
                $sum: "$book_count"
            },
            minTotalPrice: {
                $min: {
                    $multiply: ["$book_price", "$book_count"]
                }
            },
            maxTotalPrice: {
                $max: {
                    $multiply: ["$book_price", "$book_count"]
                }
            },
            totalPrice: {
                $sum: {
                    $multiply: ["$book_price", "$book_count"]
                }
            },
            avgPrice: {
                $avg: "$book_price"
            }
        }
    }
]) 

// 多字段分组
db.collection.aggregate([  
    {  
        $group: {  
            _id: {  
                field1: "$field1",  
                field2: "$field2"  
            },  
            count: { $sum: 1 } // 你可以添加其他聚合操作符，如$sum, $avg, $max等  
        }  
    }  
])

在上面的示例中，$group阶段用于根据field1和field2字段的组合进行分组。_id字段是一个文档，其中包含了你想要分组的字段。在这个例子中，我们根据field1和field2的值进行分组，并计算每个组的文档数量（使用$sum: 1）。

你可以根据需要添加更多的聚合操作符到$group阶段中，以便对每个组执行其他计算，如平均值（$avg）、最大值（$max）等。

请确保将collection替换为你的实际集合名称，并根据你的数据结构调整字段名称和聚合操作符。


```

### === 聚合语法 end ===



## === mongo foreach ===

```
// 每个文档执行指定的操作
db.users.find({}).forEach(function(doc) {
    // 年龄加1
    doc.age = doc.age + 1;
    db.users.save(doc);
})
```



## === 创建数据库，用户，并授权 ===

```
=== 管理员登录授权
use admin
db.auth('root','root')

=== 使用新数据库
use newdb

=== 授权用户 
db.createUser({
    user: "voyager",
    pwd: "welcome1",
    roles: [
        {
            role: "readWrite",
            db: "newdb"
        }
    ]
})

=== 插入测试数据
db.test.insert({"test":123})

```

## === 用户权限

```
## 1、创建管理员用户
    use admin 

    // 管理员用户 root 角色
    db.createUser({
        user: "root",
        pwd: "root",
        roles: [{
            role: 'root',
            db: 'admin'
        }]
    })

    // 管理员用户 userAdminAnyDatabase 角色
    db.createUser({
        user: "root",
        pwd: "root",
        roles: [
            {
                role: "userAdminAnyDatabase",
                db: "admin"
            }
        ]
    })

## 2、查看所有用户
    db.system.users.find().pretty()

## 3、创建普通用户
    // 普通用户 角色 读写用户
    db.createUser({
        user: "voyager",
        pwd: "welcome1",
        roles: [
            {
                role: "readWrite",
                db: "guilin_puhui"
            }
        ]
    })


## 4、授权登录root
    use admin
    db.auth('root','root')

## 5、普通用户
    use lyj
    
    db.createUser({
        user: "lyj",
        pwd: "lyj",
        roles: [{
            role: 'readWrite',
            db: 'lyj'
        }]
    })
    
    db.auth('lyj','lyj')

## 6、查看所有用户
    db.system.users.find().pretty()

## 7、修改用户密码
    db.changeUserPassword('lyj','lyj')

## 8、删除用户
    db.system.users.remove({user:"用户名"})
    db.system.users.remove({_id:"用户id"})

## 9、远程连接
    mongo IP:端口/库名 -u 用户名 -p 密码

    -- (带数据库 用户 密码)
    mongo 127.0.0.1:27017/lyj -u lyj -p lyj

    -- (带数据库)
    mongo 127.0.0.1:27017/lyj
    
## 10、数据库创建授权流程
    // 登录 admin 数据库 
    use admin
    // 管理员授权
    db.auth('root','root')  
    // 登录 新数据库
    use 新的数据库名  
    // 创建 普通用户 授权读写角色 赋予数据库
    db.createUser({
        user:"lyj",
        pwd:"lyj",
        roles:[
            {
                role:"readWrite",
                db:"新的数据库名"
            }
        ]
    })
    // 授权普通用户
    db.auth('lyj','lyj')
    // 测试插入数据
    db.test.insert({'test':1234})
    
```


    
## === 导入、导出 ===

```
导出 全量
mongodump -h dbhost -d dbname -o dbdirectory
 
    参数说明:
      -h: mongodb所在服务器地址,例如:127.0.0.1 , 当然也可以指定端口号127.0.0.1:27017
      -d: 需要备份的数据库实例，例如:test
      -o: 备份的数据存放位置，例如:C:\home\mongodb,该目录需要提前建立
 
导入 全量
mongorestore -h dbhost -d dbname dbdirectory
/*
    参数说明:
      -h: mongodb所在服务器地址,例如:127.0.0.1 , 当然也可以指定端口号127.0.0.1:27017
      -d: 需要恢复的数据库实例，例如:test
      -drop: 恢复的时候先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的            数据都会被删除，慎用
*/


//导出
mongodump -h dbhost -d dbname -u user -p password -o dbdirectory
 
 
 
//导入
mongorestore -h dbhost -d dbname -c order --dir d:\home -u user -p password


// 例子
mongoimport -u lyj -p lyj --collection test0601 --db lyj  --file E:\mongodata\test0601.json

mongoimport -u lyj -p lyj --collection error0601 --db lyj  --file E:\mongodata\error0601.json

mongoimport -u lyj -p lyj --collection paopi0601 --db lyj  --file E:\mongodata\paopi0601.json




===== 单表 操作 ====
指定表
--host      : 要导出数据库 ip
--port      : 要导出的实例节点端口号
--username  : 数据库用户名
--password  : 数据库用户密码
--collection: 要导出的表名
--db        : 要导出的表所在数据库名
--out       : 要导出的文件路径(默认为当前文件夹) 

单表导出
mongoexport --host 192.168.1.122 --port 27017 -u username -p password --collection lyj_esb_res --db data_bank_enter_qry --out D:\lyj_esb_res_03266.json



--host      : 要导入的数据库 ip
--port      : 要导入的实例节点端口号
--username  : 数据库用户名
--password  : 数据库用户密码
--collection: 要导入的表名
--db        : 要导入的表所在数据库名
--file      : 要导入的源文件路径(默认为当前文件夹)


单表导入
mongoimport --host 127.0.0.1 --port 27017 -u lyj -p lyj --collection lyj_esb_res --db lyj  --file E:\资料下载\lyj_esb_res.json
```

# === mongo 语法 end ===


# === 一些例子 ===
```
// 
db.digital_control_overall_summary_index_bx_source.aggregate(
    [
        {
            "$group": {
                "_id": {
                    "month": "$data_date"
                },
                "latest": {
                    "$first": "$$ROOT"
                }
            }
        },
        {
            "$sort": {
                "_id": 1
            }
        },
        {
            "$project": {
                "_id": 0,
                "create_time": "$latest.create_time",
                "data_date": "$latest.data_date"
            }
        }
    ]
)

// 截取字符串字段
db.data_lake_source_complaints.aggregate([
    {
        // 增加字段
        "$addFields": {
            "length": {
                // 计算字段长度
                "$strLenCP": "$line_str"
            }
        }
    },
    {
        "$addFields": {
            "start_with": {
                // 截取字符串字段
                "$substrCP": [
                    "$line_str",
                    0,
                    16
                ]
            }
        }
    }
])


// 字段拼接
"full_path": {"$concat":["$base_path", "$depend_file.file_path", "$depend_file.file_name", ]}

// 正则表达式查询
"base_path": {"$regex":"ODS_ROOT_DIR/file/"}

// 字符串截取
"base_path": { "$substrCP": ["$full_path", 31, 1000] }

// 取消50行限制操作
DBQuery.shellBatchSize = 500


```