天天看点
返回

MongoDB数据库增删改查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

 方式启动
  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 数据库
查看所有的集合
创建集合
创建第一种方案 
db.createCollection('集合名称')

第二种方案

如果直接添加数据会自动创建集合

删除集合 
db.集合名称.drop()

数据操作

前提条件 
use 数据库
增加（insert） 
// 单条查询
db.stu.insert(
    {
        name:"小明",
        age: 
    }
)
// 定义变量插入
data = {
    name:"小红",
    age:
}
db.stu.insert(data)

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

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

默认更新整体更新

db.stu.update(
        {
            name:"小王"
        },
        {
            age:
        }
    )
局部更新方式

$set

 
db.stu.update(
        {
            name:"小明"
        },
        {
            $set: {
                age:
            }
        }
    )
批量更新，默认情况下只更新一条 
db.stu.update(
        {
            name:"小李"
        },
        {
            $set: {
                age: 
            }
        },
        {
            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:}
    }
)
  1. 逻辑运算符($or) 
db.stu.find(
    {
        $or:[
            {age:,gender:true},
            {hometown:'蒙古'}
        ]
    }
)
  1. 范围运算符( in, i n , 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 >  && this.age < 
        }
    }
)
  1. limit 和 skip 
//  limit 使用
db.stu.find().limit()

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

// 同时使用 不管代码 在前还是在后都是 先 skip 后 limit
db.stu.find().limit().skip()
db.stu.find().skip().limit()
  1. 投影,是否显示字段 (1:表示显示,0:表示不显示) 
db.stu.find(
    {
        age:
    },
    {
        _id:
    }
)
  1. 排序 （1 表示升序，-1 表示降序） 
db.stu.find().sort(
    {
        age:,
        hometown:
    }
)
  1. 统计个数 
// 第一种写法
db.stu.find({age:}).count()
// 第二种写法
db.stu.count(
    {
        age:
    }
)
  1. 消除重复 
db.stu.distinct('hometown',{age:{$gt:}})

聚合查询

格式 
db.集合名称.aggregate([ 
    {管道 : {表达式}},
    {管道 : {表达式}},
    {管道 : {表达式}},
     ...
])
$group 管道对某些数据进行分组操作

$group

 定义要分组的字段必须

_id

 上，内容字段必须加上

$

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

// 按照性别分组，计算最大年龄
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岁，对性别进行分组，获取来的家乡
db.stu.aggregate([
    {
        $match:{
            age:{$lt:}
        }
    },
    {
        $group:{
            _id:"$gender",
            from:{$push:"$hometown"}
        }
    }
])

$project

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

$sort

 管道，排序，1:升序 -1:降序 
db.stu.aggregate([
    {
        $match:{
            age:{$lt:}
        }
    },
    {
        $sort:{
            age:
        }
    }
])

$limit

 和

$skip

 管道，2个同时使用需要注意顺序 
db.stu.aggregate([
    {
        $match:{
            age:{$lt:}
        }
    },
    {
        $sort:{
            age:
        }
    },
    {
        $skip:
    },
    {
        $limit:
    }
])

$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({属性:})
列出索引 
db.t1.getIndexes()
删除索引 
db.t1.dropIndex('索引名称')
数据库 mongodb
上一篇: mybatis一对一查询演示
下一篇: MongoDB数据库的增删改查

继续阅读