关于SegmentFault:MongoDB使用教程

作者 changhao
邮箱 <wu_chang_hao@qq.com>
版本 1.0

知识点

• Mongodb 装置
• mongo 命令应用
• mongo 根底操作
• pymongo 模块应用

Mongodb 装置

windows 装置形式

1). 下载安装包

MongoDB 提供了可用于 32 位和 64 位零碎的预编译二进制包，你能够从 MongoDB 官网下载安装，MongoDB 预编译二进制包下载地址：https://www.mongodb.com/downl…

2). 装置

指定装置门路，我这里装置在 D:\software\mongodb，增加 D:\software\mongodb\bin 到环境变量中。

3). 新建目录与文件夹

D:\software\mongodb\data\db
D:\software\mongodb\log\mongod.log

4). 新建配置文件 D:\software\mongodb\mongod.cfg

systemLog:
  destination: file
  path: "D:/software/mongodb/log/mongod.log"
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: "D:/software/mongodb/data/db"
net:
  bindIp: 0.0.0.0
  port: 27017
setParameter:
  enableLocalhostAuthBypass: false

5). 制作零碎服务

mongod --config "D:\software\mongodb\mongod.cfg" --bind_ip 0.0.0.0 --install

或者间接在命令行指定配置

mongod --bind_ip 0.0.0.0 --port 27017 --logpath D:\software\mongodb\log\mongod.log --logappend --dbpath    D:\software\mongodb\data\db --serviceName "mongodb" --serviceDisplayName "mongodb" --install

6). 启动 MongoDB 服务

net start MongoDB
net stop MongoDB

7). 登录 MongoDB

mongo
链接：http://www.runoob.com/mongodb/mongodb-window-install.html
  当没有账号密码登录的时候，默认就是管理员登录。，因为刚刚做零碎服务 install 的时候没有指定
  --auth(没有指定则没有权限认证这一说),(相当于 mysql 跳过受权表启动一样)

8). 创立有权限的用户

use admin
db.createUser(
    {
        user: "root",  # 这个 root 能够轻易写
        pwd: "123",
        roles: [{role: "root", db: "admin"}]  # 权限，role 是 root 阐明是管理员，}
)

use test
db.createUser(
    {
        user: "test",
        pwd: "123",
        roles: [{role: "readWrite", db: "test"},  # 针对 test 库有读写权限，操作本人的库有读写权限
        {role: "read", db: "db1"}
        ]  # 针对 db1 库读权限, 操作其余库有读权限
    }
)

9). 重启数据库

mongod --remove
mongod --config "D:\software\mongodb\mongod.cfg" --bind_ip 0.0.0.0 --install --auth

# 或者
mongod --bind_ip 0.0.0.0 --port 27017 --logpath D:\software\mongodb\log\mongod.log --logappend --dbpath
D:\software\mongodb\data\db --serviceName "MongoDB" --serviceDisplayName "MongoDB" --install --auth

10). 从新登录

# 形式一
mongo --port 27017 -u "root" -p "123" --authenticationDatabase "admin"
# 形式二：在登录之后用 db.auth("账号","明码")登录
mongo
use admin
db.auth("root","123")

Linux 装置形式

1). 装置依赖

yum install -y libcurl openssl

2). 下载 MongoDB 源码装置或 yum 管理器装置

# mongodb 源码下载地址
https://www.mongodb.com/download-center#community

# 或 yum 装置
yum install -y mongodb

3). 创立数据库目录

# 创立目录，并设置用户权限
mkdir -p /var/lib/mongo
mkdir -p /var/log/mongodb
chown `whoami` /var/lib/mongo
chown `whoami` /var/log/mongodb

4). 配置 mongo 服务参数, 容许所有 ip 拜访

mongod --dbpath /var/lib/mongo --logpath /var/log/mongodb/mongod.log --bind_ip_all --fork

5). 或者批改配置文件 /etc/mongod.conf

# mongod.conf
  
# for documentation of all options, see:
#   http://docs.mongodb.org/manual/reference/configuration-options/

# Where and how to store data.
storage:
  dbPath: /var/lib/mongo
  journal:
    enabled: true
#  engine:
#  mmapv1:
#  wiredTiger:

# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb/mongod.log

# network interfaces
net:
  port: 27017
  bindIp: true


# how the process runs
processManagement:
  timeZoneInfo: /usr/share/zoneinfo

6). 后盾启动

mongod -f /etc/mongod.conf &

7). 登录 mongodb

# 登录
mongo

# 创立数据库 test
use test

# 查看以后的数据库
db

mongo 命令应用

# 连贯到任何数据库 config
mongo 127.0.0.1:27017/config

# 不连贯任何数据库
mongo --nodb

# 启动之后，在须要时运行 new Mongo(hostname)命令就能够连贯到想要的 mongod 了
conn = new Mongo('127.0.0.1:27017')
db = conn.getDB('admin')

# 显示以后数据库所有的数据库
show databases   或者  show dbs

# 应用某个数据库，不存在则创立
use database

# 删除数据库
db.dropDatabase()

mongo 根底操作

在 MongoDB 中相干术语的解释和 sql 术语对应关系

有一些数据库名是保留的，能够间接拜访这些特殊作用的数据库

• admin: 从权限的角度来看，这是 ”root” 数据库。要是将一个用户增加到这个数据库，这个用户主动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比方列出所有的数据库或者敞开服务器。
• local: 这个数据永远不会被复制，能够用来存储限于本地单台服务器的任意汇合
• config: 当 Mongo 用于分片设置时，config 数据库在外部应用，用于保留分片的相干信息。

汇合 (表) 的增删改

use test
# 减少表内容
db.table1.insert({"a":1})
db.table2.insert({"b":2})

# 查看表
show collections  或者 show tables

# 删除
db.user.info.help()  # 查看帮忙
db.user.info.drop()

# 帮忙，不明确就 help()
db.table.help()     # 举例

减少操作

# 插入单条数据
user0 = {
    "name": "changhao",
    "age": "23",
    "hobbies": ['music', 'read', 'dancing'],
    "addr": {
        "country": 'China',
        "city": 'BJ',
    }
}
# 形式一
db.table1.insert(user0)
# 形式二
db.table1.insertOne(user0)

# 插入多条数据
user1 = {
    "_id": 1,
    "name": "changhao1",
    "age": "23",
    "hobbies": ['music', 'read', 'dancing'],
    "addr": {
        "country": 'China',
        "city": 'BJ',
    }
}

user2 = {
    "_id": 2,
    "name": "changhao2",
    "age": "23",
    "hobbies": ['music', 'read', 'dancing'],
    "addr": {
        "country": 'China',
        "city": 'BJ',
    }
}
# 形式一
db.table1.insertMany(user1, user2)
# 形式二
db.table1.insertMany([user1, user2])

查找操作

# 查看所有记录
db.table1.find()

# 丑化输入
db.table1.find().pretty()

# 查找符合条件的所有
db.table1.find({"name": "changhao"})

# 查找符合条件的第一条
db.table1.findOne({"name": "changhao"})

条件查找 - 比拟运算

# id = 1
db.table1.find({"_id":1})

# id != 1
db.table1.find({"_id": {"$ne": 1}})

# id < 2
db.table1.find({"_id": {"$lt": 1}})

# id > 1
db.table1.find({"_id": {"$gt": 1}})

# id >= 1
db.table1.find({"_id": {"$gte": 1}})

# id <= 2
db.table1.find({"_id": {"$lte": 1}})

条件查找 - 逻辑运算

# 逻辑运算:$and,$or,$not
# id >=3 and id <= 4
db.table1.find({"_id": {"$gte":3, "$lte":4}})

# id >=3 and id <=4 and age >=40
db.table1.find({"_id":{"$gte":3,"$lte":4},
    "age":{"$gte":40}
})
或者
db.table1.find({"$and":[{"_id":{"$gte":3,"$lte":4}},  # 一个字典就是一个条件
    {"age":{"$gte":40}}
]})

# id >=0 and id <=1 or id >=4 or name = "changhao"
db.table1.find({"$or": [{"_id": {"$lte": 1, "$gte": 0}},
{"_id": {"$gte": 4}},
{"name": "changhao"}
]})

# id % 2 = 1  奇数
db.table1.find({"_id": {"$mod": [2, 1]}})

# 偶数, 取反
db.table1.find({"_id": {"$mod": [2, 1]}})

正则匹配

db.table1.find({"name":/^jin.*?(g|n)$/i
})

排序、跳过、截取

# 排序，依据年龄排序，1 位正序，1 位倒序
db.table1.find().sort("age": 1)
# 选取两条数据
db.table1.find().limit(2)
# 跳过查问的数据的前 2 条
db.table1.find().skip(2)
db.table1.sort({"age":-1}).skip(0).limit(2)

记录批改

语法格局如下

db.collection.update(
    <query>,
    <update>,
    {
        upsert: <boolean>,
        multi: <boolean>,
        writeConcern: <document>
    }
)

参数阐明：

• query: 相当于 where 条件
• update: update 的对象和一些更新的操作符(如 inc… 等, 相当于 set 前面的)
• upsert: 可选, 默认为 false, 代表如果不存在 update 的记录不更新也不插入，设置为 true 代表插入。
• multi: 可选，默认 false，代表只更新找到的第一条记录，设置 true, 代表更新找到的全副记录。
• writeConcern：可选, 抛出异样的级别。

实战语句

# 1. 笼罩式
db.table1.update({'age': 20}, {"name": "changhao"})

# 2. 这一种简略的更新，齐全替换匹配
var obj = db.table1.findOne({"_id": 2})
obj.username = obj.name + 'test'
obj.age = 23
db.table1.update({"_id": 1}, obj)

设置

# 设置 $set
通常文档只会有一部分须要更新。能够应用原子性的更新修改器，指定对文档中的某些字段进行更新。更新修改器是种非凡的键，用来指定简单的更新操作，比方批改、减少后者删除

# set  name="changhao" where id = 2
db.table1.update({'_id': 2}, {"$set": {"name": "changhao", "age": 23}, {"upsert":true})

# 没有匹配胜利则新增一条{"upsert":true}
db.table1.update({'_id':2},{"$set":{"name":"changhao", "age":23}},{"upsert":true})

# 默认只改匹配胜利的第一条,{"multi": 改多条}
db.table1.update({'_id':{"$gt":4}},{"$set":{"age":28}})
db.table1.update({'_id':{"$gt":4}},{"$set":{"age":38}},{"multi":true})

# 批改内嵌文档，把名字为 test 的人所在的地址国家改成 Japan
db.table1.update({'name':"test"},{"$set":{"addr.country":"Japan"}})

# 把名字为 test 的人的地 2 个喜好改成 piao
db.table1.update({'name':"test"},{"$set":{"hobbies.1":"piao"}})

# 删除 test 的喜好,$unset
db.table1.update({'name':"test"},{"$unset":{"hobbies":""}})

减少和缩小

# 减少和缩小 $inc
# 1. 所有人年龄减少一岁
db.table1.update({},
    {"$inc":{"age":1}
    },
    {"multi":true}
)
# 2. 所有人年龄缩小 5 岁
db.user.update({},
    {"$inc":{"age":-5}
    },
    {"multi":true}
)

删除

# 删除多个中的第一个
db.table1.deleteOne({"age":8})

# 删除国家为 China 的全副
db.table1.deleteMany({"addr.country": "China"})

pymongo 模块应用

连贯数据库

import pymongo
client = pymongo.MongoClient("192.168.158.137", 27017)
# 显示服务器上的所有数据库
dblist = client.database_names()

print(dblist)
# 打印信息：['admin', 'config', 'local', 'test']

# 连贯数据库，获取库，如果库名存在，则应用，不存在创立
db = client['test']

减少数据库内容

# 减少单条
mydict = {"name": "changhao001", "age": 23}
res = db.table1.insert_one(mydict)
print(res.inserted_id)                # 返回 ObjectId 对象

# 减少多条
mylist = [{"name": "changhao002", "age": 23}, {"name": "changhao003", "age": 23}]
res = db.table1.insert_many(mylist)
print(res.inserted_ids)                # 返回 ObjectId 对象列表

查问语句

查问一条语句

# 查问一条数据
res1 = db.table1.find_one({'name': 'changhao1'})
print(res1.items())             # 查看匹配的数据内容

查问汇合中的所有数据或多条

# 查问汇合中的所有数据或多条
res2 = db.stu.find({})          # 查问所有记录
res3 = db.stu.find({"age": 23})

高级查问

# 年龄大于 20 岁的
myquery = {"age": {"$gt": 20}}
res = db.table1.find(myquery)

正则表达式查问

# 读取 name 字段中第一个字母为 "c" 的数据
myquery = {"name": {"$regex": "^c"}}
res = db.table1.find(myquery)
# 遍历出匹配的数据
for x in res: print(x)

查问后果排序，跳过，截取条数

# 查问后果的排序，跳过，和截取
sort_res = list(db.table1.find().sort("age", pymongo.DESCENDING))   # 查问所有后果，并依据年龄的降序排序
skip_res = list(db.table1.find().skip(2))                           # 查问所有后果，并过滤掉前两条
limit_res = list(db.table1.find().limit(2))                         # 查问所有后果，并截取前两条

# 分页成果
pagination_res = list(db.table1.find().sort("age", pymongo.DESCENDING).limit(2).skip(2))

批改语句

# 查问到间接更新设置值
res = db.table1.update_one({'_id': 1}, {"$set": {"name": "changhao_update"}})
print(res.modified_count)

# 查问到记录, 在字典中增加值
res = db.table1.find_one({"name": "changhao_update"})
res['age'] = 20
# 将值更新到记录中
res = db.table1.update_one({"name": "changhao_update"}, {"$set": res})
print(res.modified_count)

删除语句

删除单条

# 删除后果中的一条
res = db.table1.delete_one({"name": "changhao_update"})
print(res.deleted_count)

删除多条

# 删除多条, 正则匹配的数据
query = {"name": {"$regex": "^c"}}
res = db.table1.delete_many(query)
print(res.deleted_count)

# 删除所有
del_res = db.table1.delete_many({})