MongoDB系列：CRUD方法（一）

MongoDB系列：CRUD方法（一）

一、查询方法

一、find方法

db.collectionName.find(
  // 查询条件（可选）
  { /* 查询条件 */ },

  // 投影对象，指定要返回的字段
  { 
    fieldName1: 1, // 返回字段1
    fieldName2: 1, // 返回字段2
    // ...
  }
);

find方法有两个参数：

• 查询条件，类似于sql中的where条件
• 返回的字段，若不写任何值类似于sql中的select * from中的 *，如果 fieldName:1，代表要返回该字段，

如果 fieldNam:0 表示不查询该字段，若都存在 0和1则只有0生效。

示例：

新建表并插入数据

// 新建插入数据
db.inventory.insertMany( [
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

查询：

db.inventory.find({
   "qty":25
}, {
        "_id": 1,
        "item": 0
    });

结果： item字段不显示了

{
    "_id" : ObjectId("65a729b21072dd3695b2d6ea"),
    "qty" : NumberInt(25),
    "size" : {
        "h" : NumberInt(14),
        "w" : NumberInt(21),
        "uom" : "cm"
    },
    "status" : "A"
}

二、查询嵌套文档

也就是文档的value是一个对象类型。

继续使用上述文档，

1、查询字段size中的h等于14的数据。

db.inventory.find({
    "size.h": 14,
});

2、查询 size.h大于等于8.5，并且小于14。

db.inventory.find({
    "size.h": { $gte: 8.5 }, "size.h": { $lt: 14 }
});

三、查询数组文档

插入文档和数据：

db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
   { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
   { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
   { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
   { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);

1、查询数组中指定的元素，并且按照该顺序。

db.inventory.find( { tags: ["red", "blank"] } )

//结果
{
    "_id" : ObjectId("65a734141072dd3695b2d6f0"),
    "item" : "notebook",
    "qty" : NumberInt(50),
    "tags" : [
        "red",
        "blank"
    ],
    "dim_cm" : [
        NumberInt(14),
        NumberInt(21)
    ]
}

2、查询数组中存在指定的元素

db.inventory.find( { tags: { $all: ["red", "blank"] } } )

// 结果 返回所有tags数组中包含red和blank元素的数据。

3、查询数组中存在某个指定的元素

db.inventory.find( { tags: "red" } )

// 返回所有 tags数组中包含red元素的数据。

4、查询数组中，任意一个元素满足所有的条件的数据。

db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } );

// 查询dim_cm中任意一个元素满足大于15，并且小于20的数据
// 结果：[14,21],[10,15.25]
// 解释：14 满足小于20，21 满足大于15；10满足小于20，15.25满足大于15
// 反之：[22,85,30],22.85和30都满足大于15，但是没有元素满足小于20

5、查询数组中，存在一个元素满足所有的条件的数据。

db.inventory.find( { dim_cm: { $elemMatch: { $gt: 15, $lt: 20 } } } );

// 查询存在一个元素满足大于22并且小于30
// 结果：[10,15.25]
// 解释：15.25满足大于15并且小于20

四、查询数组中嵌套文档

新建并插入数据

db.inventory.insertMany([
    { item: "journal", instock: [{ warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 }] },
    { item: "notebook", instock: [{ warehouse: "C", qty: 5 }] },
    { item: "paper", instock: [{ warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 }] },
    { item: "planner", instock: [{ warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 }] },
    { item: "postcard", instock: [{ warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 }] }
]);

1、查询数组中指定的对象，并且顺序需要一致

db.inventory.find({ "instock": { warehouse: "A", qty: 5 } })

// 查询instock数组中存在{ warehouse: "A", qty: 5 }的数据 顺序保持一致，如果是{ qty: 5，warehouse: "A" } 就查不出来了
// 结果
{
    "_id" : ObjectId("65a745b11072dd3695b2d6f4"),
    "item" : "journal",
    "instock" : [
        {
            "warehouse" : "A",
            "qty" : NumberInt(5)
        },
        {
            "warehouse" : "C",
            "qty" : NumberInt(15)
        }
    ]
}

2、查询数组中字段指定条件

db.inventory.find( { 'instock.qty': { $lte: 5 } } )
// 查询instock数组中任意对象的字段qty小于等于5的数据

3、查询数组中满足任意一个条件的数据

db.inventory.find( { "instock": { $elemMatch: { qty: 5, warehouse: "A" } } } )
// 查询instock数组中同一个对象中存在qty等于5并且warehouse等于A的数据

db.inventory.find( { "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } } )
// 查询instock数组中同一个对象中存在qty大于10并且小于等于20的数据

五、查询返回的字段

创建并插入数据

db.inventory.insertMany( [
    { item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] },
    { item: "notebook", status: "A",  size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] },
    { item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] },
    { item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] },
    { item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" }, instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

前面在find方法简述中已经简单说了返回字段的展示与隐藏，这儿着重说一下数组以及嵌套对象这种情况。

1、查询文档中对象类型的某个字段

db.inventory.find(
   { status: "A" },
   { "size.uom": 1,"size.h": 1 }
)

// 结果，对象中只返回了 h和uom两个值
{
    "_id" : ObjectId("65a766dd1072dd3695b2d6f9"),
    "size" : {
        "h" : NumberInt(14),
        "uom" : "cm"
    }
}
... 省略其他的

2、查询文档中对象类型排除某个值

db.inventory.find(
   { status: "A" },
   { "size.uom": 0 }
)

//结果 排除size对象中uom属性
{
    "_id" : ObjectId("65a766dd1072dd3695b2d6f9"),
    "item" : "journal",
    "status" : "A",
    "size" : {
        "h" : NumberInt(14),
        "w" : NumberInt(21)
    },
    "instock" : [
        {
            "warehouse" : "A",
            "qty" : NumberInt(5)
        }
    ]
}

3、查询文档数组中返回几个元素

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

//$slice：后面跟一个number类型，正数表示查询前几个元素，负数表示查询从后数的几个元素。
// 如上所示，查询数组中最后一个元素。不常用。

六、查询null的情况

创建并插入数据

db.inventory.insertMany([
   { _id: 1, item: null },
   { _id: 2 }
])

1、查询null或字段不存在的情况

db.inventory.find({
    item:null
})
// 返回两条数据，所哟查询条件如果是null的话，也会查出来字段不存在的数据。
// 结果
{
    "_id" : NumberInt(1),
    "item" : null
}
{
    "_id" : NumberInt(2)
}

2、查询某个字段是否存在的数据

db.inventory.find( { item : { $exists: false } } )

// 查询item不存在的数据
// 结果
{
    "_id" : NumberInt(2)
}

七、总结

? 本文列举了mongoDB中几种常用的查询方式，以及给出了示例。

• 最基本的key，value结构的查询较为简单那
• 对象类型的查询，类似于javascript的方式去点即可，如a.b。
• 类型为数组的查询，包括全匹配以及存在即可的查询。
• 类型为数组且类型内为对象的查询
• 查询后返回值的过滤。
• 查询null或者字段存在与否的情况。

二、插入方法

插入方法较为简单，直接看示例即可，值得注意的是，插入的数据需要分配一个主键_id字段，如果没有设置mongodb会自动生成一个。

insertOne();
insertMany();

// 单条插入，这种情况会自动分配一个_id
db.products.insertOne( { item: "card", qty: 15 } );

// 批量插入
db.products.insertMany( [
      { item: "card", qty: 15 },
      { item: "envelope", qty: 20 },
      { item: "stamps" , qty: 30 }
   ] );

三、修改方法

创建并插入文档

db.inventory.insertMany([
    { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
    { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
    { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
    { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
    { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
    { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
    { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
    { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
    { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
    { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }，
    { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }
]);

基础修改方法有三个

• db.collection.updateOne(, , )

• db.collection.updateMany(, , )

• db.collection.replaceOne(, , )

1、updateOne单个修改

// 单个修改item等于paper的数据，可以看到此文档中符合条件的数据有两条，但是只会修改其中遍历的第一条。
db.inventory.updateOne(
    { item: "paper" },
    {
        $set: { "size.uom": "cm", status: "P" },
        $currentDate: { lastModified: true }
    }
)

2、updateMany批量修改数据

// 批量修改qty小于50的数据
// 并用$currentDate 更新了lastModified字段为当前时间
db.inventory.updateMany(
    { "qty": { $lt: 50 } },
    {
        $set: { "size.uom": "in", status: "P" },
        $currentDate: { lastModified: true }
    }
)


// 批量删除paper中的lastModified字段，使用$unset方法
db.inventory.updateMany(
    { item: "paper" },
    {
        $unset: { lastModified: 1 }
    }
)

3、replaceOne替换某条数据

// 替换item等于paper的数据，如果有多条只会修改第一条。
db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)

四、删除方法

创建并插入文档：

db.inventory.insertMany( [
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
] );

基础的删除方法有一下三个

• db.collection.deleteMany()
• db.collection.deleteOne()
• db.collection.remove()

删除方法比较简单不多做介绍了直接列出来了。

// 删除所有status等于A的数据
db.inventory.deleteMany({ status : "A" })

// 删除一个status等于D的数据
db.inventory.deleteOne( { status: "D" } )

// remove 方法其实是综合了前面两个方法,内部有许多参数，基本用不到这儿不多做研究可以qu
//等同于批量删除
db.inventory.remove({status: "D"}) 

// 等同于单个删除，justOne默认为false不限制一个
db.inventory.remove({status: "D"},{justOne:true})