zoukankan      html  css  js  c++  java
  • MongoDB

    MongoDB

    可视化工具点击

    MongoDB是一款强大、灵活、且易于扩展的通用型数据库。默认端口27017

    MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
    MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。

    下载安装

    download

    mongodb的优势

    一、MongoDB基础知识

    1、文档是MongoDB的核心概念。文档就是键值对的一个有序集{'msg':'hello','foo':3}。类似于python中的有序字典。
    需要注意的是:
    #1、文档中的键/值对是有序的。
    #2、文档中的值不仅可以是在双引号里面的字符串,还可以是其他几种数据类型(甚至可以是整个嵌入的文档)。
    #3、MongoDB区分类型和大小写。
    #4、MongoDB的文档不能有重复的键。
    #5、文档中的值可以是多种不同的数据类型,也可以是一个完整的内嵌文档。文档的键是字符串。除了少数例外情况,键可以使用任意UTF-8字符。
    
    文档键命名规范:
    #1、键不能含有\0 (空字符)。这个字符用来表示键的结尾。
    #2、.和$有特别的意义,只有在特定环境下才能使用。
    #3、以下划线"_"开头的键是保留的(不是严格要求的)。
    
    2、集合就是一组文档。如果将MongoDB中的一个文档比喻为关系型数据的一行,那么一个集合就是相当于一张表
    #1、集合存在于数据库中,通常情况下为了方便管理,不同格式和类型的数据应该插入到不同的集合,但其实集合没有固定的结构,这意味着我们完全可以把不同格式和类型的数据统统插入一个集合中。
    
    #2、组织子集合的方式就是使用“.”,分隔不同命名空间的子集合。
    比如一个具有博客功能的应用可能包含两个集合,分别是blog.posts和blog.authors,这是为了使组织结构更清晰,这里的blog集合(这个集合甚至不需要存在)跟它的两个子集合没有任何关系。
    在MongoDB中,使用子集合来组织数据非常高效,值得推荐
    
    #3、当第一个文档插入时,集合就会被创建。合法的集合名:
    集合名不能是空字符串""。
    集合名不能含有\0字符(空字符),这个字符表示集合名的结尾。
    集合名不能以"system."开头,这是为系统集合保留的前缀。
    用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含,这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合,否则千万不要在名字里出现$。
    
    3、数据库:在MongoDB中,多个文档组成集合,多个集合可以组成数据库
    数据库也通过名字来标识。数据库名可以是满足以下条件的任意UTF-8字符串:
    #1、不能是空字符串("")。
    #2、不得含有' '(空格)、.、$、/、\和\0 (空字符)。
    #3、应全部小写。
    #4、最多64字节。
    
    有一些数据库名是保留的,可以直接访问这些有特殊作用的数据库。
    #1、admin: 从身份认证的角度讲,这是“root”数据库,如果将一个用户添加到admin数据库,这个用户将自动获得所有数据库的权限。再者,一些特定的服务器端命令也只能从admin数据库运行,如列出所有数据库或关闭服务器
    #2、local: 这个数据库永远都不可以复制,且一台服务器上的所有本地集合都可以存储在这个数据库中
    #3、config: MongoDB用于分片设置时,分片信息会存储在config数据库中
    
    4、强调:把数据库名添加到集合名前,得到集合的完全限定名,即命名空间
    例如:
    如果要使用cms数据库中的blog.posts集合,这个集合的命名空间就是
    cmd.blog.posts。命名空间的长度不得超过121个字节,且在实际使用中应该小于100个字节
    
    
    特点:
    1、易用性
    MongoDB是一个面向文档(document-oriented)的数据库,而不是关系型数据库。
    不采用关系型主要是为了获得更好得扩展性。当然还有一些其他好处,与关系数据库相比,面向文档的数据库不再有“行“(row)的概念取而代之的是更为灵活的“文档”(document)模型。
    通过在文档中嵌入文档和数组,面向文档的方法能够仅使用一条记录来表现复杂的层级关系,这与现代的面向对象语言的开发者对数据的看法一致。
    另外,不再有预定义模式(predefined schema):文档的键(key)和值(value)不再是固定的类型和大小。由于没有固定的模式,根据需要添加或删除字段变得更容易了。通常由于开发者能够进行快速迭代,所以开发进程得以加快。而且,实验更容易进行。开发者能尝试大量的数据模型,从中选一个最好的。
    
    2、易扩展性
    应用程序数据集的大小正在以不可思议的速度增长。随着可用带宽的增长和存储器价格的下降,即使是一个小规模的应用程序,需要存储的数据量也可能大的惊人,甚至超出
    了很多数据库的处理能力。过去非常罕见的T级数据,现在已经是司空见惯了。
    由于需要存储的数据量不断增长,开发者面临一个问题:应该如何扩展数据库,分为纵向扩展和横向扩展,纵向扩展是最省力的做法,但缺点是大型机一般都非常贵,而且
    当数据量达到机器的物理极限时,花再多的钱也买不到更强的机器了,此时选择横向扩展更为合适,但横向扩展带来的另外一个问题就是需要管理的机器太多。
    MongoDB的设计采用横向扩展。面向文档的数据模型使它能很容易地在多台服务器之间进行数据分割。MongoDB能够自动处理跨集群的数据和负载,自动重新分配文档,以及将
    用户的请求路由到正确的机器上。这样,开发者能够集中精力编写应用程序,而不需要考虑如何扩展的问题。如果一个集群需要更大的容量,只需要向集群添加新服务器,MongoDB就会自动将现有的数据向新服务器传送
    
    3、丰富的功能
    MongoDB作为一款通用型数据库,除了能够创建、读取、更新和删除数据之外,还提供了一系列不断扩展的独特功能
    #1、索引
    支持通用二级索引,允许多种快速查询,且提供唯一索引、复合索引、地理空间索引、全文索引
    #2、聚合
    支持聚合管道,用户能通过简单的片段创建复杂的集合,并通过数据库自动优化
    #3、特殊的集合类型
    支持存在时间有限的集合,适用于那些将在某个时刻过期的数据,如会话session。类似地,MongoDB也支持固定大小的集合,用于保存近期数据,如日志
    #4、文件存储
    支持一种非常易用的协议,用于存储大文件和文件元数据。MongoDB并不具备一些在关系型数据库中很普遍的功能,如链接join和复杂的多行事务。省略
    这些的功能是处于架构上的考虑,或者说为了得到更好的扩展性,因为在分布式系统中这两个功能难以高效地实现
    
    4、卓越的性能
    MongoDB的一个主要目标是提供卓越的性能,这很大程度上决定了MongoDB的设计。MongoDB把尽可能多的内存用作缓存cache,视图为每次查询自动选择正确的索引。
    总之各方面的设计都旨在保持它的高性能
    虽然MongoDB非常强大并试图保留关系型数据库的很多特性,但它并不追求具备关系型数据库的所有功能。只要有可能,数据库服务器就会将处理逻辑交给客户端。这种精简方式的设计是MongoDB能够实现如此高性能的原因之一
    MongoDB特点

    二、安装:

    #1、安装路径为D:\MongoDB,将D:\MongoDB\bin目录加入环境变量
    
    #2、新建目录与文件
    D:\MongoDB\data\db
    D:\MongoDB\log\mongod.log
    
    #3、新建配置文件mongod.cfg,参考:https://docs.mongodb.com/manual/reference/configuration-options/
    systemLog:
       destination: file
       path: "D:\MongoDB\log\mongod.log"
       logAppend: true
    storage:
       journal:
          enabled: true
       dbPath: "D:\MongoDB\data\db"
    net:
       bindIp: 0.0.0.0
       port: 27017
    setParameter:
       enableLocalhostAuthBypass: false
        
    #4、制作系统服务
    mongod --config "D:\MongoDB\mongod.cfg" --bind_ip 0.0.0.0 --install
    或者直接在命令行指定配置
    mongod --bind_ip 0.0.0.0 --port 27017 --logpath D:\MongoDB\log\mongod.log --logappend --dbpath D:\MongoDB\data\db  --serviceName "MongoDB" --serviceDisplayName "MongoDB"  --install
    
    
    #5、启动\关闭
    net start MongoDB
    net stop MongoDB
    
    #6、登录
    mongo
    
    链接:http://www.runoob.com/mongodb/mongodb-window-install.html
    
    安装配置
    安装
    #账号管理:https://docs.mongodb.com/master/tutorial/enable-authentication/
    #1、创建账号
    use admin
    db.createUser(
      {
        user: "root",
        pwd: "123",
        roles: [ { role: "root", db: "admin" } ]
      }
    )
    
    use test
    db.createUser(
      {
        user: "egon",
        pwd: "123",
        roles: [ { role: "readWrite", db: "test" },
                 { role: "read", db: "db1" } ]
      }
    )
    
    
    #2、重启数据库
    mongod --remove
    mongod --config "C:\mongodb\mongod.cfg" --bind_ip 0.0.0.0 --install --auth
    
    #3、登录:注意使用双引号而非单引号
    mongo --port 27017 -u "root" -p "123" --authenticationDatabase "admin"
    
    也可以在登录之后用db.auth("账号","密码")登录
    mongo
    use admin
    db.auth("root","123")
    
    #推荐博客:https://www.cnblogs.com/zhoujinyi/p/4610050.html
    
    创建账号密码+开启认证机制
    创建账号密码+开启认证机制
    #1、mongo 127.0.0.1:27017/config #连接到任何数据库config
    
    #2、mongo --nodb #不连接到任何数据库
    
    #3、启动之后,在需要时运行new Mongo(hostname)命令就可以连接到想要的mongod了:
    > conn=new Mongo('127.0.0.1:27017')
    connection to 127.0.0.1:27017
    > db=conn.getDB('admin')
    admin
    
    #4、help查看帮助
    
    #5、mongo时一个简化的JavaScript shell,是可以执行JavaScript脚本的
    命令行shell

    三、基本数据类型:

    • 在概念上,MongoDB的文档与Javascript的对象相近,因而可以认为它类似于JSON。JSON(http://www.json.org)是一种简单的数据表示方式:其规范仅用一段文字就能描述清楚(其官网证明了这点),且仅包含六种数据类型。
    • 这样有很多好处:易于理解、易于解析、易于记忆。然而从另一方面说,因为只有null、布尔、数字、字符串、数字和对象这几种数据类型,所以JSON的表达能力有一定的局限。
    • 虽然JSON具备的这些类型已经具有很强的表现力,但绝大数应用(尤其是在于数据库打交道时)都还需要其他一些重要的类型。例如,JSON没有日期类型,这使得原本容易日期处理变得烦人。另外,JSON只有一种数字类型,无法区分浮点数和整数,更别区分32位和64位了。再者JSON无法表示其他一些通用类型,如正则表达式或函数。
    • MongoDB在保留了JSON基本键/值对特性的基础上,添加了其他一些数据类型。在不同的编程语言下,这些类型的确切表示有些许差异。下面说明了MongoDB支持的其他通用类型,以及如何正在文档中使用它们
    • _id和ObjectId
    #1、null:用于表示空或不存在的字段
    d={'x':null}
    #2、布尔型:true和false
    d={'x':true,'y':false}
    #3、数值
    d={'x':3,'y':3.1415926}
    #4、字符串
    d={'x':'egon'}
    #5、日期
    d={'x':new Date()}
    d.x.getHours()
    #6、正则表达式
    d={'pattern':/^egon.*?nb$/i}
    
    正则写在//内,后面的i代表:
    i 忽略大小写
    m 多行匹配模式
    x 忽略非转义的空白字符
    s 单行匹配模式
    
    #7、数组
    d={'x':[1,'a','v']}
    
    #8、内嵌文档
    user={'name':'egon','addr':{'country':'China','city':'YT'}}
    user.addr.country
    
    #9、对象id:是一个12字节的ID,是文档的唯一标识,不可变
    d={'x':ObjectId()}
    MongoDB支持的其他通用类型
    MongoDB中存储的文档必须有一个"_id"键。这个键的值可以是任意类型,默认是个ObjectId对象。
    在一个集合里,每个文档都有唯一的“_id”,确保集合里每个文档都能被唯一标识。
    不同集合"_id"的值可以重复,但同一集合内"_id"的值必须唯一
    
    #1、ObjectId
    ObjectId是"_id"的默认类型。因为设计MongoDb的初衷就是用作分布式数据库,所以能够在分片环境中生成
    唯一的标识符非常重要,而常规的做法:在多个服务器上同步自动增加主键既费时又费力,这就是MongoDB采用
    ObjectId的原因。
    ObjectId采用12字节的存储空间,是一个由24个十六进制数字组成的字符串
        0|1|2|3|   4|5|6|     7|8    9|10|11    
        时间戳      机器      PID    计数器
    如果快速创建多个ObjectId,会发现每次只有最后几位有变化。另外,中间的几位数字也会变化(要是在创建过程中停顿几秒)。
    这是ObjectId的创建方式导致的,如上图
    
    时间戳单位为秒,与随后5个字节组合起来,提供了秒级的唯一性。这个4个字节隐藏了文档的创建时间,绝大多数驱动程序都会提供
    一个方法,用于从ObjectId中获取这些信息。
    
    因为使用的是当前时间,很多用户担心要对服务器进行时钟同步。其实没必要,因为时间戳的实际值并不重要,只要它总是不停增加就好。
    接下来3个字节是所在主机的唯一标识符。通常是机器主机名的散列值。这样就可以保证不同主机生成不同的ObjectId,不产生冲突
    
    接下来连个字节确保了在同一台机器上并发的多个进程产生的ObjectId是唯一的
    
    前9个字节确保了同一秒钟不同机器不同进程产生的ObjectId是唯一的。最后3个字节是一个自动增加的 计数器。确保相同进程的同一秒产生的
    ObjectId也是不一样的。
    
    #2、自动生成_id
    如果插入文档时没有"_id"键,系统会自帮你创建 一个。可以由MongoDb服务器来做这件事。
    但通常会在客户端由驱动程序完成。这一做法非常好地体现了MongoDb的哲学:能交给客户端驱动程序来做的事情就不要交给服务器来做。
    这种理念背后的原因是:即便是像MongoDB这样扩展性非常好的数据库,扩展应用层也要比扩展数据库层容易的多。将工作交给客户端做就
    减轻了数据库扩展的负担。
    _id和ObjectId

    四、CRUD操作:

    > use blog
    switched to db blog
    > show dbs
    admin   0.000GB
    config  0.000GB
    local   0.000GB
    test    0.000GB
    > db.article.insert({"title":"西游记"})
    WriteResult({ "nInserted" : 1 })
    > db.userinfo.insert({"name":"alex"})
    WriteResult({ "nInserted" : 1 })
    > show tables;
    article
    userinfo
    > show dbs
    admin 0.000GB
    blog 0.000GB
    config 0.000GB
    local 0.000GB
    test 0.000GB
    > db.dropDatabase()
    { "dropped" : "blog", "ok" : 1 }  
    数据库操作
    > use blog
    switched to db blog
    > db.article.insert({"title":"python"})
    WriteResult({ "nInserted" : 1 })
    > db.article.insert({"title":"linux"})
    WriteResult({ "nInserted" : 1 })
    > show tables;
    article
    > db.article.drop()
    true
    > show tables;
    >
    集合操作
    #1、没有指定_id则默认ObjectId,_id不能重复,且在插入后不可变
     
    #2、插入单条
    user0={
        "name":"egon",
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'BJ'
        }
    }
     
    db.test.insert(user0)
    db.test.find()
     
    #3、插入多条
    user1={
        "_id":1,
        "name":"alex",
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'weifang'
        }
    }
     
    user2={
        "_id":2,
        "name":"wupeiqi",
        "age":20,
        'hobbies':['music','read','run'],
        'addr':{
            'country':'China',
            'city':'hebei'
        }
    }
     
     
    user3={
        "_id":3,
        "name":"yuanhao",
        "age":30,
        'hobbies':['music','drink'],
        'addr':{
            'country':'China',
            'city':'heibei'
        }
    }
     
    user4={
        "_id":4,
        "name":"jingliyang",
        "age":40,
        'hobbies':['music','read','dancing','tea'],
        'addr':{
            'country':'China',
            'city':'BJ'
        }
    }
     
    user5={
        "_id":5,
        "name":"jinxin",
        "age":50,
        'hobbies':['music','read',],
        'addr':{
            'country':'China',
            'city':'henan'
        }
    }
    db.user.insertMany([user1,user2,user3,user4,user5]) 
    db.user.find()
    添加文档
    ###################### (1) 比较运算  ###################################
     
    # SQL:=,!=,>,<,>=,<=
    # MongoDB:{key:value}代表什么等于什么,"$ne","$gt","$lt","gte","lte",其中"$ne"能用于所有数据类型
     
    #1select * from db1.user where name = "alex";
    db.user.find({'name':'alex'})
     
    #2select * from db1.user where name != "alex";
    db.user.find({'name':{"$ne":'alex'}})
     
    #3select * from db1.user where id > 2;
    db.user.find({'_id':{'$gt':2}})
     
    #4select * from db1.user where id < 3;
    db.user.find({'_id':{'$lt':3}})
     
    #5select * from db1.user where id >= 2;
    db.user.find({"_id":{"$gte":2,}})
     
    #6select * from db1.user where id <= 2;
    db.user.find({"_id":{"$lte":2}})
    
    ###################### (2) 逻辑运算  ###################################
     
    # SQL:andornot
    # MongoDB:字典中逗号分隔的多个条件是and关系,"$or"的条件放到[]内,"$not"
     
    #1select * from db1.user where id >= 2 and id < 4;
    db.user.find({'_id':{"$gte":2,"$lt":4}})
     
    #2select * from db1.user where id >= 2 and age < 40;
    db.user.find({"_id":{"$gte":2},"age":{"$lt":40}})
     
    #3select * from db1.user where id >= 5 or name = "alex";
    db.user.find({
        "$or":[
            {'_id':{"$gte":5}},
            {"name":"alex"}
            ]
    })
    #4select * from db1.user where id % 2=1;
    db.user.find({'_id':{"$mod":[2,1]}})
     
    #5、上题,取反
    db.user.find({'_id':{"$not":{"$mod":[2,1]}}})
    ###################### (3) 成员运算  ###################################
     
    # SQL:innot in
    # MongoDB:"$in","$nin"
     
    #1select * from db1.user where age in (20,30,31);
    db.user.find({"age":{"$in":[20,30,31]}})
     
    #2select * from db1.user where name not in ('alex','yuanhao');
    db.user.find({"name":{"$nin":['alex','yuanhao']}})
    
    ###################### (4) 正则匹配  ###################################
     
    # SQL: regexp 正则
    # MongoDB: /正则表达/i
     
    #1select * from db1.user where name regexp '^j.*?(g|n)$';
    db.user.find({'name':/^j.*?(g|n)$/i})
    
    
    ###################### (5) 取指定字段  ###################################
     
    #1select name,age from db1.user where id=3;
    db.user.find({'_id':3},{''name':1,'age':1})
    #2 db.user.find({'_id':3},{"addr":0})
    { "_id" : 3, "name" : "yuanhao", "age" : 30, "hobbies" : [ "music", "drink" ] }
    
    ###################### (6) 查询数组  ###################################
     
    #1、查看有dancing爱好的人
    db.user.find({'hobbies':'dancing'})
     
    #2、查看既有dancing爱好又有tea爱好的人
    db.user.find({
        'hobbies':{
            "$all":['dancing','tea']
            }
    })
     
    #3、查看第4个爱好为tea的人
    db.user.find({"hobbies.3":'tea'})
     
    #4、查看所有人最后两个爱好
    db.user.find({},{'hobbies':{"$slice":-2},"age":0,"_id":0,"name":0,"addr":0})
     
    #5、查看所有人的第2个到第3个爱好
    db.user.find({},{'hobbies':{"$slice":[1,2]},"age":0,"_id":0,"name":0,"addr":0})
     
    
    ###################### (7) 排序  ###################################
     
    # 排序:--1代表升序,-1代表降序
    db.user.find().sort({"name":1,})
    db.user.find().sort({"age":-1,'_id':1})
    
    ###################### (8) 分页  ###################################
     
    # 分页:--limit代表取多少个document,skip代表跳过前多少个document。
    db.user.find().sort({'age':1}).limit(1).skip(2)
     
    ###################### (9) 查询数量  ###################################
    # 获取数量
    db.user.count({'age':{"$gt":30}})
     
    --或者
    db.user.find({'age':{"$gt":30}}).count()
    
    ###################### (10) 其它  ###################################
     
    #1、{'key':null} 匹配key的值为null或者没有这个key
    db.t2.insert({'a':10,'b':111})
    db.t2.insert({'a':20})
    db.t2.insert({'b':null})
     
    > db.t2.find({"b":null})
    { "_id" : ObjectId("5a5cc2a7c1b4645aad959e5a"), "a" : 20 }
    { "_id" : ObjectId("5a5cc2a8c1b4645aad959e5b"), "b" : null }
     
    #2、查找所有
    db.user.find() #等同于db.user.find({})
    db.user.find().pretty()
     
    #3、查找一个,与find用法一致,只是只取匹配成功的第一个
    db.user.findOne({"_id":{"$gt":3}}) 
    查看文档
    ############################## 1 update的语法  ##############################
     
    update() 方法用于更新已存在的文档。语法格式如下:
    db.collection.update(
       <query>,
       <update>,
       {
         upsert: <boolean>,
         multi: <boolean>,
         writeConcern: <document>
       }
    )
    参数说明:对比update db1.t1 set name='EGON',sex='Male' where name='egon' and age=18;
     
    query : 相当于where条件。
    update : update的对象和一些更新的操作符(如$,$inc...等,相当于set后面的
    upsert : 可选,默认为false,代表如果不存在update的记录不更新也不插入,设置为true代表插入。
    multi : 可选,默认为false,代表只更新找到的第一条记录,设为true,代表更新找到的全部记录。
    writeConcern :可选,抛出异常的级别。
     
    更新操作是不可分割的:若两个更新同时发送,先到达服务器的先执行,然后执行另外一个,不会破坏文档。
     
    ############################## 2 覆盖更新  ##############################
     
    #注意:除非是删除,否则_id是始终不会变的
    #1 :
    db.user.update({'age':20},{"name":"Wxx","hobbies_count":3})
    是用{"_id":2,"name":"Wxx","hobbies_count":3}覆盖原来的记录
     
    #2、一种最简单的更新就是用一个新的文档完全替换匹配的文档。这适用于大规模式迁移的情况。例如
    var obj=db.user.findOne({"_id":2})
     
    obj.username=obj.name+'SB'
    obj.hobbies_count++
    delete obj.age
     
    db.user.update({"_id":2},obj)
     
    ############################## 3 局部更新  ##############################
     
    #设置:$set
     
    通常文档只会有一部分需要更新。可以使用原子性的更新修改器,指定对文档中的某些字段进行更新。
    更新修改器是种特殊的键,用来指定复杂的更新操作,比如修改、增加后者删除
     
    #1update db1.user set  name="WXX" where id = 2
    db.user.update({'_id':2},{"$set":{"name":"WXX",}})
     
    #2、没有匹配成功则新增一条{"upsert":true}
    db.user.update({'_id':6},{"$set":{"name":"egon","age":18}},{"upsert":true})
     
    #3、默认只改匹配成功的第一条,{"multi":改多条}
    db.user.update({'_id':{"$gt":4}},{"$set":{"age":28}})
    db.user.update({'_id':{"$gt":4}},{"$set":{"age":38}},{"multi":true})
     
    #4、修改内嵌文档,把名字为alex的人所在的地址国家改成Japan
    db.user.update({'name':"alex"},{"$set":{"addr.country":"Japan"}})
     
    #5、把名字为alex的人的地2个爱好改成piao
    db.user.update({'name':"alex"},{"$set":{"hobbies.1":"piao"}})
     
    #6、删除alex的爱好,$unset
    db.user.update({'name':"alex"},{"$unset":{"hobbies":""}})
     
    ############################## 4 自增或自减  ##############################
     
    #增加和减少:$inc
     
    #1、所有人年龄增加一岁
    db.user.update({},
        {
            "$inc":{"age":1}
        },
        {
            "multi":true
        }
        )
    #2、所有人年龄减少5岁
    db.user.update({},
        {
            "$inc":{"age":-5}
        },
        {
            "multi":true
        }
        )
     
     
    ############################## 5 添加删除数组内元素 ##############################
     
    #添加删除数组内元素:$push,$pop,$pull
         
    往数组内添加元素:$push
    #1、为名字为yuanhao的人添加一个爱好read
    db.user.update({"name":"yuanhao"},{"$push":{"hobbies":"read"}})
     
    #2、为名字为yuanhao的人一次添加多个爱好tea,dancing
    db.user.update({"name":"yuanhao"},{"$push":{
        "hobbies":{"$each":["tea","dancing"]}
    }})
     
    按照位置且只能从开头或结尾删除元素:$pop
    #3、{"$pop":{"key":1}} 从数组末尾删除一个元素
     
    db.user.update({"name":"yuanhao"},{"$pop":{
        "hobbies":1}
    })
     
    #4、{"$pop":{"key":-1}} 从头部删除
    db.user.update({"name":"yuanhao"},{"$pop":{
        "hobbies":-1}
    })
     
    #5、按照条件删除元素,:"$pull" 把符合条件的统统删掉,而$pop只能从两端删
    db.user.update({'addr.country':"China"},{"$pull":{
        "hobbies":"read"}
    },
    {
        "multi":true
    }
    )
     
     
    ############################## 6 避免重复添加 ##############################
     
    #避免添加重复:"$addToSet"
     
    db.urls.insert({"_id":1,"urls":[]})
     
    db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
    db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
    db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
     
    db.urls.update({"_id":1},{
        "$addToSet":{
            "urls":{
            "$each":[
                'http://www.baidu.com',
                'http://www.baidu.com',
                'http://www.xxxx.com'
                ]
                }
            }
        }
    )
     
    ############################## 7 其它 ##############################
     
    #1、了解:限制大小"$slice",只留最后n个
     
    db.user.update({"_id":5},{
        "$push":{"hobbies":{
            "$each":["read",'music','dancing'],
            "$slice":-2
        }
        }
    })
     
    #2、了解:排序The $sort element value must be either 1 or -1"
    db.user.update({"_id":5},{
        "$push":{"hobbies":{
            "$each":["read",'music','dancing'],
            "$slice":-1,
            "$sort":-1
        }
        }
    })
     
    #注意:不能只将"$slice"或者"$sort"与"$push"配合使用,且必须使用"$eah"  
    修改文档
    #1、删除多个中的第一个
    db.user.deleteOne({ 'age': 8 })
      
    #2、删除国家为China的全部
    db.user.deleteMany( {'addr.country': 'China'} )
      
    #3、删除全部
    db.user.deleteMany({})
    删除文档
    """
    MongoDB存储
        在这里我们来看一下Python3下MongoDB的存储操作,在本节开始之前请确保你已经安装好了MongoDB并启动了其服务,另外安装好了Python
        的PyMongo库。
      
    连接MongoDB
        连接MongoDB我们需要使用PyMongo库里面的MongoClient,一般来说传入MongoDB的IP及端口即可,第一个参数为地址host,
        第二个参数为端口port,端口如果不传默认是27017。
    """<br>
    import pymongo
    client = pymongo.MongoClient(host='localhost', port=27017)<br>
    """
    这样我们就可以创建一个MongoDB的连接对象了。另外MongoClient的第一个参数host还可以直接传MongoDB的连接字符串,以mongodb开头,
    例如:client = MongoClient('mongodb://localhost:27017/')可以达到同样的连接效果。<br>
    """
    # 指定数据库
    # MongoDB中还分为一个个数据库,我们接下来的一步就是指定要操作哪个数据库,在这里我以test数据库为例进行说明,所以下一步我们
    # 需要在程序中指定要使用的数据库。
      
    db = client.test
    # 调用client的test属性即可返回test数据库,当然也可以这样来指定:
    # db = client['test']
    # 两种方式是等价的。
      
    # 指定集合
    # MongoDB的每个数据库又包含了许多集合Collection,也就类似与关系型数据库中的表,下一步我们需要指定要操作的集合,
    # 在这里我们指定一个集合名称为students,学生集合。还是和指定数据库类似,指定集合也有两种方式。
      
    collection = db.students
    # collection = db['students']
    # 插入数据,接下来我们便可以进行数据插入了,对于students这个Collection,我们新建一条学生数据,以字典的形式表示:
      
    student = {
        'id': '20170101',
        'name': 'Jordan',
        'age': 20,
        'gender': 'male'
    }
    # 在这里我们指定了学生的学号、姓名、年龄和性别,然后接下来直接调用collection的insert()方法即可插入数据。
      
    result = collection.insert(student)
    print(result)
    # 在MongoDB中,每条数据其实都有一个_id属性来唯一标识,如果没有显式指明_id,MongoDB会自动产生一个ObjectId类型的_id属性。
    # insert()方法会在执行后返回的_id值。
      
    # 运行结果:
    # 5932a68615c2606814c91f3d
    # 当然我们也可以同时插入多条数据,只需要以列表形式传递即可,示例如下:
      
    student1 = {
        'id': '20170101',
        'name': 'Jordan',
        'age': 20,
        'gender': 'male'
    }
      
    student2 = {
        'id': '20170202',
        'name': 'Mike',
        'age': 21,
        'gender': 'male'
    }
      
    result = collection.insert([student1, student2])
    print(result)
    # 返回的结果是对应的_id的集合,运行结果:
    # [ObjectId('5932a80115c2606a59e8a048'), ObjectId('5932a80115c2606a59e8a049')]
    # 实际上在PyMongo 3.X版本中,insert()方法官方已经不推荐使用了,当然继续使用也没有什么问题,
    # 官方推荐使用insert_one()和insert_many()方法将插入单条和多条记录分开。
      
    student = {
        'id': '20170101',
        'name': 'Jordan',
        'age': 20,
        'gender': 'male'
    }
      
    result = collection.insert_one(student)
    print(result)
    print(result.inserted_id)
    # 运行结果:
    # <pymongo.results.InsertOneResult object at 0x10d68b558>
    # 5932ab0f15c2606f0c1cf6c5
    # 返回结果和insert()方法不同,这次返回的是InsertOneResult对象,我们可以调用其inserted_id属性获取_id。
      
    # 对于insert_many()方法,我们可以将数据以列表形式传递即可,示例如下:
      
    student1 = {
        'id': '20170101',
        'name': 'Jordan',
        'age': 20,
        'gender': 'male'
    }
      
    student2 = {
        'id': '20170202',
        'name': 'Mike',
        'age': 21,
        'gender': 'male'
    }
      
    result = collection.insert_many([student1, student2])
    print(result)
    print(result.inserted_ids)
    # insert_many()方法返回的类型是InsertManyResult,调用inserted_ids属性可以获取插入数据的_id列表,运行结果:
      
    # <pymongo.results.InsertManyResult object at 0x101dea558>
    # [ObjectId('5932abf415c2607083d3b2ac'), ObjectId('5932abf415c2607083d3b2ad')]
    # 查询,插入数据后我们可以利用find_one()或find()方法进行查询,find_one()查询得到是单个结果,find()则返回多个结果。
      
    result = collection.find_one({'name': 'Mike'})
    print(type(result))
    print(result)
    # 在这里我们查询name为Mike的数据,它的返回结果是字典类型,运行结果:
    # <class'dict'>
    # {'_id': ObjectId('5932a80115c2606a59e8a049'), 'id': '20170202', 'name': 'Mike', 'age': 21, 'gender': 'male'}
    # 可以发现它多了一个_id属性,这就是MongoDB在插入的过程中自动添加的。
      
    # 我们也可以直接根据ObjectId来查询,这里需要使用bson库里面的ObjectId。
      
    from bson.objectid import ObjectId
      
    result = collection.find_one({'_id': ObjectId('593278c115c2602667ec6bae')})
    print(result)
    # 其查询结果依然是字典类型,运行结果:
      
    # {' ObjectId('593278c115c2602667ec6bae'), 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male'}
    # 当然如果查询_id':结果不存在则会返回None。
      
    # 对于多条数据的查询,我们可以使用find()方法,例如在这里查找年龄为20的数据,示例如下:
      
    results = collection.find({'age': 20})
    print(results)
    for result in results:
        print(result)
    # 运行结果:
      
    # <pymongo.cursor.Cursor object at 0x1032d5128>
    # {'_id': ObjectId('593278c115c2602667ec6bae'), 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male'}
    # {'_id': ObjectId('593278c815c2602678bb2b8d'), 'id': '20170102', 'name': 'Kevin', 'age': 20, 'gender': 'male'}
    # {'_id': ObjectId('593278d815c260269d7645a8'), 'id': '20170103', 'name': 'Harden', 'age': 20, 'gender': 'male'}
    # 返回结果是Cursor类型,相当于一个生成器,我们需要遍历取到所有的结果,每一个结果都是字典类型。
      
    # 如果要查询年龄大于20的数据,则写法如下:
      
    results = collection.find({'age': {'$gt': 20}})
    # 在这里查询的条件键值已经不是单纯的数字了,而是一个字典,其键名为比较符号$gt,意思是大于,键值为20,这样便可以查询出所有
    # 年龄大于20的数据。
      
    # 在这里将比较符号归纳如下表:
    """
    符号含义示例
    $lt小于{'age': {'$lt': 20}}
    $gt大于{'age': {'$gt': 20}}
    $lte小于等于{'age': {'$lte': 20}}
    $gte大于等于{'age': {'$gte': 20}}
    $ne不等于{'age': {'$ne': 20}}
    $in在范围内{'age': {'$in': [20, 23]}}
    $nin不在范围内{'age': {'$nin': [20, 23]}}
    """
    # 另外还可以进行正则匹配查询,例如查询名字以M开头的学生数据,示例如下:
      
    results = collection.find({'name': {'$regex': '^M.*'}})
    # 在这里使用了$regex来指定正则匹配,^M.*代表以M开头的正则表达式,这样就可以查询所有符合该正则的结果。
      
    # 在这里将一些功能符号再归类如下:
    """
    符号含义示例示例含义
    $regex匹配正则{'name': {'$regex': '^M.*'}}name以M开头
    $exists属性是否存在{'name': {'$exists': True}}name属性存在
    $type类型判断{'age': {'$type': 'int'}}age的类型为int
    $mod数字模操作{'age': {'$mod': [5, 0]}}年龄模5余0
    $text文本查询{'$text': {'$search': 'Mike'}}text类型的属性中包含Mike字符串
    $where高级条件查询{'$where': 'obj.fans_count == obj.follows_count'}自身粉丝数等于关注数
    """
    # 这些操作的更详细用法在可以在MongoDB官方文档找到:
    # https://docs.mongodb.com/manual/reference/operator/query/
      
    
    # 计数
    # 要统计查询结果有多少条数据,可以调用count()方法,如统计所有数据条数:
      
    count = collection.find().count()
    print(count)
    # 或者统计符合某个条件的数据:
      
    count = collection.find({'age': 20}).count()
    print(count)
    # 排序
    # 可以调用sort方法,传入排序的字段及升降序标志即可,示例如下:
      
    results = collection.find().sort('name', pymongo.ASCENDING)
    print([result['name'] for result in results])
    # 运行结果:
      
    # ['Harden', 'Jordan', 'Kevin', 'Mark', 'Mike']
    # 偏移,可能想只取某几个元素,在这里可以利用skip()方法偏移几个位置,比如偏移2,就忽略前2个元素,得到第三个及以后的元素。
      
    results = collection.find().sort('name', pymongo.ASCENDING).skip(2)
    print([result['name'] for result in results])
    # 运行结果:
    # ['Kevin', 'Mark', 'Mike']
    # 另外还可以用limit()方法指定要取的结果个数,示例如下:
      
    results = collection.find().sort('name', pymongo.ASCENDING).skip(2).limit(2)
    print([result['name'] for result in results])
    # 运行结果:
    # ['Kevin', 'Mark']
    # 如果不加limit()原本会返回三个结果,加了限制之后,会截取2个结果返回。
      
    # 值得注意的是,在数据库数量非常庞大的时候,如千万、亿级别,最好不要使用大的偏移量来查询数据,很可能会导致内存溢出,
    # 可以使用类似find({'_id': {'$gt': ObjectId('593278c815c2602678bb2b8d')}}) 这样的方法来查询,记录好上次查询的_id。
      
    # 更新
    # 对于数据更新可以使用update()方法,指定更新的条件和更新后的数据即可,例如:
      
    condition = {'name': 'Kevin'}
    student = collection.find_one(condition)
    student['age'] = 25
    result = collection.update(condition, student)
    print(result)
    # 在这里我们将name为Kevin的数据的年龄进行更新,首先指定查询条件,然后将数据查询出来,修改年龄,
    # 之后调用update方法将原条件和修改后的数据传入,即可完成数据的更新。
      
    # 运行结果:
      
    # {'ok': 1, 'nModified': 1, 'n': 1, 'updatedExisting': True}
    # 返回结果是字典形式,ok即代表执行成功,nModified代表影响的数据条数。
      
    # 另外update()方法其实也是官方不推荐使用的方法,在这里也分了update_one()方法和update_many()方法,用法更加严格,
    # 第二个参数需要使用$类型操作符作为字典的键名,我们用示例感受一下。
      
    condition = {'name': 'Kevin'}
    student = collection.find_one(condition)
    student['age'] = 26
    result = collection.update_one(condition, {'$set': student})
    print(result)
    print(result.matched_count, result.modified_count)
    # 在这里调用了update_one方法,第二个参数不能再直接传入修改后的字典,而是需要使用{'$set': student}这样的形式,
    # 其返回结果是UpdateResult类型,然后调用matched_count和modified_count属性分别可以获得匹配的数据条数和影响的数据条数。
      
    # 运行结果:
    #
    # <pymongo.results.UpdateResult object at 0x10d17b678>
    # 1 0
    # 我们再看一个例子:
      
    condition = {'age': {'$gt': 20}}
    result = collection.update_one(condition, {'$inc': {'age': 1}})
    print(result)
    print(result.matched_count, result.modified_count)
    # 在这里我们指定查询条件为年龄大于20,然后更新条件为{'$inc': {'age': 1}},执行之后会讲第一条符合条件的数据年龄加1。
      
    # 运行结果:
    #
    # <pymongo.results.UpdateResult object at 0x10b8874c8>
    # 1 1
    # 可以看到匹配条数为1条,影响条数也为1条。
      
    # 如果调用update_many()方法,则会将所有符合条件的数据都更新,示例如下:
      
    condition = {'age': {'$gt': 20}}
    result = collection.update_many(condition, {'$inc': {'age': 1}})
    print(result)
    print(result.matched_count, result.modified_count)
    # 这时候匹配条数就不再为1条了,运行结果如下:
    #
    # <pymongo.results.UpdateResult object at 0x10c6384c8>
    # 3 3
    # 可以看到这时所有匹配到的数据都会被更新。
      
    # 删除
    # 删除操作比较简单,直接调用remove()方法指定删除的条件即可,符合条件的所有数据均会被删除,示例如下:
      
    result = collection.remove({'name': 'Kevin'})
    print(result)
    # 运行结果:
    #
    # {'ok': 1, 'n': 1}
    # 另外依然存在两个新的推荐方法,delete_one()和delete_many()方法,示例如下:
      
    result = collection.delete_one({'name': 'Kevin'})
    print(result)
    print(result.deleted_count)
    result = collection.delete_many({'age': {'$lt': 25}})
    print(result.deleted_count)
    # 运行结果:
      
    # <pymongo.results.DeleteResult object at 0x10e6ba4c8>
    # 1
    # 4
    # delete_one()即删除第一条符合条件的数据,delete_many()即删除所有符合条件的数据,返回结果是DeleteResult类型,
    # 可以调用deleted_count属性获取删除的数据条数。
      
    # 更多
    # 另外PyMongo还提供了一些组合方法,如find_one_and_delete()、find_one_and_replace()、find_one_and_update(),
    # 就是查找后删除、替换、更新操作,用法与上述方法基本一致。
      
    # 另外还可以对索引进行操作,如create_index()、create_indexes()、drop_index()等。
      
    # 详细用法可以参见官方文档:http://api.mongodb.com/python/current/api/pymongo/collection.html
      
    # 另外还有对数据库、集合本身以及其他的一些操作,在这不再一一讲解,可以参见
    # 官方文档:http://api.mongodb.com/python/current/api/pymongo/
    pymongo

    1、文档操作:增

    #1、没有指定_id则默认ObjectId,_id不能重复,且在插入后不可变
    
    #2、插入单条
    user0={
        "name":"egon",
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'BJ'
        }
    }
    
    db.test.insert(user0)
    db.test.find()
    
    #3、插入多条
    user1={
        "_id":1,
        "name":"alex",
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'weifang'
        }
    }
    
    user2={
        "_id":2,
        "name":"wupeiqi",
        "age":20,
        'hobbies':['music','read','run'],
        'addr':{
            'country':'China',
            'city':'hebei'
        }
    }
    
    
    user3={
        "_id":3,
        "name":"yuanhao",
        "age":30,
        'hobbies':['music','drink'],
        'addr':{
            'country':'China',
            'city':'heibei'
        }
    }
    
    user4={
        "_id":4,
        "name":"jingliyang",
        "age":40,
        'hobbies':['music','read','dancing','tea'],
        'addr':{
            'country':'China',
            'city':'BJ'
        }
    }
    
    user5={
        "_id":5,
        "name":"jinxin",
        "age":50,
        'hobbies':['music','read',],
        'addr':{
            'country':'China',
            'city':'henan'
        }
    }
    db.user.insertMany([user1,user2,user3,user4,user5])
    
    单条插入与多条插入
    单条插入与多条插入

    2、文档操作:删

    #1、删除多个中的第一个
    db.user.deleteOne({ 'age': 8 })
    
    #2、删除国家为China的全部
    db.user.deleteMany( {'addr.country': 'China'} ) 
    
    #3、删除全部
    db.user.deleteMany({})
    View Code

    3、文档操作:改

    update() 方法用于更新已存在的文档。语法格式如下:
    db.collection.update(
       <query>,
       <update>,
       {
         upsert: <boolean>,
         multi: <boolean>,
         writeConcern: <document>
       }
    )
    参数说明:对比update db1.t1 set name='EGON',sex='Male' where name='egon' and age=18;
    
    query : 相当于where条件。
    update : update的对象和一些更新的操作符(如$,$inc...等,相当于set后面的
    upsert : 可选,默认为false,代表如果不存在update的记录不更新也不插入,设置为true代表插入。
    multi : 可选,默认为false,代表只更新找到的第一条记录,设为true,代表更新找到的全部记录。
    writeConcern :可选,抛出异常的级别。
    
    更新操作是不可分割的:若两个更新同时发送,先到达服务器的先执行,然后执行另外一个,不会破坏文档。
    
    update语法介绍
    #注意:除非是删除,否则_id是始终不会变的
    #1、覆盖式:
    db.user.update({'age':20},{"name":"Wxx","hobbies_count":3})
    是用{"_id":2,"name":"Wxx","hobbies_count":3}覆盖原来的记录
    
    #2、一种最简单的更新就是用一个新的文档完全替换匹配的文档。这适用于大规模式迁移的情况。例如
    var obj=db.user.findOne({"_id":2})
    
    obj.username=obj.name+'SB'
    obj.hobbies_count++
    delete obj.age
    
    db.user.update({"_id":2},obj)
    
    覆盖式
    #设置:$set
    
    通常文档只会有一部分需要更新。可以使用原子性的更新修改器,指定对文档中的某些字段进行更新。
    更新修改器是种特殊的键,用来指定复杂的更新操作,比如修改、增加后者删除
    
    #1、update db1.user set  name="WXX" where id = 2
    db.user.update({'_id':2},{"$set":{"name":"WXX",}})
    
    #2、没有匹配成功则新增一条{"upsert":true}
    db.user.update({'_id':6},{"$set":{"name":"egon","age":18}},{"upsert":true})
    
    #3、默认只改匹配成功的第一条,{"multi":改多条}
    db.user.update({'_id':{"$gt":4}},{"$set":{"age":28}})
    db.user.update({'_id':{"$gt":4}},{"$set":{"age":38}},{"multi":true})
    
    #4、修改内嵌文档,把名字为alex的人所在的地址国家改成Japan
    db.user.update({'name':"alex"},{"$set":{"addr.country":"Japan"}})
    
    #5、把名字为alex的人的地2个爱好改成piao
    db.user.update({'name':"alex"},{"$set":{"hobbies.1":"piao"}})
    
    #6、删除alex的爱好,$unset
    db.user.update({'name':"alex"},{"$unset":{"hobbies":""}})
    设置:$set
    #增加和减少:$inc
    
    #1、所有人年龄增加一岁
    db.user.update({},
        {
            "$inc":{"age":1}
        },
        {
            "multi":true
        }
        )
    #2、所有人年龄减少5岁
    db.user.update({},
        {
            "$inc":{"age":-5}
        },
        {
            "multi":true
        }
        )
    
    增加和减少:$inc
    #添加删除数组内元素
        
    往数组内添加元素:$push
    #1、为名字为yuanhao的人添加一个爱好read
    db.user.update({"name":"yuanhao"},{"$push":{"hobbies":"read"}})
    
    #2、为名字为yuanhao的人一次添加多个爱好tea,dancing
    db.user.update({"name":"yuanhao"},{"$push":{
        "hobbies":{"$each":["tea","dancing"]}
    }})
    
    按照位置且只能从开头或结尾删除元素:$pop
    #3、{"$pop":{"key":1}} 从数组末尾删除一个元素
    
    db.user.update({"name":"yuanhao"},{"$pop":{
        "hobbies":1}
    })
    
    #4、{"$pop":{"key":-1}} 从头部删除
    db.user.update({"name":"yuanhao"},{"$pop":{
        "hobbies":-1}
    })
    
    #5、按照条件删除元素,:"$pull" 把符合条件的统统删掉,而$pop只能从两端删
    db.user.update({'addr.country':"China"},{"$pull":{
        "hobbies":"read"}
    },
    {
        "multi":true
    }
    )
    添加删除数组内元素:$push,$pop,$pull
    #避免添加重复:"$addToSet"
    
    db.urls.insert({"_id":1,"urls":[]})
    
    db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
    db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
    db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
    
    db.urls.update({"_id":1},{
        "$addToSet":{
            "urls":{
            "$each":[
                'http://www.baidu.com',
                'http://www.baidu.com',
                'http://www.xxxx.com'
                ]
                }
            }
        }
    )
    避免添加重复:"$addToSet"
    #1、了解:限制大小"$slice",只留最后n个
    
    db.user.update({"_id":5},{
        "$push":{"hobbies":{
            "$each":["read",'music','dancing'],
            "$slice":-2
        }
        }
    })
    
    #2、了解:排序The $sort element value must be either 1 or -1"
    db.user.update({"_id":5},{
        "$push":{"hobbies":{
            "$each":["read",'music','dancing'],
            "$slice":-1,
            "$sort":-1
        }
        }
    })
    
    #注意:不能只将"$slice"或者"$sort"与"$push"配合使用,且必须使用"$eah"
    其他

    4、文档操作:查

    # SQL:=,!=,>,<,>=,<=
    # MongoDB:{key:value}代表什么等于什么,"$ne","$gt","$lt","gte","lte",其中"$ne"能用于所有数据类型
    
    #1、select * from db1.user where name = "alex";
    db.user.find({'name':'alex'})
    
    #2、select * from db1.user where name != "alex";
    db.user.find({'name':{"$ne":'alex'}})
    
    #3、select * from db1.user where id > 2;
    db.user.find({'_id':{'$gt':2}})
    
    #4、select * from db1.user where id < 3;
    db.user.find({'_id':{'$lt':3}})
    
    #5、select * from db1.user where id >= 2;
    db.user.find({"_id":{"$gte":2,}})
    
    #6、select * from db1.user where id <= 2;
    db.user.find({"_id":{"$lte":2}})
    比较运算
    # SQL:and,or,not
    # MongoDB:字典中逗号分隔的多个条件是and关系,"$or"的条件放到[]内,"$not"
    
    #1、select * from db1.user where id >= 2 and id < 4;
    db.user.find({'_id':{"$gte":2,"$lt":4}})
    
    #2、select * from db1.user where id >= 2 and age < 40;
    db.user.find({"_id":{"$gte":2},"age":{"$lt":40}})
    
    #3、select * from db1.user where id >= 5 or name = "alex";
    db.user.find({
        "$or":[
            {'_id':{"$gte":5}},
            {"name":"alex"}
            ]
    })
    
    #4、select * from db1.user where id % 2=1;
    db.user.find({'_id':{"$mod":[2,1]}})
    
    #5、上题,取反
    db.user.find({'_id':{"$not":{"$mod":[2,1]}}})
    逻辑运算
    # SQL:in,not in
    # MongoDB:"$in","$nin"
    
    #1、select * from db1.user where age in (20,30,31);
    db.user.find({"age":{"$in":[20,30,31]}})
    
    #2、select * from db1.user where name not in ('alex','yuanhao');
    db.user.find({"name":{"$nin":['alex','yuanhao']}})
    成员运算
    # SQL: regexp 正则
    # MongoDB: /正则表达/i
    
    #1、select * from db1.user where name regexp '^j.*?(g|n)$';
    db.user.find({'name':/^j.*?(g|n)$/i})
    正则匹配
    #1、select name,age from db1.user where id=3;
    db.user.find({'_id':3},{'_id':0,'name':1,'age':1})
    取指定的字段
    #1、查看有dancing爱好的人
    db.user.find({'hobbies':'dancing'})
    
    #2、查看既有dancing爱好又有tea爱好的人
    db.user.find({
        'hobbies':{
            "$all":['dancing','tea']
            }
    })
    
    #3、查看第4个爱好为tea的人
    db.user.find({"hobbies.3":'tea'})
    
    #4、查看所有人最后两个爱好
    db.user.find({},{'hobbies':{"$slice":-2},"age":0,"_id":0,"name":0,"addr":0})
    
    #5、查看所有人的第2个到第3个爱好
    db.user.find({},{'hobbies':{"$slice":[1,2]},"age":0,"_id":0,"name":0,"addr":0})
    
    > db.blog.find().pretty()
    {
            "_id" : 1,
            "name" : "alex意外死亡的真相",
            "comments" : [
                    {
                            "name" : "egon",
                            "content" : "alex是谁???",
                            "thumb" : 200
                    },
                    {
                            "name" : "wxx",
                            "content" : "我去,真的假的",
                            "thumb" : 300
                    },
                    {
                            "name" : "yxx",
                            "content" : "吃喝嫖赌抽,欠下两个亿",
                            "thumb" : 40
                    },
                    {
                            "name" : "egon",
                            "content" : "xxx",
                            "thumb" : 0
                    }
            ]
    }
    db.blog.find({},{'comments':{"$slice":-2}}).pretty() #查询最后两个
    db.blog.find({},{'comments':{"$slice":[1,2]}}).pretty() #查询1到2
    查询数组
    # 排序:--1代表升序,-1代表降序
    db.user.find().sort({"name":1,})
    db.user.find().sort({"age":-1,'_id':1})
    排序
    分页
    # 获取数量
    db.user.count({'age':{"$gt":30}}) 
    
    --或者
    db.user.find({'age':{"$gt":30}}).count()
    获取数量
    #1、{'key':null} 匹配key的值为null或者没有这个key
    db.t2.insert({'a':10,'b':111})
    db.t2.insert({'a':20})
    db.t2.insert({'b':null})
    
    > db.t2.find({"b":null})
    { "_id" : ObjectId("5a5cc2a7c1b4645aad959e5a"), "a" : 20 }
    { "_id" : ObjectId("5a5cc2a8c1b4645aad959e5b"), "b" : null }
    
    #2、查找所有
    db.user.find() #等同于db.user.find({})
    db.user.find().pretty()
    
    #3、查找一个,与find用法一致,只是只取匹配成功的第一个
    db.user.findOne({"_id":{"$gt":3}})
    其他

    5、数据库操作

    #1、增
    use config #如果数据库不存在,则创建数据库,否则切换到指定数据库。
    
    #2、查
    show dbs #查看所有
    可以看到,我们刚创建的数据库config并不在数据库的列表中, 要显示它,我们需要向config数据库插入一些数据。
    db.table1.insert({'a':1})
    
    #3、删
    use config #先切换到要删的库下
    db.dropDatabase() #删除当前库
    数据库操作

    6、集合操作

    #1、增
    当第一个文档插入时,集合就会被创建
    > use database1
    switched to db database1
    > db.table1.insert({'a':1})
    WriteResult({ "nInserted" : 1 })
    > db.table2.insert({'b':2})
    WriteResult({ "nInserted" : 1 })
    
    #2、查
    > show tables
    table1
    table2
    
    #3、删
    > db.table1.drop()
    true
    > show tables
    table2
    集合操作
    如果你有数据存储在MongoDB中,你想做的可能就不仅仅是将数据提取出来那么简单了;你可能希望对数据进行分析并加以利用。MongoDB提供了以下聚合工具:
    #1、聚合框架
    #2、MapReduce(详见MongoDB权威指南)
    #3、几个简单聚合命令:count、distinct和group。(详见MongoDB权威指南)
    
    #聚合框架:
    可以使用多个构件创建一个管道,上一个构件的结果传给下一个构件。
    这些构件包括(括号内为构件对应的操作符):筛选($match)、投射($project)、分组($group)、排序($sort)、限制($limit)、跳过($skip)
    不同的管道操作符可以任意组合,重复使用
    聚合
    from pymongo import MongoClient
    import datetime
    
    client=MongoClient('mongodb://root:123@localhost:27017')
    table=client['db1']['emp']
    # table.drop()
    
    l=[
    ('egon','male',18,'20170301','老男孩驻沙河办事处外交大使',7300.33,401,1), #以下是教学部
    ('alex','male',78,'20150302','teacher',1000000.31,401,1),
    ('wupeiqi','male',81,'20130305','teacher',8300,401,1),
    ('yuanhao','male',73,'20140701','teacher',3500,401,1),
    ('liwenzhou','male',28,'20121101','teacher',2100,401,1),
    ('jingliyang','female',18,'20110211','teacher',9000,401,1),
    ('jinxin','male',18,'19000301','teacher',30000,401,1),
    ('成龙','male',48,'20101111','teacher',10000,401,1),
    
    ('歪歪','female',48,'20150311','sale',3000.13,402,2),#以下是销售部门
    ('丫丫','female',38,'20101101','sale',2000.35,402,2),
    ('丁丁','female',18,'20110312','sale',1000.37,402,2),
    ('星星','female',18,'20160513','sale',3000.29,402,2),
    ('格格','female',28,'20170127','sale',4000.33,402,2),
    
    ('张野','male',28,'20160311','operation',10000.13,403,3), #以下是运营部门
    ('程咬金','male',18,'19970312','operation',20000,403,3),
    ('程咬银','female',18,'20130311','operation',19000,403,3),
    ('程咬铜','male',18,'20150411','operation',18000,403,3),
    ('程咬铁','female',18,'20140512','operation',17000,403,3)
    ]
    
    for n,item in enumerate(l):
        d={
            "_id":n,
            'name':item[0],
            'sex':item[1],
            'age':item[2],
            'hire_date':datetime.datetime.strptime(item[3],'%Y%m%d'),
            'post':item[4],
            'salary':item[5]
        }
        table.save(d)
    准备数据
    {"$match":{"字段":"条件"}},可以使用任何常用查询操作符$gt,$lt,$in等
    
    #例1、select * from db1.emp where post='teacher';
    db.emp.aggregate({"$match":{"post":"teacher"}})
    
    #例2、select * from db1.emp where id > 3 group by post;  
    db.emp.aggregate(
        {"$match":{"_id":{"$gt":3}}},
        {"$group":{"_id":"$post",'avg_salary':{"$avg":"$salary"}}}
    )
    
    #例3、select * from db1.emp where id > 3 group by post having avg(salary) > 10000;  
    db.emp.aggregate(
        {"$match":{"_id":{"$gt":3}}},
        {"$group":{"_id":"$post",'avg_salary':{"$avg":"$salary"}}},
        {"$match":{"avg_salary":{"$gt":10000}}}
    )
    筛选:$match
    {"$project":{"要保留的字段名":1,"要去掉的字段名":0,"新增的字段名":"表达式"}}
    
    #1、select name,post,(age+1) as new_age from db1.emp;
    db.emp.aggregate(
        {"$project":{
            "name":1,
            "post":1,
            "new_age":{"$add":["$age",1]}
            }
    })
    
    #2、表达式之数学表达式
    {"$add":[expr1,expr2,...,exprN]} #相加
    {"$subtract":[expr1,expr2]} #第一个减第二个
    {"$multiply":[expr1,expr2,...,exprN]} #相乘
    {"$divide":[expr1,expr2]} #第一个表达式除以第二个表达式的商作为结果
    {"$mod":[expr1,expr2]} #第一个表达式除以第二个表达式得到的余数作为结果
    
    #3、表达式之日期表达式:$year,$month,$week,$dayOfMonth,$dayOfWeek,$dayOfYear,$hour,$minute,$second
    #例如:select name,date_format("%Y") as hire_year from db1.emp
    db.emp.aggregate(
        {"$project":{"name":1,"hire_year":{"$year":"$hire_date"}}}
    )
    
    #例如查看每个员工的工作多长时间
    db.emp.aggregate(
        {"$project":{"name":1,"hire_period":{
            "$subtract":[
                {"$year":new Date()},
                {"$year":"$hire_date"}
            ]
        }}}
    )
    
    
    #4、字符串表达式
    {"$substr":[字符串/$值为字符串的字段名,起始位置,截取几个字节]}
    {"$concat":[expr1,expr2,...,exprN]} #指定的表达式或字符串连接在一起返回,只支持字符串拼接
    {"$toLower":expr}
    {"$toUpper":expr}
    
    db.emp.aggregate( {"$project":{"NAME":{"$toUpper":"$name"}}})
    
    #5、逻辑表达式
    $and
    $or
    $not
    其他见Mongodb权威指南
    投射:$project
    {"$group":{"_id":分组字段,"新的字段名":聚合操作符}}
    
    #1、将分组字段传给$group函数的_id字段即可
    {"$group":{"_id":"$sex"}} #按照性别分组
    {"$group":{"_id":"$post"}} #按照职位分组
    {"$group":{"_id":{"state":"$state","city":"$city"}}} #按照多个字段分组,比如按照州市分组
    
    #2、分组后聚合得结果,类似于sql中聚合函数的聚合操作符:$sum、$avg、$max、$min、$first、$last
    #例1:select post,max(salary) from db1.emp group by post; 
    db.emp.aggregate({"$group":{"_id":"$post","max_salary":{"$max":"$salary"}}})
    
    #例2:去每个部门最大薪资与最低薪资
    db.emp.aggregate({"$group":{"_id":"$post","max_salary":{"$max":"$salary"},"min_salary":{"$min":"$salary"}}})
    
    #例3:如果字段是排序后的,那么$first,$last会很有用,比用$max和$min效率高
    db.emp.aggregate({"$group":{"_id":"$post","first_id":{"$first":"$_id"}}})
    
    #例4:求每个部门的总工资
    db.emp.aggregate({"$group":{"_id":"$post","count":{"$sum":"$salary"}}})
    
    #例5:求每个部门的人数
    db.emp.aggregate({"$group":{"_id":"$post","count":{"$sum":1}}})
    
    #3、数组操作符
    {"$addToSet":expr}:不重复
    {"$push":expr}:重复
    
    #例:查询岗位名以及各岗位内的员工姓名:select post,group_concat(name) from db1.emp group by post;
    db.emp.aggregate({"$group":{"_id":"$post","names":{"$push":"$name"}}})
    db.emp.aggregate({"$group":{"_id":"$post","names":{"$addToSet":"$name"}}})
    分组:$group
    {"$sort":{"字段名":1,"字段名":-1}} #1升序,-1降序
    {"$limit":n} 
    {"$skip":n} #跳过多少个文档
    
    #例1、取平均工资最高的前两个部门
    db.emp.aggregate(
    {
        "$group":{"_id":"$post","平均工资":{"$avg":"$salary"}}
    },
    {
        "$sort":{"平均工资":-1}
    },
    {
        "$limit":2
    }
    )
    #例2、
    db.emp.aggregate(
    {
        "$group":{"_id":"$post","平均工资":{"$avg":"$salary"}}
    },
    {
        "$sort":{"平均工资":-1}
    },
    {
        "$limit":2
    },
    {
        "$skip":1
    }
    )
    排序:$sort、限制:$limit、跳过:$skip
    #集合users包含的文档如下
    { "_id" : 1, "name" : "dave123", "q1" : true, "q2" : true }
    { "_id" : 2, "name" : "dave2", "q1" : false, "q2" : false  }
    { "_id" : 3, "name" : "ahn", "q1" : true, "q2" : true  }
    { "_id" : 4, "name" : "li", "q1" : true, "q2" : false  }
    { "_id" : 5, "name" : "annT", "q1" : false, "q2" : true  }
    { "_id" : 6, "name" : "li", "q1" : true, "q2" : true  }
    { "_id" : 7, "name" : "ty", "q1" : false, "q2" : true  }
    
    #下述操作时从users集合中随机选取3个文档
    db.users.aggregate(
       [ { $sample: { size: 3 } } ]
    )
    随机选取n个:$sample
    from pymongo import MongoClient
    
    #1、链接
    client=MongoClient('mongodb://root:123@localhost:27017/')
    # client = MongoClient('localhost', 27017)
    
    #2、use 数据库
    db=client['db2'] #等同于:client.db1
    
    #3、查看库下所有的集合
    print(db.collection_names(include_system_collections=False))
    
    #4、创建集合
    table_user=db['userinfo'] #等同于:db.user
    
    #5、插入文档
    import datetime
    user0={
        "_id":1,
        "name":"egon",
        "birth":datetime.datetime.now(),
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'BJ'
        }
    }
    
    user1={
        "_id":2,
        "name":"alex",
        "birth":datetime.datetime.now(),
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'weifang'
        }
    }
    # res=table_user.insert_many([user0,user1]).inserted_ids
    # print(res)
    # print(table_user.count())
    
    #6、查找
    
    # from pprint import pprint#格式化细
    # pprint(table_user.find_one())
    # for item in table_user.find():
    #     pprint(item)
    
    # print(table_user.find_one({"_id":{"$gte":1},"name":'egon'}))
    
    #7、更新
    table_user.update({'_id':1},{'name':'EGON'})
    
    #8、传入新的文档替换旧的文档
    table_user.save(
        {
            "_id":2,
            "name":'egon_xxx'
        }
    )
    练习

    五、pymongo

    官网点击

    from pymongo import MongoClient
    
    #1、链接
    client=MongoClient('mongodb://root:123@localhost:27017/')
    # client = MongoClient('localhost', 27017)
    
    #2、use 数据库
    db=client['db2'] #等同于:client.db1
    
    #3、查看库下所有的集合
    print(db.collection_names(include_system_collections=False))
    
    #4、创建集合
    table_user=db['userinfo'] #等同于:db.user
    
    #5、插入文档
    import datetime
    user0={
        "_id":1,
        "name":"egon",
        "birth":datetime.datetime.now(),
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'BJ'
        }
    }
    
    user1={
        "_id":2,
        "name":"alex",
        "birth":datetime.datetime.now(),
        "age":10,
        'hobbies':['music','read','dancing'],
        'addr':{
            'country':'China',
            'city':'weifang'
        }
    }
    # res=table_user.insert_many([user0,user1]).inserted_ids
    # print(res)
    # print(table_user.count())
    
    #6、查找
    
    # from pprint import pprint#格式化细
    # pprint(table_user.find_one())
    # for item in table_user.find():
    #     pprint(item)
    
    # print(table_user.find_one({"_id":{"$gte":1},"name":'egon'}))
    
    #7、更新
    table_user.update({'_id':1},{'name':'EGON'})
    
    #8、传入新的文档替换旧的文档
    table_user.save(
        {
            "_id":2,
            "name":'egon_xxx'
        }
    )
    View Code
  • 相关阅读:
    Linux Core Dump
    ODP.NET Managed正式推出
    获取EditText的光标位置
    (Java实现) 洛谷 P1603 斯诺登的密码
    (Java实现) 洛谷 P1603 斯诺登的密码
    (Java实现) 洛谷 P1036 选数
    (Java实现) 洛谷 P1036 选数
    (Java实现) 洛谷 P1012 拼数
    (Java实现) 洛谷 P1012 拼数
    (Java实现) 洛谷 P1028 数的计算
  • 原文地址:https://www.cnblogs.com/bubu99/p/10587486.html
Copyright © 2011-2022 走看看