第一篇：一天学会MongoDB数据库之Python操做

时间  2019-12-13
标签 一篇 一天 1天 学会 mongodb 数据库 python 栏目 MongoDB 繁體版
原文   原文链接

 本文仅仅学习使用，转自：https://www.cnblogs.com/suoning/p/6759367.html#3682005html

里面新增了若是用用Python代码进行增删改查python

什么是MongoDB ? 

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。linux

在高负载的状况下，添加更多的节点，能够保证服务器性能。web

MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。正则表达式

MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档相似于 JSON 对象。字段值能够包含其余文档，数组及文档数组。sql

主要特色

  • MongoDB的提供了一个面向文档存储，操做起来比较简单和容易。
  • 你能够在MongoDB记录中设置任何属性的索引 (如：FirstName="Ning",Address="Beijing")来实现更快的排序。
  • 你能够经过本地或者网络建立数据镜像，这使得MongoDB有更强的扩展性。
  • 若是负载的增长（须要更多的存储空间和更强的处理能力） ，它能够分布在计算机网络中的其余节点上这就是所谓的分片。
  • Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。
  • MongoDb 使用update()命令能够实现替换完成的文档（数据）或者一些指定的数据字段 。
  • Mongodb中的Map/reduce主要是用来对数据进行批量处理和聚合操做。
  • Map和Reduce。Map函数调用emit(key,value)遍历集合中全部的记录，将key与value传给Reduce函数进行处理。
  • Map函数和Reduce函数是使用Javascript编写的，并能够经过db.runCommand或mapreduce命令来执行MapReduce操做。
  • GridFS是MongoDB中的一个内置功能，能够用于存放大量小文件。
  • MongoDB容许在服务端执行脚本，能够用Javascript编写某个函数，直接在服务端执行，也能够把函数的定义存储在服务端，下次直接调用便可。
  • MongoDB支持各类编程语言:RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。

下载安装配置启动链接

官网：https://www.mongodb.com/download-center#community 下载对应系统的版本mongodb

linux系统的安装：shell

curl -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.6.tgz    # 下载
tar -zxvf mongodb-linux-x86_64-3.0.6.tgz                              # 解压
mv  mongodb-linux-x86_64-3.0.6/ /usr/local/mongodb                    # 将解压包拷贝到指定目录

export PATH=<mongodb-install-directory>/bin:$PATH      #<mongodb-install-directory> 为Mongo的安装路径，如本文的 /usr/local/mongodb 
mkdir -p /data/db      #建立数据库目录(启动指定--dbpath)

wins安装：数据库

 直接安装，在安装的过程当中可能会有失败的状况，注意把下面的勾去掉，而后下一步下一步就行了express

Compass就是个数据库管理工具，最先的时候没有集成Compass, 最先的时候是用Robo 3T这个工具管理数据库。

安装不上Compass的时候，就能够用Root 3T.

MongoDB术语

    

配置文件

mac系统下的配置：

suoningdeMacBook-Pro:~ suoning$ cat /usr/local/etc/mongod.conf 
systemLog:
  destination: file
  path: /usr/local/var/log/mongodb/mongo.log
  logAppend: true
storage:
  dbPath: /usr/local/var/mongodb
net:
  bindIp: 127.0.0.1
  port: 11811
suoningdeMacBook-Pro:~ suoning$

启动

mac：

$ ./mongod 
$ ./mongod --dbpath=/data/db --rest
# 默认端口为：27017
# MongoDB 提供了简单的 HTTP 用户界面。 若是你想启用该功能，须要在启动的时候指定参数 --rest
# MongoDB 的 Web 界面访问端口比服务的端口多1000。若是你的MongoDB运行端口使用默认的27017，
  你能够在端口号为28017访问web用户界面，即地址为：http://localhost:28017

win:

 

启动mongoDB 服务
cmd-> 进入安装目录的bin目录，执行命令：
mongod --dbpath=E:\Mongodata
其中：
mongod：是启动服务的.exe可执行文件
--dbpath=E:\Mongodata  配置的是未来数据的存储目录，须要实现建立好文件夹

E:\>E:\MongoDB\Server\4.0\bin\mongod --dbpath=E:\Mongodata
      
服务启动成功后出现：等待连接的提示就说明服务启动成功了

 

链接

要可以链接成功的前提就是要开启服务

mac:

$ sudo mongo
$ sudo mongo --port 11811
$ sudo mongo -u root -p pwd 127.0.0.1:11811/test

 win:能够经过Roob 3T来链接

安装pymongo

目的是要在Python里使用，因此接下来安装python插件,在cmd里安装，执行下面的命令便可

pip install pymongo

在Python里链接MongoDB

1. 如何使用Python代码去链接Mongo数据库

2.  经过代码操做：增

# 1. 导入MongoClient
from pymongo import MongoClient


# 首先，须要一个类，把对数据库的增删改查操做封装为一个接口
# 该类的名名字随便期
class Mongo(object):

    # 初始化，就是链接数据库
    # port:必须是个整数，不能加引号变成字符串
    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)

    # 插入数据
    def inert(self,database,collection,document):
        """
        :param database:  表示哪一个数据库
        :param collection: 表示哪一个表
        :param document:   表示哪一个记录
        :return:
        """
        # 1. 链接数据库
        _database = self.client.get_database(database)
        # 2.链接该库下面要操做的表
        _collection = _database.get_collection(collection)
        # 给表里插入一条数据
        result = _collection.insert_one(document)
        # 插入数据后，返回的是什么数据类型？数据是什么？下面打印出来看看
        print(type(result))   # <class 'pymongo.results.InsertOneResult'>
        print(dir(result))
        # ['_InsertOneResult__acknowledged', '_InsertOneResult__inserted_id', '_WriteResult__acknowledged', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', '_raise_if_unacknowledged', 'acknowledged', 'inserted_id']
        
　　　　 print(result)       # <pymongo.results.InsertOneResult object at 0x033A4DF0>
        print(result.inserted_id)   # 插入成功后返回的一个id
        print(result.acknowledged)  # 判断有没有插入成功，成功True，失败：False

    def __del__(self):
        self.client.close()


if __name__ == '__main__':
    mongo = Mongo()
    data = {
        # 若是指定了插入时的id值，就会用你指定的值，若是没有指定id值，插入后就会自动有个ObjectId("5bb9bc6aa236ce29f4898035")
        '_id':'5bb9bcb1a236ce2f008933ad',
        "name": '小甜甜',
        "age": 26
    }
    # 插入数据
    # 'trade_center':要插入的库，若是不存在，mongoDB会自动帮你建立这个库
    # 'users'：表，若是不存在，MongoDB会自动帮你建立表
    # data: 要插入到 trade_center库下面的users表里的数据
    mongo.inert('trade_center','users',data)
# 1. 导入MongoClient
from pymongo import MongoClient
# 导入
from pymongo.errors import DuplicateKeyError


class Mongo(object):

    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)

    # 插入数据
    def insert(self,database,collection,document):
       # 有时候插入数据时，会出现重复的状况，好比：
       # 自定义了id 且 表里已经有一个相同的id
       # 经过try...except ...处理掉异常
        try:
            _database = self.client.get_database(database)
            _collection = _database.get_collection(collection)
            result = _collection.insert_one(document)
            # 若是插入成功就返回一个result.acknowledged
            return result.acknowledged
        except DuplicateKeyError:
            return False

    def __del__(self):
        self.client.close()


if __name__ == '__main__':
    mongo = Mongo()
    data = {
        "name": '小甜甜',
        "age": 26,
        "Hobbit":['吃','喝','玩','乐']
    }
    mongo.insert('trade_center','users',data)
插入数据时若是出现重复的状况处理 
# 1. 导入MongoClient
from pymongo import MongoClient
from pymongo.errors import DuplicateKeyError

# insert_one()与insert_many()的主要区别是：
当一次要插入多条数据时，用insert_many(),
当一次只插入一条数据时，用insert_one()
    

class Mongo(object):

    # 初始化，就是链接数据库
    # port:必须是个整数，不能加引号变成字符串
    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)

    # 插入数据
    def insert(self,database,collection,document):
        try:
            _database = self.client.get_database(database)
            _collection = _database.get_collection(collection)
            #  若是document 是个字典，说明就是一个值，就能够用insert_one()
            # isinstance:是python里的函数，判断一个对象是个个字典，仍是个列表
            if isinstance(document,dict):
                result = _collection.insert_one(document)
                # 若是插入成功就返回一个result.acknowledged
                return result.acknowledged
            elif isinstance(document,list):
                result = _collection.insert_many(document)
                return result.acknowledged
            else:
                return False
        except DuplicateKeyError:
            return False

    def delete(self,database,collection,document):

        pass

    def update(self,database,collection,document):
        pass

    def search(self,database,collection,document):
        pass

    def __del__(self):
        self.client.close()


if __name__ == '__main__':
    mongo = Mongo()
    data =[
        {
            "name": '小臭臭',
            "age": 23,
            "Hobbit": ['吃', '玩']
        },
        {
            "name": '小美美',
            "age": 24,
            "Hobbit": ['喝', '乐']
        },
        {
            "name": '大宝',
            "age": 28,
            "Hobbit": [ '傻乐']
        },

    ]
    mongo.insert('trade_center','users',data)
insert_one()与insert_many()

3.经过代码操做：查

# 1. 导入MongoClient
from pymongo import MongoClient
from pymongo.errors import DuplicateKeyError

# 首先，须要一个类，把对数据库的增删改查操做封装为一个接口
# 该类的名名字随便期
class Mongo(object):

    # 初始化，就是链接数据库
    # port:必须是个整数，不能加引号变成字符串
    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)

    def search(self, database, collection, filter):
        """
        :param database:   数据库
        :param collection: 表
        :param filter:     查询条件,查询条件必须是个字典
        :return:
        """
        # 同理:先获取数据库
        # 再获得表
        # 最后就能够用该表去查找了
        _database = self.client.get_database(database)
        _collection = _database.get_collection(collection)
        # 把查询结果转化成列表
        results = list(_collection.find(filter))
        print(type(results))   # <class 'pymongo.cursor.Cursor'>
        print(dir(results))
        print(results)
        # 将查询结果return
        return results

    def __del__(self):
        self.client.close()


if __name__ == '__main__':
    mongo = Mongo()
    # 定义查询条件，查询条件必须是个字典
# 像下面的写法，是and的关系
    filter={
        "name":"小臭臭",
　　　　 # 注意：查询条件里，若是值是int等类型时，不能加“”，不然就会查不到数据，同理，删除/更新也是同样的
        "age":23
    }
    mongo.search('trade_center','users',filter)
# 1. 导入MongoClient
from pymongo import MongoClient
from pymongo.errors import DuplicateKeyError



# 首先，须要一个类，把对数据库的增删改查操做封装为一个接口
# 该类的名名字随便期
class Mongo(object):

    # 初始化，就是链接数据库
    # port:必须是个整数，不能加引号变成字符串
    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)

    # 插入数据
    # def insert(self,database,collection,document):
    #     try:
    #         _database = self.client.get_database(database)
    #         _collection = _database.get_collection(collection)
    #         #  若是document 是个字典，说明就是一个值，就能够用insert_one()
    #         # isinstance:是python里的函数，判断一个对象是个个字典，仍是个列表
    #         if isinstance(document,dict):
    #             result = _collection.insert_one(document)
    #             # 若是插入成功就返回一个result.acknowledged
    #             return result.acknowledged
    #         elif isinstance(document,list):
    #             result = _collection.insert_many(document)
    #             return result.acknowledged
    #         else:
    #             return False
    #     except DuplicateKeyError:
    #         return False

    def delete(self,database,collection,document):

        pass

    def update(self,database,collection,document):
        pass

    def search(self, database, collection, filter):
        """
        :param database:   数据库
        :param collection: 表
        :param filter:     查询条件,查询条件必须是个字典
        :return:
        """
        # 同理:先获取数据库
        # 再获得表
        # 最后就能够用该表去查找了
        _database = self.client.get_database(database)
        _collection = _database.get_collection(collection)
        # 把查询结果转化成列表
        results = list(_collection.find(filter))
        print(type(results))   # <class 'pymongo.cursor.Cursor'>
        print(dir(results))
        print(results)
        # 将查询结果return
        return results

    def __del__(self):
        self.client.close()


if __name__ == '__main__':
    mongo = Mongo()
    # 若是查询条件须要嵌套，经过.的方式一级级嵌套到key就行
    # 如："qiantao.namer":"大智"
    filter={
        "qiantao.namer":"大智"
    }
    mongo.search('trade_center','users',filter)
目标数据结构是嵌套的，嵌套查询条件怎么写？

4.经过代码操做：删

# 1. 导入MongoClient
from pymongo import MongoClient

class Mongo(object):

    # 初始化，就是链接数据库
    # port:必须是个整数，不能加引号变成字符串
    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)


    def delete(self, database, collection, filter):
        # filter: 删除的条件
        _database = self.client.get_database(database)
        _collection = _database.get_collection(collection)
        result = _collection.delete_many(filter)
        print(result.acknowledged)
        return result.acknowledged

    def __del__(self):
        self.client.close()


if __name__ == '__main__':
    mongo = Mongo()
    # 删除的条件，若是值是整数，不能加引号
    filter={
        "age":26
    }
    mongo.delete('trade_center','users',filter)

5.经过代码操做：改

# 1. 导入MongoClient
from pymongo import MongoClient
from pymongo.errors import DuplicateKeyError

class Mongo(object):

    # 初始化，就是链接数据库
    # port:必须是个整数，不能加引号变成字符串
    def __init__(self,host='localhost',port=27017):
        self.client = MongoClient(host,port)


    def update(self,database,collection,filter,document_to):
        _database = self.client.get_database(database)
        _collection = _database.get_collection(collection)
        # filiter: 更新的条件
        # update：第二个参数：便是否要更新的数据。即用update去更新那些符合filter条件的数据
        # 更新的操做:要更新的数据，首先是个字典，字典里面的格式为：{"$set":要更新的内容}
        result = _collection.update_many(filter,{"$set":document_to},upsert=True)

if __name__ == '__main__':
    mongo = Mongo()
  
  # filter:条件
    filter={
        "name":"小臭臭"
    }
    #  要更新成的数据
    document_to={
        "name":"小臭臭",
        "age":10,
        "Hobbit":["拉","pao"]
    }
    mongo.update('trade_center','users',filter,document_to)

 

安全验证

建立管理员

> use admin
switched to db admin
> db
admin
> db.createUser({user:'suoning',pwd:'123456',roles:[{role:'userAdminAnyDatabase',db:'admin'}]})
Successfully added user: {
    "user" : "suoning",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}
> exit
bye

修改配置文件

版本区别与更多配置：https://docs.mongodb.com/manual/administration/configuration/

suoningdeMacBook-Pro:~ suoning$ cat /usr/local/etc/mongod.conf 
systemLog:
  destination: file
  path: /usr/local/var/log/mongodb/mongo.log
  logAppend: true
storage:
  dbPath: /usr/local/var/mongodb
net:
  bindIp: 127.0.0.1
  port: 11811
security:
   authorization: enabled
suoningdeMacBook-Pro:~ suoning$

重启验证

> 
> show dbs
2017-04-25T08:41:50.126+0800 E QUERY    [thread1] Error: listDatabases failed:{
    "ok" : 0,
    "errmsg" : "not authorized on admin to execute command { listDatabases: 1.0 }",
    "code" : 13,
    "codeName" : "Unauthorized"
} :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
Mongo.prototype.getDBs@src/mongo/shell/mongo.js:62:1
shellHelper.show@src/mongo/shell/utils.js:761:19
shellHelper@src/mongo/shell/utils.js:651:15
@(shellhelp2):1:1
> 
> use admin
switched to db admin
> db.auth('suoning','123456')
1
> show dbs
admin  0.000GB
local  0.000GB
>

建立普通用户

> use admin
switched to db admin
> db.auth('suoning','123456')
1
> 
> use mydb
switched to db mydb
> db.createUser({user:'nick',pwd:'123456',roles:[{role:'readWrite',db:'mydb'}]})
Successfully added user: {
    "user" : "nick",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "mydb"
        }
    ]
}
> 
> db.auth('nick','123456')
1
>

删除用户

> db.dropUser("nick")
true

查看全部存在用户

> use admin
switched to db admin
> db.auth('suoning','123456')
1
> db.system.users.find()
{ "_id" : "admin.suoning", "user" : "suoning", "db" : "admin", "credentials" : { "SCRAM-SHA-1" : { "iterationCount" : 10000, "salt" : "XXW+MD0TENKSkzk0bM2EGw==", "storedKey" : "iIuv5DpGOksvaFpFOSnAIRSwh+w=", "serverKey" : "ZGA7/Lkjv+RJX3fNANQN9hgBUwY=" } }, "roles" : [ { "role" : "userAdminAnyDatabase", "db" : "admin" } ] }
{ "_id" : "mydb.nick", "user" : "nick", "db" : "mydb", "credentials" : { "SCRAM-SHA-1" : { "iterationCount" : 10000, "salt" : "j71pQs/OR1eRtRa1IT80+w==", "storedKey" : "5hkHmU+FwdENDgGjV0wIbmTAOrQ=", "serverKey" : "Qs+c0gfGNUpwD/ZKgeOackzwNxI=" } }, "roles" : [ { "role" : "readWrite", "db" : "mydb" } ] }
>

 

总结：

  • 建立超级管理员须要未开启权限模式的状况下执行;
  • 若是 MongoDB 开启了权限模式，而且某一个数据库没有任何用户时，在不验证权限的状况下，能够建立一个用户，当继续建立第二个用户时，会返回错误，若想继续建立用户则必须登陆;
  • 用户只能在用户所在数据库登陆，管理员须要经过admin认证后才能管理其余数据库。

 

数据库角色

  1. 内建的角色
  2. 数据库用户角色：read、readWrite;
  3. 数据库管理角色：dbAdmin、dbOwner、userAdmin；
  4. 集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
  5. 备份恢复角色：backup、restore；
  6. 全部数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
  7. 超级用户角色：root // 这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
  8. 内部角色：__system
角色说明：
Read：容许用户读取指定数据库
readWrite：容许用户读写指定数据库
dbAdmin：容许用户在指定数据库中执行管理函数，如索引建立、删除，查看统计或访问system.profile
userAdmin：容许用户向system.users集合写入，能够找指定数据库里建立、删除和管理用户
clusterAdmin：只在admin数据库中可用，赋予用户全部分片和复制集相关函数的管理权限。
readAnyDatabase：只在admin数据库中可用，赋予用户全部数据库的读权限
readWriteAnyDatabase：只在admin数据库中可用，赋予用户全部数据库的读写权限
userAdminAnyDatabase：只在admin数据库中可用，赋予用户全部数据库的userAdmin权限
dbAdminAnyDatabase：只在admin数据库中可用，赋予用户全部数据库的dbAdmin权限。
root：只在admin数据库中可用。超级帐号，超级权限

 

数据类型

数据类型 描述
String 字符串。存储数据经常使用的数据类型。在 MongoDB 中，UTF-8 编码的字符串才是合法的。
Integer 整型数值。用于存储数值。根据你所采用的服务器，可分为 32 位或 64 位。
Boolean 布尔值。用于存储布尔值（真/假）。
Double 双精度浮点值。用于存储浮点值。
Min/Max keys 将一个值与 BSON（二进制的 JSON）元素的最低值和最高值相对比。
Arrays 用于将数组或列表或多个值存储为一个键。
Timestamp 时间戳。记录文档修改或添加的具体时间。
Object 用于内嵌文档。
Null 用于建立空值。
Symbol 符号。该数据类型基本上等同于字符串类型，但不一样的是，它通常用于采用特殊符号类型的语言。
Date 日期时间。用 UNIX 时间格式来存储当前日期或时间。你能够指定本身的日期时间：建立 Date 对象，传入年月日信息。
Object ID 对象 ID。用于建立文档的 ID。
Binary Data 二进制数据。用于存储二进制数据。
Code 代码类型。用于在文档中存储 JavaScript 代码。
Regular expression 正则表达式类型。用于存储正则表达式。

 

库与表操做

建立库与表

> show dbs
admin  0.000GB
local  0.000GB
> 
> use mydb
switched to db mydb
> db
mydb
> 
> db.mydb.insert({"name":"Nick","age":18})
WriteResult({ "nInserted" : 1 })
> 
> show dbs
admin  0.000GB
local  0.000GB
mydb   0.000GB
>
> show tables;
mydb
>

 删除库

> db.dropUser("nick")
true
> 
> db.createUser({user:'nick',pwd:'123456',roles:[{role:'dbAdmin',db:'mydb'}]})
Successfully added user: {
    "user" : "nick",
    "roles" : [
        {
            "role" : "dbAdmin",
            "db" : "mydb"
        }
    ]
}
> 
> db.auth("nick","123456")
1
> 
> use mydb
switched to db mydb
> db
mydb
> 
> show dbs;
admin  0.000GB
local  0.000GB
mydb   0.000GB
>
> db.dropDatabase()
{ "dropped" : "mydb", "ok" : 1 }
> 
> show dbs;
admin  0.000GB
local  0.000GB
>

 删除表

> db;
mydb
> show tables;
mydb
> 
> db.mydb.drop();
true
> show tables;
>

 

文档操做

增

使用 insert() 或 save() 方法向集合中插入文档，语法以下：

db.COLLECTION_NAME.insert(document)

建立读写用户：

> db.createUser({user:'ning',pwd:'123456',roles:[{role:'readWrite',db:'mydb'}]})
Successfully added user: {
    "user" : "ning",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "mydb"
        }
    ]
}
> 
> db.auth('ning','123456')
1
>

插入数据：

> 
> db.user.insert({'name':'nick','age':18,'girlfriend':['jenny','coco','julia']})
WriteResult({ "nInserted" : 1 })
> 
> show tables
user
>
> 
> vb = ({'sex':'man'});
{ "sex" : "man" }
> db.user.insert(vb);
WriteResult({ "nInserted" : 1 })
>

 插入文档你也可使用 db.col.save(document) 命令。若是不指定 _id 字段 save() 方法相似于 insert() 方法。若是指定 _id 字段，则会更新该 _id 的数据。

 

删

remove() 方法的基本语法格式以下所示：

db.collection.remove(
   <query>,
   <justOne>
)

# MongoDB 是 2.6 版本之后的，语法格式以下：
db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)

# 参数说明：
query :（可选）删除的文档的条件。
justOne : （可选）若是设为 true 或 1，则只删除一个文档。
writeConcern :（可选）抛出异常的级别。

删除数据：

> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 18, "girlfriend" : [ "jenny", "coco", "julia" ] }
{ "_id" : ObjectId("58fef9165b9ea92ab29fbd4c"), "sex" : "man" }
> 
> db.user.remove({'sex':'man'})
WriteResult({ "nRemoved" : 1 })
> 
> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 18, "girlfriend" : [ "jenny", "coco", "julia" ] }
>

删除第一条找到的记录能够设置 justOne 为 1：

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

删除全部数据：

>db.col.remove({})
>db.col.find()
>

 

改

# 只更新一条
> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 21, "girlfriend" : [ "jenny", "coco", "julia" ] }
{ "_id" : ObjectId("58feffe55b9ea92ab29fbd4d"), "name" : "jenny", "age" : 21 }
> 
> db.user.update({'age':21},{$set:{'age':22}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> 
> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 22, "girlfriend" : [ "jenny", "coco", "julia" ] }
{ "_id" : ObjectId("58feffe55b9ea92ab29fbd4d"), "name" : "jenny", "age" : 21 }
> 

# 更新多条
> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 21, "girlfriend" : [ "jenny", "coco", "julia" ] }
{ "_id" : ObjectId("58feffe55b9ea92ab29fbd4d"), "name" : "jenny", "age" : 21 }
> 
> db.user.update({'age':21},{$set:{'age':22}},{multi:true})
WriteResult({ "nMatched" : 2, "nUpserted" : 0, "nModified" : 2 })
> 
> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 22, "girlfriend" : [ "jenny", "coco", "julia" ] }
{ "_id" : ObjectId("58feffe55b9ea92ab29fbd4d"), "name" : "jenny", "age" : 22 }
>

save() 方法经过传入的文档来替换已有文档。语法格式以下：

db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)

参数说明：
document : 文档数据。
writeConcern :可选，抛出异常的级别。
> db.user.find()
{ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 22, "girlfriend" : [ "jenny", "coco", "julia" ] }
> 
> db.user.save({ "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"), "name" : "nick", "age" : 18, "girlfriend" : [ "jenny", "julia" ] })
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> 
> db.user.find().pretty()
{
    "_id" : ObjectId("58fef7d55b9ea92ab29fbd4b"),
    "name" : "nick",
    "age" : 18,
    "girlfriend" : [
        "jenny",
        "julia"
    ]
}
>

 

查

查询数据的语法格式以下：

db.mydb.find(query, projection)

query ：可选，使用查询操做符指定查询条件
projection ：可选，使用投影操做符指定返回的键。查询时返回文档中全部键值， 只需省略该参数便可（默认省略）。
pretty() 方法以格式化的方式来显示全部文档。
>db.mydb.find().pretty()

大于小于：

操做 格式 范例 RDBMS中的相似语句
等于 {<key>:<value>} db.col.find({"name":"nick"}).pretty() where name = 'nick'
小于 {<key>:{$lt:<value>}} db.col.find({"likes":{$lt:50}}).pretty() where likes < 50
小于或等于 {<key>:{$lte:<value>}} db.col.find({"likes":{$lte:50}}).pretty() where likes <= 50
大于 {<key>:{$gt:<value>}} db.col.find({"likes":{$gt:50}}).pretty() where likes > 50
大于或等于 {<key>:{$gte:<value>}} db.col.find({"likes":{$gte:50}}).pretty() where likes >= 50
不等于 {<key>:{$ne:<value>}} db.col.find({"likes":{$ne:50}}).pretty() where likes != 50

获取"col"集合中 "likes" 大于100，小于 200 的数据，你可使用如下命令：

db.col.find({likes : {$lt :200, $gt : 100}}) 

 and or:

and:
    >db.col.find({key1:value1, key2:value2}).pretty()
or:
    >db.col.find(
       {
          $or: [
             {key1: value1}, {key2:value2}
          ]
       }
    ).pretty()

Limit、Skip

limit()方法基本语法以下所示：

>db.COLLECTION_NAME.find().limit(NUMBER)

skip() 方法脚本语法格式以下：

使用skip()方法来跳过指定数量的数据，skip方法接受一个数字参数做为跳过的记录条数，默认为0。

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

 sort

sort()方法对数据进行排序，sort()方法能够经过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。

>db.COLLECTION_NAME.find().sort({KEY:1})

操做符 $type

获取 "col" 集合中 title 为 String 的数据:

db.col.find({"title" : {$type : 2}})

对应匹配类型：

类型 数字 备注
Double 1  
String 2  
Object 3  
Array 4  
Binary data 5  
Undefined 6 已废弃。
Object id 7  
Boolean 8  
Date 9  
Null 10  
Regular Expression 11  
JavaScript 13  
Symbol 14  
JavaScript (with scope) 15  
32-bit integer 16  
Timestamp 17  
64-bit integer 18  
Min key 255 Query with -1.
Max key 127  

 

索引

使用 ensureIndex() 方法来建立索引，语法以下：

>db.COLLECTION_NAME.ensureIndex({KEY:1})

语法中 Key 值为你要建立的索引字段，1为指定按升序建立索引，若是你想按降序来建立索引指定为-1便可
复合索引
db.col.ensureIndex({"title":1,"description":-1})
后台执行
经过在建立索引时加background:true 的选项，让建立工做在后台执行
db.values.ensureIndex({open: 1, close: 1}, {background: true})

ensureIndex() 接收可选参数，可选参数列表以下：

Parameter Type Description
background Boolean 建索引过程会阻塞其它数据库操做，background可指定之后台方式建立索引，即增长 "background" 可选参数。 "background" 默认值为false。
unique Boolean 创建的索引是否惟一。指定为true建立惟一索引。默认值为false.
name string 索引的名称。若是未指定，MongoDB的经过链接索引的字段名和排序顺序生成一个索引名称。
dropDups Boolean 在创建惟一索引时是否删除重复记录,指定 true 建立惟一索引。默认值为 false.
sparse Boolean 对文档中不存在的字段数据不启用索引；这个参数须要特别注意，若是设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false.
expireAfterSeconds integer 指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
v index version 索引的版本号。默认的索引版本取决于mongod建立索引时运行的版本。
weights document 索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其余索引字段的得分权重。
default_language string 对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语
language_override string 对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language.

索引不能被如下的查询使用：

  • 正则表达式及非操做符，如 $nin, $not, 等。
  • 算术运算符，如 $mod, 等。
  • $where 子句

最大范围

  • 集合中索引不能超过64个
  • 索引名的长度不能超过125个字符 
  • 一个复合索引最多能够有31个字段
  • 现有的索引字段的值超过索引键的限制，MongoDB中不会建立索引。

 

聚合

聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。

聚合的方法使用aggregate()方法，基本语法格式以下所示：

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])

以上实例相似sql语句： select by_user, count(*) from mycol group by by_user
咱们经过字段by_user字段对数据进行分组，并计算by_user字段相同值的总和。
表达式 描述 实例
$sum 计算总和。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
$avg 计算平均值 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
$min 获取集合中全部文档对应值得最小值。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
$max 获取集合中全部文档对应值得最大值。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
$push 在结果文档中插入值到一个数组中。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])
$addToSet 在结果文档中插入值到一个数组中，但不建立副本。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
$first 根据资源文档的排序获取第一个文档数据。 db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
$last 根据资源文档的排序获取最后一个文档数据 db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

管道

MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操做是能够重复的。

表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

  • $project：修改输入文档的结构。能够用来重命名、增长或删除域，也能够用于建立计算结果以及嵌套文档。
  • $match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操做。
  • $limit：用来限制MongoDB聚合管道返回的文档数。
  • $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
  • $unwind：将文档中的某一个数组类型字段拆分红多条，每条包含数组中的一个值。
  • $group：将集合中的文档分组，可用于统计结果。
  • $sort：将输入文档排序后输出。
  • $geoNear：输出接近某一地理位置的有序文档。

管道操做符实例

一、$project实例

db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );
这样的话结果中就只还有_id,tilte和author三个字段了，默认状况下_id字段是被包含的，若是要想不包含_id话能够这样:
db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

2.$match实例

db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );
$match用于获取分数大于70小于或等于90记录，而后将符合条件的记录送到下一阶段$group管道操做符进行处理。

3.$skip实例

db.article.aggregate(
    { $skip : 5 });
通过$skip管道操做符处理后，前五个文档被"过滤"掉。

 

查询分析

explain()

mongo执行计划分析，详细点此处。

> db.user.find({"name":"nick"}).explain();
> db.user.find({"name":"nick"}).explain(true);

关键参数详细：

executionStats.executionSuccess
是否执行成功

executionStats.nReturned
查询的返回条数

executionStats.executionTimeMillis
总体执行时间

executionStats.totalKeysExamined
索引扫描次数

executionStats.totalDocsExamined
document扫描次数

 

hint()

使用 hint 来强制 MongoDB 使用一个指定的索引。

这种方法某些情形下会提高性能。 一个有索引的 collection 而且执行一个多字段的查询(一些字段已经索引了)。

以下查询指定了使用 naem 和 age 索引字段来查询：
> db.user.find({"name":"nick","age":18}).hint({"name":1,"age":1});
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程