MongoDB: 简单使用

pymongo:

import pymongo

# 连接
client = pymongo.MongoClient(host=host, port=27017)

# 查看所有数据库名
client.list_database_names()


# 选择数据库 不存在则创建
db = client.DB_NAME

# 查看所有collection名
db.list_collection_names()

# 创建集合
db.create_collection("COLLECTION_NAME")

# 选择集合
collect = db.COLLECTION_NAME

# 删除集合
collect.drop() # 删除当前集合
db.drop_collection("COLLECTION_NAME") # 指定要删除的集合

# 增
collect.insert_one({"name":"Tom", "age": 18, "sex": "man"}) # insert_many 插入多条
# 删
collect.delete_one({"age":{"$lt":18}}) # delete_many
# 改
collect.update_one({"age":{"$lt":18}}, {"$set":{"age":19}}) # update_many 
$set: 在某一列上改， 没有$set:将整条数据替换

# 查
collect.find_one({query}) # 返回一条数据
collect.find({query}).limit(3) # 返回多条数据

# 创建索引
my_collection.create_index([("name", pymongo.DESCENDING),("sex", pymongo.ASCENDING)])
pymongo.DESCENDING:降序
pymongo.ASCENDING:升序
pymongo.Text: 文本索引，每个集合只能有一个文本索引但文本索引可包含多个字段
collect.find({'$text':{'$search':"man"}})# 使用文本索引进行搜索，文本索引中某个字段的值是否为“man”

# 聚合 aggregate
...

Mongo:

# MongoDb 基础
大小写敏感
### 基本概念
```text
database 数据库
collection 集合（表）
document 文档（数据行）
field 字段(列)
index 索引
primary key   主键
```
### 数据类型
```text
String, Integer, Boolean, Double, Min/Max keys(将一个BSON(json的二进制文件)元素的最低值和最高值比较)
Array， Timestamp, Object, Null, Symbol, Date, Object ID, Binary Data, Code, Regular expression
```
### 创建用户
```mongodb
use admin  
db.createUser({
  user: 'admin',  // 用户名
  pwd: '123456',  // 密码
  roles:[{
    role: 'root',  // 角色---超级管理员才可以使用该角色
    db: 'admin'  // 数据库
  }]
})
show users  // 查看当前库下的用户

db.dropUser('testadmin')  // 删除用户

db.updateUser('admin', {pwd: '654321'})  // 修改用户密码

db.auth('admin', '654321')  // 密码认证

```
### 连接
```shell
# 打开服务
mongod --dbpath /usr/local/mongodb/data/db --logpath /usr/local/mongodb/log --fork
port: 27017
# 连接
# mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
mongodb://[username:password@]host1[:port1][,host2[:port2]

```
### 创建数据库
```mongodb
# 使用use切换数据库不存在则创建，插入第一条数据时创建成功
use Practice
db.Practice.insertOne({})
```
### 删除数据库
```mongodb
db.dropdatabase()
```
### 操作集合

#### 创建删除集合
```mongodb
# 创建集合
db.createCollection(docName)
# 删除集合
db.collect_name.drop()
# 查看所有集合
show collections/tables
```
#### 插入文档
```mongodb
insert|insertOne|insertMany
db.collect_name.insert(document)
db.collect_name.insert([doc1, doc2...])
```
#### 更新文档
```mongodb
db.col_name.update(query,update,{upsert:bool,multi:bool,writeConcern:doc})/.updateOne() /.updateMany()
    query : update的查询条件，类似sql update查询内where后面的。
    update : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
    upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
    multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
    writeConcern :可选，抛出异常的级别。
db.grammer.update({"url":"www.runoob.com"}, {"main":"runoob"},{multi:true})
db.grammer.update({}, {$set: {"newField": value}}, {multi:true}) 
    # set 添加新的字段(列)
    # unset 删除字段
```
#### 更新字段名
```mongodb
db.col_name.update(query, {$set: {newName: "$oldName"}})
```
#### 删除文档
```mongodb
db.collect_name.remove({query:value}, {justOne:bool, writeConcern})
    justOne: 是否只删除一条文档， 默认false全部删除
db.collect_name.remove({}) # 删除所有文档
```

#### 查询文档
```mongodb
db.col_name.find().pretty() # 查看所有文档
        .pretty 以格式化的方式来显示所有文档。
        .limit(num) 限定读取的条数
        .skip(num) 跳过一定数量的doc（从多少条后开始find）
        .sort({key:1}) 根据key值进行排序 1：升序 -1： 降序
        skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()
    .findOne() 只返回一条文档
query:
    {}  所有文档
    =	{<key>:<value>}	db.col.find({"by":"菜鸟教程"}).pretty()	
    <   {<key>:{$lt:<value>}}	db.col.find({"likes":{$lt:50}}).pretty()
    <=	{<key>:{$lte:<value>}}	db.col.find({"likes":{$lte:50}}).pretty()
    >	{<key>:{$gt:<value>}}	db.col.find({"likes":{$gt:50}}).pretty()
    >=	{<key>:{$gte:<value>}}	db.col.find({"likes":{$gte:50}}).pretty()
    !=	{<key>:{$ne:<value>}}	db.col.find({"likes":{$ne:50}}).pretty()
    or  db.col.find({$or:[{"by":"菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()   
    $type db.col.find({"title" : {$type : 'string'}}) 选取title的值为string类型的doc

and: db.col.find({qury1, qury2}).pretty()
or : db.col.find({$or:[qury1, qury2]})
q1 and (q2 or q3): {q1, $or:[q2, q3]}
```
### 索引
#### 创建索引
```mongogdb
# db.collect_name.createIndex({keys: 1}, {options})
    1: 升序
    -1: 降序
    options:
        background: 创建索引时会阻塞其他操作，此参数可以设置为后台创建
        unique:建立索引是否唯一
        name: 设置索引名称
        sparse:
        expireAfterSeconds:设定一个秒为单位的数值， 完成TTL设定，设定集合生存时间
            注意：索引关键字必须是Date类型， 过期数据不立即删除， 文档数据默认60s扫描一次
        weights: 索引权重
        default_language:
        language_override:
        v: 索引版本号     
        
db.collect_name.createIndex({"id": 1},{background:true})
复合索引： db.collect_name.createIndex({"id":1, "description":-1})

文本索引：用于支持全文索引，一个集合只允许一个text索引，但可包含多个字段
db.collect_name.createIndex({name:"text", school:"text"})
db.grammer.find({$text:{$search: name_val|school_val}})
可以使用多个字段值进行搜索

```
#### 查看删除索引
```mongodb
# 查看所有索引
db.collect_name.getIndexes()

# 查看集合索引大小
db.collect_name.totalIndexSize()

# 删除集合所有索引
db.collect_name.dropIndexes()

# 删除集合指定索引
db.collect_name.dropIndex("index_name")
```

### 聚合
```mongodb
MongoDB 中聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果,类似 SQL 语句中的 count(*)。

db.col_name.aggregate(options)
    options:
        $match 过滤数据
            db.col_name.aggregate({$match:{query}}) 
        $group 分组
            # 将过滤后的数据根据colname分组， 并对同组的col2列的数据求和
            db.col_name.aggregate({$match:{query}}, {$group:{_id: "$colname", total:{$sum:"$col2_name"}}})
        $limit: 限制返回的文档数目
        $skip: 跳过指定数量的文档，返回其余数据
        $unwind: 将文档中的某个数组类型的列拆分，数组中每个数据与文档中的其他字段组成新文档
        $sort: 排序
        $project: 修改输入文档的结构，用于重命名，增加， 删除
        {$project: {col1:1, col2: 1, _id: 0}} 1: 该字段输入， 0：字段不输入
```