mongodb审计 mongodb writeconcern

转载

mob64ca140234eb 2023-10-31 10:11:24

文章标签 mongodb审计 mongodb nosql 数据库字段 文章分类 MongoDB 数据库

添加操作

查询操作

复合主键

逻辑操作符匹配

文档游标

文档投影

更新操作

删除操作

添加操作

db.集合.insertOne(<JSON对象>)   // 添加单个文档
db.集合.insertMany([{<JSON对象1>},{<JSON对象2>}])   // 批量添加文档
db.集合.insert()   // 添加单个文档
开始创建文档
db.collection.insertOne(
doc ,
{
  writeConcern: 安全级别   // 可选字段
}
)

writeConcern 定义了本次文档创建操作的安全写级别简单来说，安全写级别用来判断一次数据库写入操作是否成功，安全写级别越高，丢失数据的风险就越低，然而写入操作的延迟也可能更高。

writeConcern 决定一个写操作落到多少个节点上才算成功。 writeConcern的取值包括

0：发起写操作，不关心是否成功

1- 集群中最大数据节点数：写操作需要被复制到指定节点数才算成功

majority: 写操作需要被复制到大多数节点上才算成功

发起写操作的程序将阻塞到写操作到达指定的节点数为止

rs0:PRIMARY> db.order.insertOne({"_id":"000001","name":"xiaowang"})
{ "acknowledged" : true, "insertedId" : "000001" }
rs0:PRIMARY> db.order.find()
{ "_id" : "000001", "name" : "xiaowang" }

插入文档时，如果没有显示指定主键，MongoDB将默认创建一个主键，字段固定为_id,ObjectId() 可以快速生成的12字节id 作为主键，ObjectId 前四个字节代表了主键生成的时间，精确到秒。主键ID在客户端驱动生成，一定程度上代表了顺序性，但不保证顺序性，可以通过ObjectId("id值").getTimestamp() 获取创建时间。

如：

rs0:PRIMARY> ObjectId("628385bb76e4d4d1f519fda9").getTimestamp()
 ISODate("2022-05-17T11:23:39Z")

创建多个文档

db.collection.insertMany(
[   {doc } , {doc }, ....],
  {
   writeConcern: doc, 
   ordered: true/false
  }
)

rs0:PRIMARY> db.order.insertMany([{"_id":"000003","name":"23323"},{"_id":"000009","name":"小米","account":22233}])
 { "acknowledged" : true, "insertedIds" : [ "000003", "000009" ] }

ordered: 是否按顺序进行写入

顺序写入时，一旦遇到错误，便会退出，剩余的文档无论正确与否，都不会写入

乱序写入，则只要文档可以正确写入就会正确写入，不管前面的文档是否是错误的文档

rs0:PRIMARY> db.order.insertMany([{"_id":"000007","name":"23323"},{"_id":"0070009","name":"小米","account":22233}],{ordered:true})

查询操作

db.collection.find({}) 查询所有的文档
db.collection.find({}).pretty() 返回格式化后的文档

rs0:PRIMARY> db.order.find().pretty()
{ "_id" : "000001", "name" : "xiaowang" }
{ "_id" : ObjectId("628385bb76e4d4d1f519fda9"), "name" : "xiaoming" }
{ "_id" : "000003", "name" : "23323" }
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "000007", "name" : "23323" }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }
rs0:PRIMARY>

条件查询：

1. 精准等值查询
db.collection.find( { status: "D" } );
db.collection.find( { qty: 0 } );
2. 多条件查询
db.collection.find( { qty: 0, status: "D" } );
3. 嵌套对象精准查询
db.collection.find( { "size.uom": "in" } );
4. 返回指定字段
db.collection.find( { }, { item: 1, status: 1 } );
默认会返回_id 字段， 同样可以通过指定 _id:0 ,不返回_id 字段
5. 条件查询 and
db.collection.find({$and:[{"qty":0},{"status":"A"}]}).pretty(); 
6. 条件查询 or
db.collection.find({$or:[{"qty":0},{"status":"A"}]}).pretty();

Mongo查询条件和SQL查询对照表
SQL
MQL
a<>1 或者 a!=1
{ a : {$ne: 1}}
a>1
{ a: {$gt:1}}
a>=1
{ a: {$gte:1}}
a<1
{ a: {$lt:1}}
a<=1
{ a: { $lte:1}}
in
{ a: { $in:[ x, y, z]}}
not in
{ a: { $nin:[ x, y, z]}}
a is null
{ a: { $exists: false }}
insertOne, inertMany, insert 的区别
insertOne, 和 insertMany命令不支持 explain命令
insert支持 explain命令

rs0:PRIMARY> db.order.find({},{"_id":0,"account":1}).pretty()
{ }
{ }
{ }
{ "account" : 22233 }
{ }
{ "account" : 22233 }

rs0:PRIMARY> db.order.find({"account":{$exists:true}})
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }

rs0:PRIMARY> db.order.find({account:22233})
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }

复合主键

可以使用文档作为复合主键

db.order.insert(
 {
   _id: {  product_name: 1,  product_type: 2},
 supplierId:" 001",
 create_Time: new Date()
 }
 )

注意复合主键，字段顺序换了，会当做不同的对象被创建，即使内容完全一致

逻辑操作符匹配

$not : 匹配筛选条件不成立的文档
$and : 匹配多个筛选条件同时满足的文档
$or : 匹配至少一个筛选条件成立的文档
$nor : 匹配多个筛选条件全部不满足的文档
$exists：匹配包含查询字段的文档

如：

db.collection.find({filed1: { $not: { $lt: value}}}  ); 
$not 也会筛选出并不包含查询字段的文档
db.collection.find({$and : [ {filed1:{ $eq : "value1"}}, {filed2:{ $gt:value2}}]});
对于同一个字段的and操作可以简写
db.collection.find({filed1:{ $gte:value1, $lte:value2}});

{ field : {$exists: <boolean>} }

rs0:PRIMARY> db.order.find({$and:[{"account":22233},{"name":"小米"}]})
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }
rs0:PRIMARY> db.order.find({$and:[{"account":22233}]})
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }
{ "_id" : ObjectId("6283889c76e4d4d1f519fdac"), "name" : "小黑", "account" : 22233 }

rs0:PRIMARY> db.order.find({"account":{$gte:20000,$lte:300000}})
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }
{ "_id" : ObjectId("6283889c76e4d4d1f519fdac"), "name" : "小黑", "account" : 22233 }

文档游标

count 统计计数
skip 跳过几条记录
limit显示几条记录
sort 按照某个字段排序

默认情况下，这里的count不会考虑 skip 和 limit的效果，如果希望考虑 limit 和 skip ，需要设置为 true。分布式环境下，count 不保证数据的绝对正确

db.collection.find().skip(1).limit(10).sort(file:1).count(true);

rs0:PRIMARY> db.order.find().count()
10
rs0:PRIMARY> db.order.find()
{ "_id" : "000001", "name" : "xiaowang" }
{ "_id" : ObjectId("628385bb76e4d4d1f519fda9"), "name" : "xiaoming" }
{ "_id" : "000003", "name" : "23323" }
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "000007", "name" : "23323" }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }
{ "_id" : { "product_name" : 1, "product_type" : 2 }, "supplierId" : " 001", "create_Time" : ISODate("2022-05-17T11:31:03.586Z") }
{ "_id" : ObjectId("6283889076e4d4d1f519fdaa"), "name" : "小红" }
{ "_id" : ObjectId("6283889c76e4d4d1f519fdab"), "name" : "小红" }
{ "_id" : ObjectId("6283889c76e4d4d1f519fdac"), "name" : "小黑", "account" : 22233 }

rs0:PRIMARY> db.order.find().skip(5).limit(3).sort({"account":-1})
{ "_id" : "000007", "name" : "23323" }
{ "_id" : "000001", "name" : "xiaowang" }
{ "_id" : "000003", "name" : "23323" }
rs0:PRIMARY> db.order.find().sort({"account":-1})
{ "_id" : "000009", "name" : "小米", "account" : 22233 }
{ "_id" : "0070009", "name" : "小米", "account" : 22233 }
{ "_id" : ObjectId("6283889c76e4d4d1f519fdac"), "name" : "小黑", "account" : 22233 }
{ "_id" : "000001", "name" : "xiaowang" }
{ "_id" : ObjectId("628385bb76e4d4d1f519fda9"), "name" : "xiaoming" }
{ "_id" : "000003", "name" : "23323" }
{ "_id" : "000007", "name" : "23323" }
{ "_id" : { "product_name" : 1, "product_type" : 2 }, "supplierId" : " 001", "create_Time" : ISODate("2022-05-17T11:31:03.586Z") }
{ "_id" : ObjectId("6283889076e4d4d1f519fdaa"), "name" : "小红" }
{ "_id" : ObjectId("6283889c76e4d4d1f519fdab"), "name" : "小红" }

rs0:PRIMARY> db.order.find().skip(10).count()
10
rs0:PRIMARY> db.order.find().skip(10).count(true)
0

文档投影

db.collection.find(  查询条件,  投影设置)
投影设置：{ field: < 1 ：1 表示需要返回， 0： 表示不需要返回 ， 只能为 0，或者1 ， 非主键字段，不能同时混选0 或 1>}
slice
可以使用 $slice 返回数组中的部分元素；如， 先添加一个数组元素的文档
db.members.insertOne(
 {
  _id: {uid:3,accountType: "qq"},
  nickName:"张飞",
  points:1200,
  address:[
  {address:"xxx",post_no:0000},
  {address:"yyyyy",post_no:0002}
  ]}
 );
 返回数组的第一个元素
 db.members.find(
 {},
 {_id:0, 
  nickName:1,
  points:1,
  address: 
     {$slice:1}
 });
 返回倒数第一个
 db.members.find(
 {},
 {_id:0, 
  nickName:1,
  points:1,
  address:{$slice:-1}}
  );
  
  返回前两个
  db.members.find(
 {},
 {_id:0, 
  nickName:1,
  points:1,
  address:{$slice:2}}
  );

slice: 值
1： 数组第一个元素
-1：最后一个元素
-2：最后两个元素
slice[ 1,2 ] : skip, limit 对应的关系

rs0:PRIMARY>  db.members.find( {}, {_id:0,   nickName:1,  points:1,  address:{$slice:[0,2]}}  );
{ "nickName" : "张飞", "points" : 1200, "address" : [ { "address" : "xxx", "post_no" : 0 }, { "address" : "yyyyy", "post_no" : 2 } ] }

还可以使用 elementMatch 进行数组元素进行匹配
添加一组数据

db.members.insertOne(
 {
  _id: {uid:4,accountType: "qq"},
  nickName:"张三",
  points:1200,
  tag:["student","00","IT"]}
 );

查询tag数组中第一个匹配"00" 的元素

rs0:PRIMARY> db.members.find(
...   {},
...   {_id:0,
...    nickName:1,
...    points:1,
...    tag: {  $elemMatch:  {$eq:  "00" } }
... });
{ "nickName" : "张飞", "points" : 1200 }
{ "nickName" : "张三", "points" : 1200, "tag" : [ "00" ] }

更新操作

updateOne/updateMany 方法要求更新条件部分必须具有以下之一，否则将报错
将tag 中有90 的文档，增加一个字段： flag: 1

db.collection.updateMany(
 {filed:value},
 {$set:{filed:value}}
 );
 只修改一个则用
 db.collection.updateOne({filed:value},
 {$set:{filed:value}}
 );

rs0:PRIMARY> db.order.updateOne({"age":{$gt:23}},{$set:{"userName":"小王2"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "userName" : "小王2", "age" : 222, "total" : 22222 }
{ "_id" : "0000002", "userName" : "小明", "age" : 24, "total" : 23232 }

db.collection.update( <query>,<update>,<options>)
 <query> 定义了更新时的筛选条件
 <update> 文档提供了更新内容
 <options> 声明了一些更新操作的参数更新文档操作只会作用在第一个匹配的文档上
 如果<update> 不包含任何更新操作符，则会直接使用update 文档替换集合中符合文档筛选条件的文更新操作符
$set 给符合条件的文档新增一个字段，有该字段则修改其值
$unset 给符合条件的文档，删除一个字段
$rename 重命名字段
$inc 加减字段值
$mul 相乘字段值
$min 采用最小值  比较value去最小值
$max 次用最大值

$push： 增加一个对象到数组底部
$pop：从数组底部删除一个对象
$pull：如果匹配指定的值，从数组中删除相应的对象
$pullAll：如果匹配任意的值，从数据中删除相应的对象
$addToSet：如果不存在则增加一个值到数组

rs0:PRIMARY> db.order.updateOne({"age":{$gt:23}},{$unset:{"userName":"小王1"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 222, "total" : 22222 }
{ "_id" : "0000002", "userName" : "小明", "age" : 24, "total" : 23232 }

rs0:PRIMARY> db.order.updateOne({"age":{$gt:23}},{$rename:{"userName":"name"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 222, "total" : 22222, "name" : "小王1" }
{ "_id" : "0000002", "userName" : "小明", "age" : 24, "total" : 23232 }

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 223, "total" : 22222, "name" : "小王1" }
{ "_id" : "0000002", "userName" : "小明", "age" : 24, "total" : 23232 }

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 666, "total" : 22222, "name" : "小王1" }
{ "_id" : "0000002", "userName" : "小明", "age" : 24, "total" : 23232 }

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 1000, "total" : 22222, "name" : "小王1" }
{ "_id" : "0000002", "userName" : "小明", "age" : 1000, "total" : 23232 }

push

rs0:PRIMARY> db.order.updateOne({"age":{$gt:23}},{$push:{"score":{$each:[99,98,97]}}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 1000, "total" : 22222, "name" : "小王1", "score" : [ 99, 98, 97 ] }
{ "_id" : "0000002", "userName" : "小明", "age" : 1000, "total" : 23232 }

addToSet

rs0:PRIMARY> db.order.updateOne({"age":{$gt:23}},{$addToSet:{"score":100}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
rs0:PRIMARY> db.order.find()
{ "_id" : "0000001", "age" : 1000, "total" : 22222, "name" : "小王1", "score" : [ 99, 98, 97, 100 ] }
{ "_id" : "0000002", "userName" : "小明", "age" : 1000, "total" : 23232 }

删除操作

删除文档
db.collection.remove(<query>,<options>)
默认情况下，会删除所有满足条件的文档，可以设定参数 { justOne:true},只会删除满足添加的第一条文档
删除集合
db.collection.drop( { writeConcern:<doc>})
<doc> 定义了本次删除集合操作的安全写级别
这个指令不但删除集合内的所有文档，且删除集合的索引

db.collection.remove 只会删除所有的文档，直接使用remve删除所有文档效率比较低，可以使用 drop 删除集合，才重新创建集合以及索引。

rs0:PRIMARY> db.order.remove({"_id":"0000001"})
WriteResult({ "nRemoved" : 1 })
rs0:PRIMARY> db.order.find()
{ "_id" : "0000002", "userName" : "小明", "age" : 1000, "total" : 23232 }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。