MongoDB数据库增删改查

MongoDB 的学习笔记

MongoDB 安装

Ubuntu 安装

sudo apt-get install mongodb

Mac 安装

brew install mongodb

MongoDB 启动

Ubuntu 启动方式

1. 启动服务方式（守护进程方式启动） (部署ubuntu服务器的时候基本使用这种方案)

会有 看门口狗 的方式，当 mongodb 闪退的时候，操作系统自动会重新启动

# 启动
sudo service mongodb start
# 停止
sudo service mongodb stop

2. 直接手动启动 (挂住终端的形式启动)

# 启动
sudo mongod
# 停止
输入 ctrl + C

注意事项:如果启动不成功
1. 请注意对默认路径 /data/db 是否有访问权限，解决方法使用 sudo 方式启动

sudo chmod -R 777 /data/db

1. 数据库的路径是否存在 /data/db,如果不存在就创建

Mac 启动

sudo mongod

mongod 启动参数说明

--dbpath 设置数据的路径（如果不传递就是 /data/db）
-f [--config] 配置文件路径 启动时使用配置文件进行启动
--fork 守护进程启动（必须携带 –logpath）
--auth 开启认证权限

命令行客户端链接

默认链接的IP地址: 127.0.0.1
默认端口: 27017

mongo

认证权限模式

如果没有启动 认证权限模式 对所有的数据全部有访问权限
开启权限
当没有任何用户时，默认情况下，第一步先是创建 root 用户
一旦创建好第一个root账号以后所有的访问权限都无效，需要使用root账号进行登录

// 进入管理员数据库
use admin
// 创建root账号
db.createUser({
    user: 'python',
    pwd:'123456',
    roles:["root"]
})

db.createUser({
    user: 'user_01',
    pwd:'123456',
    roles:[
        {
            db: 'db_01',
            role: 'readWrite' // 读写都支持，read 只读,write 只写
        }
    ]
})

db.createUser({
    user: 'user_02',
    pwd:'123456',
    roles:[
        {
            db: 'db_02',
            role: 'readWrite' // 读写都支持，read 只读,write 只写
        }
    ]
})

登录账号

// 进入管理员数据库
use admin
// 登录，如果返回 1 表示登录成功
db.auth('用户名','密码')

删除用户

use admin
// 可以删除用户但是希望使用另一种方式删除
db.removeUser('user_01')
// 或
db.dropUser('user_02')

数据库操作流程

mongodb 数据库有哪些组成

• 1. 数据库（database） -> 数据库
• 1. 集合（collections） -> 表
• 1. 文档 -> 行
• 1. field -> 字段
• 1. index
• 1. _id -> 主键

database 操作

获取数据库列表

show databases;

进入数据库

use 数据库名字

查看当前进入的数据库位置

db

创建database

// 进入某个数据库中，如果该数据库被添加数据自动创建
use 数据库

删除database

// 进入数据库
use 数据库
// 删除数据库
db.dropDatabase()

集合(表)操作

前提条件

use 数据库

查看所有的集合

show colllections

创建集合

创建第一种方案

db.createCollection('集合名称')

第二种方案
如果直接添加数据会自动创建集合

删除集合

db.集合名称.drop()

数据操作

前提条件

use 数据库

增加（insert）

// 单条查询
db.stu.insert(
    {
        name:"小明",
        age: 18
    }
)
// 定义变量插入
data = {
    name:"小红",
    age:20
}
db.stu.insert(data)

// 批量插入
data = [
    {
        name:"小王",
        age:26
    },
    {
        name:"小李",
        age:30
    }
]
db.stu.insertMany(data)

更新 (update)

格式 db.stu.update(“更新条件”,”更新内容”,”更新方式”)
默认更新整体更新

    db.stu.update(
        {
            name:"小王"
        },
        {
            age:12
        }
    )

局部更新方式 $set

    db.stu.update(
        {
            name:"小明"
        },
        {
            $set: {
                age:88
            }
        }
    )

批量更新，默认情况下只更新一条

    db.stu.update(
        {
            name:"小李"
        },
        {
            $set: {
                age: 14
            }
        },
        {
            multi:true  //默认不填写就是 false
        }
    )

删除 (delete)

// 默认情况下是全部符合条件的删除
db.stu.remove(
    {
        name:"小明"
    }
)
// 仅仅只删除一条
db.stu.remove(
    {
        name:"小李"
    },
    {
        justOne:true // 默认删除是false
    }
)

// 清空数据
db.stu.remove({})

数据：
db.stu.insert({_id : 1, name:’郭靖’,hometown:’蒙古’,age:20,gender:true})
db.stu.insert({_id : 2, name:’黄蓉’,hometown:’桃花岛’,age:18,gender:false})
db.stu.insert({_id : 3, name:’华筝’,hometown:’蒙古’,age:18,gender:false})
db.stu.insert({_id : 4, name:’黄药师’,hometown:’桃花岛’,age:40,gender:true})
db.stu.insert({_id : 5, name:’段誉’,hometown:’大理’,age:16,gender:true})
db.stu.insert({_id : 6, name:’段王爷’,hometown:’大理’,age:45,gender:true})

数据保存

根据 _id 进行判定，如果 _id 存在我就更新，如果 _id 不存在就插入

查询

1. 查询所有数据

db.stu.find()

1. 查询一条数据

db.stu.findOne()

1. 查询带条件

db.stu.find(
    {
        gender:false,
        hometown:"蒙古"
    }
)

1. 比较运算符查询($gt,$gte,$lt,$lte,$ne)

db.stu.find(
    {
        age:{$ne:20}
    }
)

1. 逻辑运算符($or)

db.stu.find(
    {
        $or:[
            {age:18,gender:true},
            {hometown:'蒙古'}
        ]
    }
)

1. 范围运算符($in,$nin)

// $in 两个数据要么 18 要么 45
db.stu.find(
    {
        hometown:{$in:["蒙古","桃花岛"]}
    }
)

1. 正则表达式

// 写法一
db.stu.find(
    {
        hometown:/^蒙/
    }
)
// 写法二
db.stu.find(
    {
        hometown:{$regex:"^蒙"}
    }
)

1. 自定义查询

db.stu.find(
    {
        $where: function() {
            return this.age > 10 && this.age < 30
        }
    }
)

1. limit 和 skip

//  limit 使用
db.stu.find().limit(2)

// skip 使用 
db.stu.find().skip(1)

// 同时使用 不管代码 在前还是在后都是 先 skip 后 limit
db.stu.find().limit(2).skip(1)
db.stu.find().skip(1).limit(2)

1. 投影,是否显示字段 (1:表示显示,0:表示不显示)

db.stu.find(
    {
        age:18
    },
    {
        _id:0
    }
)

1. 排序 （1 表示升序，-1 表示降序）

db.stu.find().sort(
    {
        age:1,
        hometown:1
    }
)

1. 统计个数

// 第一种写法
db.stu.find({age:18}).count()
// 第二种写法
db.stu.count(
    {
        age:18
    }
)

1. 消除重复

db.stu.distinct('hometown',{age:{$gt:18}})

聚合查询

格式

db.集合名称.aggregate([ 
    {管道 : {表达式}},
    {管道 : {表达式}},
    {管道 : {表达式}},
     ...
])

$group 管道对某些数据进行分组操作

$group 定义要分组的字段必须 _id 上，内容字段必须加上 $

// 按照性别分组，计算总数
db.stu.aggregate([
    {$group:{
            // _id 必须填写
            _id:'$gender',
            // $sum 对分组后的数据集合进行数量统计
            counter:{$sum:1}
        }
    }
])

// 按照性别分组，计算最大年龄
db.stu.aggregate([
    {$group:{
            // _id 必须填写
            _id:'$gender',
            max:{$max:'$age'}
        }
    }
])

// 按照性别分组，计算最小年龄
db.stu.aggregate([
    {$group:{
            // _id 必须填写
            _id:'$gender',
            min:{$min:'$age'}
        }
    }
])

// 按照性别进行分组，计算来自的地区
// $push 把具体数据放入列表
// $$ROOT 表示整条数据
db.stu.aggregate([
    {$group:{
            // _id 必须填写
            _id:'$gender',
            from:{$push:'$$ROOT'}
        }
    }
]).pretty()



// 按照性别进行分组,对分组内容计算平均值
db.stu.aggregate([
    {$group:{
            // _id 必须填写
            _id:'$gender',
            avgAge:{$avg:'$age'}
        }
    }
])

$match 管道 过滤数据

// match 基本操作
db.stu.aggregate([
    {
        $match:{
            age:{$gt:20}
        }
    } 
// 管道 结果 可以提供给下一个管道作为数据源

// 需求：去除所有小于20岁，对性别进行分组，获取来的家乡
db.stu.aggregate([
    {
        $match:{
            age:{$lt:20}
        }
    },
    {
        $group:{
            _id:"$gender",
            from:{$push:"$hometown"}
        }
    }
])

$project 对字段是否显示

// 需求：去除所有小于20岁，对性别进行分组，获取来的家乡
db.stu.aggregate([
    {
        $match:{
            age:{$lt:20}
        }
    },
    {
        $group:{
            _id:"$gender",
            from:{$push:"$hometown"}
        }
    },
    {
        $project:{
            _id:0
        }
    }
])

$sort 管道，排序，1:升序 -1:降序

db.stu.aggregate([
    {
        $match:{
            age:{$lt:20}
        }
    },
    {
        $sort:{
            age:1
        }
    }
])

$limit和$skip管道，2个同时使用需要注意顺序

db.stu.aggregate([
    {
        $match:{
            age:{$lt:20}
        }
    },
    {
        $sort:{
            age:1
        }
    },
    {
        $skip:1
    },
    {
        $limit:2
    }
])

$unwind 管道，拆分列表数据变成多条数据，默认情况下如果数据为空或者是空列表就过滤

数据构造：
db.t3.insert([
{ “_id” : 1, “item” : “a”, “size”: [ “S”, “M”, “L”] },
{ “_id” : 2, “item” : “b”, “size” : [ ] },
{ “_id” : 3, “item” : “c”, “size”: “M” },
{ “_id” : 4, “item” : “d” },
{ “_id” : 5, “item” : “e”, “size” : null }
])

db.t3.aggregate([
    {
        $unwind:'$size'
    }
])
// 不丢失数据
db.t3.aggregate([
    {
        $unwind: {
            path:"$size",
            preserveNullAndEmptyArrays:true // 不过滤数据，保留空列表和为空的数据
        }
    }
])

索引

创建索引

db.集合.ensureIndex({属性:1})

列出索引

db.t1.getIndexes()

删除索引

db.t1.dropIndex('索引名称')