博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
MongoDB基本操作
阅读量：5794 次
发布时间：2019-06-18

本文共 22530 字，大约阅读时间需要 75 分钟。

准备：集合测试数据
db.col.insert({name:"chavin",age:"28“”,job:"DBA"})
db.col.insert({name:"dbk",age:"28",job:"java工程师"})
db.col.insert({name:"dbk",age:"28",job:"java工程师"})
db.col.insert({name:"dbk",age:"28",job:"java工程师"})
db.col.insert({name:"nope",age:"28",job:"会计"})
db.col.insert({name:"king",age:"35",job:"CTO"})
db.col.insert({name:"chavinking",age:"35",job:"CTO"})
db.col.insert({name:"舒永康",age:"35",job:"java高级工程师"})
db.col.insert({name:"张芳",age:"30",job:"集成工程师"})

1、创建数据库
MongoDB 创建数据库的语法格式如下：
use DATABASE_NAME

--查看所有mongodb数据库

MongoDB Enterprise > show dbs
admin  0.000GB
local  0.000GB
--创建数据库，如果存在则切换数据库
MongoDB Enterprise > use dbking
switched to db dbking
MongoDB Enterprise > show dbs
admin  0.000GB
local  0.000GB
--显示当前连接数据库
MongoDB Enterprise > db
dbking
--首次创建数据库需要insert新数据才能成功创建，否则仅在内存中生效，退出数据库自动删除
MongoDB Enterprise > db.col.insert({name:"chavin",age:28,job:"DBA"})
WriteResult({ "nInserted" : 1 })
MongoDB Enterprise > show dbs
admin   0.000GB
dbking  0.000GB
local   0.000GB

2、删除数据库

    删除数据库语法：db.dropDatabase()，表示删除当前数据库。
MongoDB Enterprise > db
dbking
--删除dbking数据库
MongoDB Enterprise > db.dropDatabase()
{ "dropped" : "dbking", "ok" : 1 }
MongoDB Enterprise > db
dbking
MongoDB Enterprise > show dbs
admin  0.000GB
local  0.000GB

3、向mongodb数据库集合中插入文档

MongoDB 使用 insert() 或 save() 方法向集合中插入文档，语法如下：
db.COLLECTION_NAME.insert(document)
--向集合中插入一条数据
MongoDB Enterprise > db.col.insert({name:"chavin",age:28,job:"DBA"})
WriteResult({ "nInserted" : 1 })
MongoDB Enterprise > db.col.insert({name:"dbk",age:28,job:"java工程师"})
WriteResult({ "nInserted" : 1 })
--也可以如下方式插入数据
MongoDB Enterprise > doc=({name:"king",age:"35",job:"CTO"})
{ "name" : "king", "age" : "35", "job" : "CTO" }
MongoDB Enterprise > doc
{ "name" : "king", "age" : "35", "job" : "CTO" }
MongoDB Enterprise > db.col.insert(doc)
WriteResult({ "nInserted" : 1 })

--查看dbking.col集合数据：find()为查询函数

MongoDB Enterprise > db.col.find()
{ "_id" : ObjectId("586285166aee0c58632c0b8e"), "name" : "chavin", "age" : 28, "job" : "DBA" }
{ "_id" : ObjectId("586285a06aee0c58632c0b8f"), "name" : "dbk", "age" : 28, "job" : "java工程师" }
{ "_id" : ObjectId("5862863b6aee0c58632c0b90"), "name" : "king", "age" : "35", "job" : "CTO" }

--格式化查询显示结果：pretty()格式化函数

MongoDB Enterprise > db.col.find().pretty()
{
        "_id" : ObjectId("586285166aee0c58632c0b8e"),
        "name" : "chavin",
        "age" : 28,
        "job" : "DBA"
}
{
        "_id" : ObjectId("586285a06aee0c58632c0b8f"),
        "name" : "dbk",
        "age" : 28,
        "job" : "java工程师"
}
{
        "_id" : ObjectId("5862863b6aee0c58632c0b90"),
        "name" : "king",
        "age" : "35",
        "job" : "CTO"
}

4、删除文档

MongoDB remove()函数是用来移除集合中的数据。
remove() 方法的基本语法格式如下所示：
db.collection.remove(
   <query>,
   <justOne>
)
如果你的 MongoDB 是 2.6 版本以后的，语法格式如下：
db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)
参数说明：
query :（可选）删除的文档的条件。
justOne : （可选）如果设为 true 或 1，则只删除一个文档。
writeConcern :（可选）抛出异常的级别。

--插入一行数据

MongoDB Enterprise > db.col.insert({name:123})
WriteResult({ "nInserted" : 1 })

--删除刚刚插入的数据

MongoDB Enterprise > db.col.remove({name:123})
WriteResult({ "nRemoved" : 1 })

--删除age为28的记录

MongoDB Enterprise > db.col.remove({age:28})
WriteResult({ "nRemoved" : 2 })
MongoDB Enterprise > db.col.find().pretty()
{
        "_id" : ObjectId("5862863b6aee0c58632c0b90"),
        "name" : "king",
        "age" : "35",
        "job" : "CTO"
}

--插入2条数据

MongoDB Enterprise > db.col.insert({name:"chavin",age:"28",job:"DBA"})
WriteResult({ "nInserted" : 1 })
MongoDB Enterprise > db.col.insert({name:"chavin",age:"28",job:"DBA"})
WriteResult({ "nInserted" : 1 })

--如果你只想删除第一条找到的记录可以设置 justOne 为 1，如下所示：

MongoDB Enterprise > db.col.find()

{ "_id" : ObjectId("586310a9e423fe7088062a91"), "name" : "chavin", "age" : "28", "job" : "DBA" }
{ "_id" : ObjectId("586310aae423fe7088062a92"), "name" : "chavin", "age" : "28", "job" : "DBA" }

MongoDB Enterprise > db.col.remove({name:"chavin"},1)

WriteResult({ "nRemoved" : 1 })
MongoDB Enterprise > db.col.find()
{ "_id" : ObjectId("586310aae423fe7088062a92"), "name" : "chavin", "age" : "28", "job" : "DBA" }

--删除集合所有数据（如果数据量非常大，remove不如直接drop集合，然后重建集合及其索引）

MongoDB Enterprise > db.col.remove({})

WriteResult({ "nRemoved" : 7 })
MongoDB Enterprise > db.col.find()

5、更改集合

MongoDB 使用 update() 和 save() 方法来更新集合中的文档。接下来让我们详细来看下两个函数的应用及其区别。

update() 方法用于更新已存在的文档。语法格式如下：

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)
参数说明：
query : update的查询条件，类似sql update查询内where后面的。
update : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
writeConcern :可选，抛出异常的级别。

--查看当前col集合下文档信息

MongoDB Enterprise > db.col.find()
{ "_id" : ObjectId("58634612e423fe7088062a9d"), "name" : "chavin", "age" : "28", "job" : "DBA" }
{ "_id" : ObjectId("58634612e423fe7088062a9e"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062a9f"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062aa0"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062aa1"), "name" : "nope", "age" : "28", "job" : "会计" }
{ "_id" : ObjectId("58634613e423fe7088062aa2"), "name" : "king", "age" : "35", "job" : "CTO" }

--update更新示例，默认只能更新查到的第一行匹配数据

MongoDB Enterprise > db.col.update({name:"dbk"},{$set:{name:"wcw"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
MongoDB Enterprise > db.col.find()
{ "_id" : ObjectId("58634612e423fe7088062a9d"), "name" : "chavin", "age" : "28", "job" : "DBA" }
{ "_id" : ObjectId("58634612e423fe7088062a9e"), "name" : "wcw", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062a9f"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062aa0"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062aa1"), "name" : "nope", "age" : "28", "job" : "会计" }
{ "_id" : ObjectId("58634613e423fe7088062aa2"), "name" : "king", "age" : "35", "job" : "CTO" }

以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true。

MongoDB Enterprise > db.col.update({name:"dbk"},{$set:{name:"wcw"}},false,true)

WriteResult({ "nMatched" : 2, "nUpserted" : 0, "nModified" : 2 })
MongoDB Enterprise > db.col.find()
{ "_id" : ObjectId("58634612e423fe7088062a9d"), "name" : "chavin", "age" : "28", "job" : "DBA" }
{ "_id" : ObjectId("58634612e423fe7088062a9e"), "name" : "wcw", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062a9f"), "name" : "wcw", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062aa0"), "name" : "wcw", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634612e423fe7088062aa1"), "name" : "nope", "age" : "28", "job" : "会计" }
{ "_id" : ObjectId("58634613e423fe7088062aa2"), "name" : "king", "age" : "35", "job" : "CTO" }

save() 方法更新文档

save() 方法通过传入的文档来替换已有文档。语法格式如下：
db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)
参数说明：
document : 文档数据。
writeConcern :可选，抛出异常的级别。

--save存在则替换，否则则插入

MongoDB Enterprise > db.col.save({_id:ObjectId("58634612e423fe7088062a9e"),name:"dbk",age:30,job:"DBA"})

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

MongoDB Enterprise > db.col.save({_id:123,name:"dbk",age:30,job:"DBA"})

WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : 123 })

MongoDB Enterprise > db.col.save({name:"dbk01",age:30,job:"DBA"})

WriteResult({ "nInserted" : 1 })

--更新实例

全部更新：
db.col.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
只更新第一条记录：
db.col.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

6、mongodb查询文档

语法

MongoDB 查询数据的语法格式如下：
>db.COLLECTION_NAME.find()
find() 方法以非结构化的方式来显示所有文档。
如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：
>db.col.find().pretty()
pretty() 方法以格式化的方式来显示所有文档。

除了 find() 方法之外，还有一个 findOne() 方法，它只返回一个文档。

--find()示例

MongoDB Enterprise > db.col.find()

{ "_id" : ObjectId("58634a61e423fe7088062aa5"), "name" : "chavin", "age" : "28", "job" : "DBA" }
{ "_id" : ObjectId("58634a62e423fe7088062aa6"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
MongoDB Enterprise > db.col.find().pretty()
{
    "_id" : ObjectId("58634a61e423fe7088062aa5"),
    "name" : "chavin",
    "age" : "28",
    "job" : "DBA"
}
{
    "_id" : ObjectId("58634a62e423fe7088062aa6"),
    "name" : "dbk",
    "age" : "28",
    "job" : "java工程师"
}

MongoDB 与 RDBMS Where 语句比较

如果你熟悉常规的 SQL 数据，通过下表可以更好的理解 MongoDB 的条件语句查询：

操作                    格式                              范例                                      RDBMS中的类似语句

---------------------------------------------------------------------------------------------------------------------------
等于                {<key>:<value>}            db.col.find({"by":"菜鸟教程"}).pretty()            where by = '菜鸟教程'
小于                {<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

MongoDB AND 条件

MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，及常规 SQL 的 AND 条件。
语法格式如下：
>db.col.find({key1:value1, key2:value2}).pretty()

--查询示例

MongoDB Enterprise > db.col.find({age:"28",name:"dbk"}).pretty()

{
    "_id" : ObjectId("58634a62e423fe7088062aa6"),
    "name" : "dbk",
    "age" : "28",
    "job" : "java工程师"
}

相当于关系型数据库中的··where age=28 and name='dbk'

MongoDB OR 条件

MongoDB OR 条件语句使用了关键字 $or,语法格式如下：
>db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

--find示例$or

MongoDB Enterprise > db.col.find({$or:[{age:"28"},{name:"dbk"}]}).pretty()

{
    "_id" : ObjectId("58634a61e423fe7088062aa5"),
    "name" : "chavin",
    "age" : "28",
    "job" : "DBA"
}
{
    "_id" : ObjectId("58634a62e423fe7088062aa6"),
    "name" : "dbk",
    "age" : "28",
    "job" : "java工程师"
}
{
    "_id" : ObjectId("58634c2ae423fe7088062aa7"),
    "name" : "chavin",
    "age" : "28",
    "job" : "DBA"
}

--AND 和 OR 联合使用 find示例

MongoDB Enterprise > db.col.find({$or:[{age:"28",name:"chavin"},{age:"35",name:"舒永康"}]}).pretty()

{
    "_id" : ObjectId("58634df8e423fe7088062aaf"),
    "name" : "舒永康",
    "age" : "35",
    "job" : "java高级工程师"
}
{
    "_id" : ObjectId("58634f5fe423fe7088062ab1"),
    "name" : "chavin",
    "age" : "28",
    "job" : "DBA"
}

7、MongoDB 条件操作符

描述：条件操作符用于比较两个表达式并从mongoDB集合中获取数据。

MongoDB中条件操作符有：

(>)                大于 -                    $gt
(<)                小于 -                    $lt
(>=)               大于等于 -                $gte
(<= )              小于等于 -                $lte
(<>)               不等于 -                  $ne

--MongoDB (>) 大于操作符 - $gt

MongoDB Enterprise > db.col.find({age:{$gt:"28"}})

{ "_id" : ObjectId("58634df8e423fe7088062aad"), "name" : "king", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58634df8e423fe7088062aae"), "name" : "chavinking", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58634df8e423fe7088062aaf"), "name" : "舒永康", "age" : "35", "job" : "java高级工程师" }
{ "_id" : ObjectId("58634dfae423fe7088062ab0"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }

--MongoDB（>=）大于等于操作符 - $gte

MongoDB Enterprise > db.col.find({age:{$gte:"30"}})

{ "_id" : ObjectId("58634df8e423fe7088062aad"), "name" : "king", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58634df8e423fe7088062aae"), "name" : "chavinking", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58634df8e423fe7088062aaf"), "name" : "舒永康", "age" : "35", "job" : "java高级工程师" }
{ "_id" : ObjectId("58634dfae423fe7088062ab0"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }

--MongoDB (<) 小于操作符 - $lt

MongoDB Enterprise > db.col.find({age:{$lt:"30"}})

{ "_id" : ObjectId("58634a62e423fe7088062aa6"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aa9"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aaa"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aab"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aac"), "name" : "nope", "age" : "28", "job" : "会计" }
{ "_id" : ObjectId("58634f5fe423fe7088062ab1"), "name" : "chavin", "age" : "28", "job" : "DBA" }

--MongoDB (<=) 小于操作符 - $lte

MongoDB Enterprise > db.col.find({age:{$lte:"30"}})

{ "_id" : ObjectId("58634a62e423fe7088062aa6"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aa9"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aaa"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aab"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58634df8e423fe7088062aac"), "name" : "nope", "age" : "28", "job" : "会计" }
{ "_id" : ObjectId("58634dfae423fe7088062ab0"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }
{ "_id" : ObjectId("58634f5fe423fe7088062ab1"), "name" : "chavin", "age" : "28", "job" : "DBA" }

--mongodb(<>) 不等于 - $ne

MongoDB Enterprise > db.col.find({age:{$ne:"28"}})

{ "_id" : ObjectId("58634df8e423fe7088062aad"), "name" : "king", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58634df8e423fe7088062aae"), "name" : "chavinking", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58634df8e423fe7088062aaf"), "name" : "舒永康", "age" : "35", "job" : "java高级工程师" }
{ "_id" : ObjectId("58634dfae423fe7088062ab0"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }

--MongoDB 使用 (<) 和 (>) 查询 - $lt 和 $gt

MongoDB Enterprise > db.col.find({age:{$gt:"28",$lt:"35"}})

{ "_id" : ObjectId("58634dfae423fe7088062ab0"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }

8、mongodb中可以使用的类型如下：

类型                            数字                          备注

---------------------------------------------------------------------
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    

--$type示例

MongoDB Enterprise > db.col.find().pretty()

{
    "_id" : ObjectId("586358cde423fe7088062ab2"),
    "name" : "dbk",
    "age" : "28",
    "job" : "java工程师"
}
{
    "_id" : ObjectId("586358d7e423fe7088062ab3"),
    "name" : "dbk",
    "age" : 30,
    "job" : "java工程师"
}
{
    "_id" : ObjectId("586358dbe423fe7088062ab4"),
    "name" : "dbk",
    "age" : 31,
    "job" : "java工程师"
}

MongoDB Enterprise > db.col.find({age:{$type:2}})

{ "_id" : ObjectId("586358cde423fe7088062ab2"), "name" : "dbk", "age" : "28", "job" : "java工程师" }

9、MongoDB Limit与Skip方法（分页）

MongoDB Limit() 方法

如果你需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。
语法
limit()方法基本语法如下所示：
>db.COLLECTION_NAME.find().limit(NUMBER)

--limit()示例

MongoDB Enterprise > db.col.find().limit(2)
{ "_id" : ObjectId("586358cde423fe7088062ab2"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("586358d7e423fe7088062ab3"), "name" : "dbk", "age" : 30, "job" : "java工程师" }

MongoDB Skip() 方法

我们除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。
语法
skip() 方法脚本语法格式如下：
>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

--skip()示例

MongoDB Enterprise > db.col.find().skip(10)
{ "_id" : ObjectId("58635ec6e423fe7088062abc"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }

--skip和limit连用示例，表示输出第10条和11条数据

MongoDB Enterprise > db.col.find().limit(2).skip(9)
{ "_id" : ObjectId("58635ec5e423fe7088062abb"), "name" : "舒永康", "age" : "35", "job" : "java高级工程师" }
{ "_id" : ObjectId("58635ec6e423fe7088062abc"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }

10、MongoDB sort()方法

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

sort()方法基本语法如下所示：

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

--sort()方法示例

MongoDB Enterprise > db.col.find({age:{$type:2}}).sort({age:1})

{ "_id" : ObjectId("586358cde423fe7088062ab2"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab5"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab6"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab7"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab8"), "name" : "nope", "age" : "28", "job" : "会计" }
{ "_id" : ObjectId("58635ec6e423fe7088062abc"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab9"), "name" : "king", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58635ec5e423fe7088062aba"), "name" : "chavinking", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58635ec5e423fe7088062abb"), "name" : "舒永康", "age" : "35", "job" : "java高级工程师" }
MongoDB Enterprise > db.col.find({age:{$type:2}}).sort({age:-1})
{ "_id" : ObjectId("58635ec5e423fe7088062ab9"), "name" : "king", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58635ec5e423fe7088062aba"), "name" : "chavinking", "age" : "35", "job" : "CTO" }
{ "_id" : ObjectId("58635ec5e423fe7088062abb"), "name" : "舒永康", "age" : "35", "job" : "java高级工程师" }
{ "_id" : ObjectId("58635ec6e423fe7088062abc"), "name" : "张芳", "age" : "30", "job" : "集成工程师" }
{ "_id" : ObjectId("586358cde423fe7088062ab2"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab5"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab6"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab7"), "name" : "dbk", "age" : "28", "job" : "java工程师" }
{ "_id" : ObjectId("58635ec5e423fe7088062ab8"), "name" : "nope", "age" : "28", "job" : "会计" }

11、find()返回相应字段方法

语法：

field：1   --表示返回该字段
_id:0      --表示不反悔_id字段

MongoDB Enterprise > db.col.find({},{"name":1,_id:0})

{ "name" : "dbk" }
{ "name" : "dbk" }
{ "name" : "dbk" }
{ "name" : "dbk" }
{ "name" : "dbk" }
{ "name" : "dbk" }
{ "name" : "nope" }
{ "name" : "king" }
{ "name" : "chavinking" }
{ "name" : "舒永康" }
{ "name" : "张芳" }

MongoDB Enterprise > db.col.find({age:{$type:2}},{name:1,age:1,_id:0}).sort({age:-1})

{ "name" : "king", "age" : "35" }
{ "name" : "chavinking", "age" : "35" }
{ "name" : "舒永康", "age" : "35" }
{ "name" : "张芳", "age" : "30" }
{ "name" : "dbk", "age" : "28" }
{ "name" : "dbk", "age" : "28" }
{ "name" : "dbk", "age" : "28" }
{ "name" : "dbk", "age" : "28" }
{ "name" : "nope", "age" : "28" }

MongoDB 索引

索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。
这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。

ensureIndex() 方法 或 createIndex() 方法

MongoDB使用 ensureIndex() 方法来创建索引。

ensureIndex()方法基本语法格式如下所示：

>db.COLLECTION_NAME.ensureIndex({KEY:1})
语法中 Key 值为你要创建的索引字段，1为指定按升序创建索引，如果你想按降序来创建索引指定为-1即可。

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.

--创建index示例

MongoDB Enterprise > db.col.createIndex({"name":1,"age":1})

{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 5,
    "numIndexesAfter" : 6,
    "ok" : 1
}
MongoDB Enterprise > db.col.ensureIndex({"name":1,"age":1,"job":-1})
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 6,
    "numIndexesAfter" : 7,
    "ok" : 1
}

12、删除集合方法

语法：db.collection.drop()

MongoDB Enterprise > show collections

col
test01

MongoDB Enterprise > db.test01.drop()

true

MongoDB Enterprise > show collections

col

13、mongodb聚合操作

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

aggregate() 方法
MongoDB中聚合的方法使用aggregate()。

aggregate() 方法的基本语法格式如下所示：

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

下表展示了一些聚合的表达式:

表达式       描述                                                实例

-----------------------------------------------------------------------------------------------------------------------------------
$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"}}}})

--group示例

MongoDB Enterprise > db.col.aggregate({$group:{_id:"$name",num_c:{$sum:1}}})

{ "_id" : "张芳", "num_c" : 1 }
{ "_id" : "舒永康", "num_c" : 1 }
{ "_id" : "dbk", "num_c" : 6 }
{ "_id" : "nope", "num_c" : 1 }
{ "_id" : "king", "num_c" : 1 }
{ "_id" : "chavinking", "num_c" : 1 }

说明：以上实例类似sql语句： select by_user, count(*) from mycol group by by_user；

在上面的例子中，我们通过字段by_user字段对数据进行分组，并计算by_user字段相同值的总和。

>管道的概念

管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。

MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。
这里我们介绍一下聚合框架中常用的几个操作：
---------------------------------------------------------------------------------------------------
$project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
$match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
$limit：用来限制MongoDB聚合管道返回的文档数。
$skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
$unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
$group：将集合中的文档分组，可用于统计结果。
$sort：将输入文档排序后输出。
$geoNear：输出接近某一地理位置的有序文档。

--管道操作示例

1）$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管道操作符处理后，前五个文档被"过滤"掉。

转载地址：http://fhffx.baihongyu.com/

你可能感兴趣的文章
EXCEL表中如何让数值变成万元或亿元
查看>>
L104
查看>>
CTOR有助于BCH石墨烯技术更上一层楼
查看>>
被遗忘的CSS
查看>>
Webpack中的sourcemap以及如何在生产和开发环境中合理的设置sourcemap的类型
查看>>
做完小程序项目、老板给我加了6k薪资～
查看>>
自制一个 elasticsearch-spring-boot-starter
查看>>
【人物志】美团前端通道主席洪磊：一位产品出身、爱焊电路板的工程师
查看>>
一份关于数据科学家应该具备的技能清单
查看>>
机器学习实战_一个完整的程序（一）
查看>>
Web框架的常用架构模式（JavaScript语言）
查看>>
CSS盒模型
查看>>
ng2路由延时加载模块
查看>>
使用GitHub的十个最佳实践
查看>>
脱离“体验”和“安全”谈盈利的游戏运营 都是耍流氓
查看>>
慎用！BLEU评价NLP文本输出质量存在严重问题
查看>>
JAVA的优势就是劣势啊！
查看>>
ELK实战之logstash部署及基本语法
查看>>
LINUX下防恶意扫描软件PortSentry
查看>>
如何 debug Proxy.pac文件
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-12-22 02:29:16   当前IP: 18.224.69.137   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我