mongoDB数据库基础认知

数据库命名规则：

1、不区分大小写，一般来说都是用小写

2、不能包含空字符

3、数据库名称不能为空

4、名称限制：不能包括/\. "$*<>:|? (windows平台下的)

数据库操作内容

查看数据库列表 ：

    show dbs;

查看当前所在的数据库：

MongoDB中默认的数据库为test。如果这个数据库为空，那么是不会显示出来的。只有往这个数据库中添加了数据之后，才会在查看数据库列表的时候显示

       db;

默认数据库：我们在创建数据库的时候，不要和这三个数据库的名称冲突！！！！

admin:1、配置用户的权限，把用户添加到这个数据库，那么这个用户会拥有这个数据库的所有权限。

2、运行服务器端的特殊的命令。

local:只存储存在于本地服务器的集合。

config:在mongodb用于分片的时候，保存分片的相关信息

创建/切换数据库：

如果数据库不存在，会自动创建数据库；如果存在，就直接切换到指定的数据库

use myNewDatabase;

删除数据库：

tip： 要删除数据库，一定要先切换到要删除的数据库中

db.dropDatabase()

集合操作内容

集合名称命名规则

1、应以下划线或者字母开头

2、不能包含$

3、不能为空字符串

4、不能包含空字符串

5、不能以.开头

注意：操作集合之前，要先切换到要操作的数据库，查看当前数据库

创建集合:如果不存在集合，就会自动创建集合，并插入数据;如果集合存在，就直接插入数据

db.myNewCollection2.insertOne({x:2})

查看集合

show collections;

删除集合

db.myNewCollection2.drop()

文档操作内容

文档介绍

1、在Mongodb中将数据记录存储在文档中，此时文档存储的格式是JSON文档的二进制形式，叫做BSON格式（binary json）

2、文档的结构：字段和值。

2.1、字段的规则

a.字段名称不能包含空字符

b.在每个文档中，默认都会有一个名称为 _id 的字段。_id会保留用作主键，它的值是唯一的，不可变，并且可以是任何类型(数组类型除外)

2.2、值的类型:任何的BSON数据类型，文档、数组、文档数组

        var obj = {
            _id:"iiouw0928304820840820",
            name:{first:'alan',last:'ken'},
            contribs:['a','b','c']
        }

文档crud操作

注意：操作文档之前，要先切换到要操作的数据库，查看当前数据库

创建文档

创建文档的时候，就是往集合中插入文档。那么此时，如果集合不存在，会自动创建集合

    db.collection.insertOne()  //插入单个文档到集合中
    db.collection.insertMany()  //插入多个文档到集合中
    db.collection.insert() //将1个或者多个文档插入到集合中。这个方法过期了，不推荐使用。
//例子：
db.users.insertOne({
    name:'sue',
   age:30,
   status:'ready'
})

db.inventory.insertOne({
   item:'canvas',
    qty:100,
   tags:['cotton'],
   size:{h:28,w:35.5,uom:'cm'}
})

db.inventory.insertMany(
{item:'canvas',qty:100,tags:['cotton'],size:{h:28,w:35.5,uom:'cm'}}，
{item:'canvas',qty:100,tags:['cotton'],size:{h:28,w:35.5,uom:'cm'}}，
{item:'canvas',qty:100,tags:['cotton'],size:{h:28,w:35.5,uom:'cm'}}
)

查询文档

1. 基本查询

 //准备数据
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({}) // 习惯上，查询所有文档，在find()中传入 {}

// 格式化查询文档
db.inventory.find({}).pretty()

 //指定返回的文档字段(投影)
db.inventory.find({},{
    item:1,
    qty:1
})

// 相等条件查询，根据某个字段的值来过滤文档
db.inventory.find({
    status:'D'
})

// 指定AND条件：同时满足多个条件过滤文档
db.inventory.find({
    status:'A',
    qty:{
        // 模糊查询的条件
       $lt:30 // 表示小于30  less than
       $gt:30 // 大于30 greater than
    }
})


// 指定OR条件：满足其中一个条件过滤文档
db.inventory.find({
    $or:[
        {status:'A'},
        {qty:{$gt:30}}
    ]
})

 //指定AND和OR条件：复合查询，分解为最小化
 //需求：查询status为A 并且 qty小于30或者item以p开头  的文档
db.inventory.find({
    status:'A',
    $or:[
        {qty:{$lt:30}},
        {item:/^p/}
    ]
})


// 使用查询运算符指定条件 $in
// 需求：查询status是A 或者 D的文档
db.inventory.find({
    status:{$in:['A','D']}
})

2. 查询嵌套文档

// ！！！注意：在嵌套文档查询中，字段的顺序也会影响结果
db.inventory.find({
// 以下两种查询结果不同
    size:{h:14,w:21,uom:"cm"}
    size:{w:21,h:14,uom:'cm'}
})

 //查询嵌套字段:根据嵌套的文档中的字段作为条件来进行查询
 //需求：查询size字段中的uom等于in的所有文档
db.inventory.find({
    "size.uom":'in'
})

 //使用查询运算符(条件运算符、逻辑运算符)来指定匹配项
 //需求：查询size字段中字段h小于15的所有文档
db.inventory.find({
    "size.h":{$lt:15}
})

 //AND条件 + 查询嵌套字段 + 查询运算符
 //需求：查询嵌套字段h小于15，嵌套uom等于“in”，status字段的值等于“D”的所有文档
db.inventory.find({
    "size.h":{$lt:15},
    "size.uom":"in",
    status:"D"
})

3. 查询数组

 //准备数据
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 ] }
]);

 //根据指定的数组来查询文档
 //注意：在mongodb中，数组元素的顺序也会影响查询结果。
db.inventory.find({
    tags:["blank","red"]
})

 //在mongodb中，数组元素的顺序也会影响查询结果。如果不考虑顺序或者指定的条件数组是包含在字段的数组中的，那么可以用$all
db.inventory.find({
    tags:{$all:["blank","red"]}
})

// 根据数组中的某一个元素查询
 //需求：查询tags字段包含字符串“red”的所有文档
db.inventory.find({
    tags:"red"
})

 //根据数组元素结合运算符查询
 //需求：查询数组dim_cm中某个值大于25的所有文档
db.inventory.find({
    dim_cm:{$gt:25}
})



 //给数组元素指定多个条件
 //使用数组元素上的符合过滤条件查询
 //需求：查询文档，根据dim_cm的数组包含某些组合条件：数组中的一个元素满足大于15，另一个元素满足小于20或者单个元素同时满足多个条件
db.inventory.find({
    dim_cm:{
        $gt:15,
        $lt:20
    }
})

// 查询满足多个条件的数组元素
// 可以在值是数组的字段上指定多个条件，使 至少 一个数组元素满足所有指定的条件
// 需求：查询在dim_cm中包含至少一个元素同时大于22并且小于30的文档
db.inventory.find({
    dim_cm:{
       $elemMatch:{
        $gt:22,
        $lt:30
       }
    }
})

// 通过数组的索引位置查询元素
// 需求：查询数组dim_cm中第二个元素大于25的所有文档
db.inventory.find({
    "dim_cm.1":{
        $gt:25
    }
})

4. 查询嵌套文档的数组（数组中的元素是文档）

// 数据准备
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 } ] }
]);

 //查询与指定的字段中的某个文档相同的所有文档
// 需求：查询在字段instock中文档为{ warehouse: "A", qty: 5 }的所有文档(模糊查询)
db.inventory.find({
    "instock":{ warehouse: "A", qty: 5 }
})

 //注意：字段(数组)中的指定的条件为文档，这个文档中的字段的顺序也会影响查询结果
db.inventory.find({
    "instock":{ qty: 5,warehouse: "A"}
})

// 在嵌入的文档数组中的字段上指定查询条件
 //需求：查询嵌入文档的qty的值小于或者等于20的所有文档
db.inventory.find({
    'instock.qty': {$lte:20}
})

 //指定嵌套文档数组的字段满足多个查询条件
 //查询instock字段的数组中至少有一个嵌入式文档满足同时包含等于5的qty的字段和等于A的warehouse字段的所有文档
db.inventory.find({
    "instock":{
        $elemMatch:{qty:5,warehouse:'A'}
    }
})

5. 指定从查询返回的项目字段(投影)

//数据准备
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 } ] }
]);

// 查询指定条件的所有字段
 //需求：返回状态为A的集合中的所有文档的所有字段
db.inventory.find({
    status:'A'
})

 //返回指定的字段和_id字段
 //需求：返回状态为A的集合中的所有文档的item字段和status字段
db.inventory.find({
    status:'A'
},{
    _id:1,  // _id默认情况下会返回
    item:1,
    status:1
})

 //不需要返回_id，只要在投影中指定_id:0即可。
db.inventory.find({
    status:'A'
},{
    _id:0,
    item:1,
    status:1
})

 //注意：如果不需要返回某个字段，除了_id可以显示指定为0，其他不需要返回的字段不需要指定，需要返回的字段指定为1即可。
db.inventory.find({
    status:'A'
},{
    _id:0,
    item:1,
    //status:0 //不需要指定，指定了0会报错!!
})

 //返回嵌入式文档中的特定字段
 //需求:返回status为A的所有文档，只返回item字段、status字段、size中的文档的uom字段、_id字段
db.inventory.find({
    status:'A'
},{
    item:1,
    status:1,
    "size.uom":1
})


 返回的文档中排除某个字段
 需求：查询status值为A的所有文档，不返回size字段，其余字段都返回
db.inventory.find({
    status:'A'
},{
    size:0
})

 排除嵌入式文档中的特定字段
 需求：查询status值为A的所有文档，不返回size字段中嵌套文档中的uom字段
db.inventory.find({
    status:'A'
},{
    "size.uom":0
})

 返回数组中的特定数组元素
 需求：返回instock字段的数组中最后一个元素，用投影的方式
db.inventory.find({

},{
    item:1,
    status:1,
    instock:{
        $slice:-1
    }
})

6. 空字段或者缺少字段查询

// 准备测试数据
db.inventory.insertMany([
   { _id: 1, item: null },
   { _id: 2 }
])

// 查询item为null的文档,结果是返回值为null或者缺少字段的文档
db.inventory.find({
    item:null
})

 //只返回item为null的文档。           了解：BSON中指定null的类型的代号值为10
db.inventory.find({
    item:{$type:10}
})

 //只返回缺少字段的文档
db.inventory.find({
    item:{
        $exists:false
    }
})

更新文档

 //准备数据
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" }
] );

 //更新单个文档
db.inventory.updateOne({
    item:'paper'
},{
    $set:{'size.uom':'cm',status:'P'},
    $currentDate:{lastModified:true} // 自动产生更新时间，如果lastModified不存在，会自动创建lastModified
})

 //更新多个文档
db.inventory.updateMany({
    qty:{
        $lt:50
    }
},{
    $set:{'size.uom':'in',status:'P'},
    $currentDate:{lastModified:true} // 自动产生更新时间，如果lastModified不存在，会自动创建lastModified
})

 //替换文档
db.inventory.replaceOne({
    item:'paper'
},{
    item:'paper',
    size: { h: 85, w: 110, uom: "in" }
})

删除操作

//准备数据：
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" },
] );

 //批量删除 deleteMany()
 //全部删除
db.inventory.deleteMany({})

 //根据条件删除多条数据
db.inventory.deleteMany({
    status:'A'
})

 //单个删除 deleteOne(条件)
db.inventory.deleteOne({
    status:'P'
})