=== 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
```
