MongoDB 数据库

最新推荐文章于 2022-10-12 11:45:34 发布
最新推荐文章于 2022-10-12 11:45:34 发布
阅读量336 收藏 1
点赞数 1
分类专栏： MongoDB

MongoDB 概念解析

在mongodb中基本的概念是文档、集合、数据库。

SQL术语/概念MongoDB术语/概念解释/说明
databasedatabase数据库
tablecollection数据库表/集合
rowdocument数据记录行/文档
columnfield数据字段/域
indexindex索引
primarykeyprimary key 主键,MongoDB自动将_id字段设置为主键

如下图：

在这里插入图片描述

（1）数据库

一个mongodb中可以建立多个数据库。
MongoDB的默认数据库为"db"，该数据库存储在data目录中。
MongoDB的单个实例可以容纳多个独立的数据库，每一个都有自己的集合和权限，不同的数据库也放置在不同的文件中。

  1. “show dbs” 命令可以显示所有数据的列表。
  2. 执行 “db” 命令可以显示当前数据库对象或集合。
  3. 运行"use"命令，可以连接到一个指定的数据库。
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
> db
test
> use local
switched to db local
> db
local

数据库也通过名字来标识。数据库名可以是满足以下条件的任意UTF-8字符串。

  • 不能是空字符串（"")。
  • 不得含有’ '（空格)、.、$、/、\和\0 (空字符)。
  • 应全部小写。
  • 最多64字节。

有一些数据库名是保留的，可以直接访问这些有特殊作用的数据库。

  • admin： 从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
  • local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合
  • config: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。
（2）文档

文档是一组键值(key-value)对(即BSON)。MongoDB 的文档不需要设置相同的字段，并且相同的字段不需要相同的数据类型，这与关系型数据库有很大的区别，也是 MongoDB 非常突出的特点。

表列出了 RDBMS 与 MongoDB 对应的术语：

RDBMSMongoDB
数据库数据库
表格集合
行文档
列字段
表联合嵌入文档
主键主键 (MongoDB 提供了 key 为 _id )

需要注意的是：

  1. 文档中的键/值对是有序的。
  2. 文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。
  3. MongoDB区分类型和大小写。
  4. MongoDB的文档不能有重复的键。
  5. 文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。

文档键命名规范：

  • 键不能含有\0 (空字符)。这个字符用来表示键的结尾。
  • .和$有特别的意义，只有在特定环境下才能使用。
  • 以下划线"_"开头的键是保留的(不是严格要求的)。
（3）集合

集合就是 MongoDB 文档组，类似于 RDBMS 中的表格。
集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据，但通常情况下我们插入集合的数据都会有一定的关联性。

比如，我们可以将以下不同数据结构的文档插入到集合中：

> db.site.insert({'site': 'www.baidu.com'})
WriteResult({ "nInserted" : 1 })
> db.site.insert({'site': 'www.google.com', 'name': 'Google'})
WriteResult({ "nInserted" : 1 })
> db.site.insert({'site': 'www.runoob.com', 'name': 'Runoob', 'num': 5})
WriteResult({ "nInserted" : 1 })

> db.site.find()
{ "_id" : ObjectId("5bd800b9ff37ee5746a7a49e"), "site" : "www.baidu.com" }
{ "_id" : ObjectId("5bd800d6ff37ee5746a7a49f"), "site" : "www.google.com", "name
" : "Google" }
{ "_id" : ObjectId("5bd80106ff37ee5746a7a4a0"), "site" : "www.runoob.com", "name
" : "Runoob", "num" : 5 }
>

注意：当第一个文档插入时，集合就会被创建。

合法的集合名：
  • 集合名不能是空字符串""。
  • 集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
  • 集合名不能以"system."开头，这是为系统集合保留的前缀。
  • 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。
capped collections

Capped collections 就是固定大小的collection。
它有很高的性能以及队列过期的特性(过期按照插入的顺序). 有点和 “RRD” 概念类似。
Capped collections 是高性能自动的维护对象的插入顺序。它非常适合类似记录日志的功能。和标准的 collection 不同，你必须要显式的创建一个capped collection，指定一个 collection 的大小，单位是字节。collection 的数据存储空间值提前分配的。
Capped collections 可以按照文档的插入顺序保存到集合中，而且这些文档在磁盘上存放位置也是按照插入顺序来保存的，所以当我们更新Capped collections 中文档的时候，更新后的文档不可以超过之前文档的大小，这样话就可以确保所有文档在磁盘上的位置一直保持不变。
由于 Capped collection 是按照文档的插入顺序而不是使用索引确定插入位置，这样的话可以提高增添数据的效率。MongoDB 的操作日志文件 oplog.rs 就是利用 Capped Collection 来实现的。
要注意的是指定的存储大小包含了数据库的头信息。

例：

> db.createCollection('user', {capped: true, size: 100000})
{ "ok" : 1 }
> db.user.insert({'name': 'Tom', 'age': 18})
WriteResult({ "nInserted" : 1 })
> db.user.find()
{ "_id" : ObjectId("5bd80455ff37ee5746a7a4a1"), "name" : "Tom", "age" : 18 }
  • 在 capped collection 中，你能添加新的对象。
  • 能进行更新，然而，对象不会增加存储空间。如果增加，更新就会失败 。
  • 使用 Capped Collection 不能删除一个文档，可以使用 drop() 方法删除 collection 所有的行。
  • 删除之后，你必须显式的重新创建这个 collection。
  • 在32bit机器中，capped collection 最大存储为 1e9( 1X109)个字节。
（4）元数据

数据库的信息是存储在集合中。它们使用了系统的命名空间：

dbname.system.*

在MongoDB数据库中名字空间 .system.* 是包含多种系统信息的特殊集合(Collection)，如下:

集合命名空间描述
dbname.system.namespaces列出所有名字空间。
dbname.system.indexes列出所有索引。
dbname.system.profile包含数据库概要(profile)信息。
dbname.system.users列出所有可访问数据库的用户。
dbname.local.sources包含复制对端（slave）的服务器信息和状态。

对于修改系统集合中的对象有如下限制。
在{{system.indexes}}插入数据，可以创建索引。但除此之外该表信息是不可变的(特殊的drop index命令将自动更新相关信息)。
{{system.users}}是可修改的。 {{system.profile}}是可删除的。

（5）MongoDB 数据类型

下表为MongoDB中常用的几种数据类型。

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

下面说明下几种重要的数据类型。

ObjectId

ObjectId 类似唯一主键，可以很快的去生成和排序，包含 12 bytes，含义是：

  • 前 4 个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间，比北京时间晚了 8 个小时
  • 接下来的 3 个字节是机器标识码
  • 紧接的两个字节由进程 id 组成 PID
  • 最后三个字节是随机数

在这里插入图片描述

MongoDB 中存储的文档必须有一个 _id 键。这个键的值可以是任何类型的，默认是个 ObjectId 对象。

由于 ObjectId 中保存了创建的时间戳，所以你不需要为你的文档保存时间戳字段，你可以通过 getTimestamp 函数来获取文档的创建时间:

> var newObject = ObjectId()
> newObject.getTimestamp()
ISODate("2018-10-30T07:36:23Z")

ObjectId 转为字符串：

> newObject.str
5bd809f7ff37ee5746a7a4a2
字符串

BSON 字符串都是 UTF-8 编码。

时间戳

BSON 有一个特殊的时间戳类型用于 MongoDB 内部使用，与普通的 日期 类型不相关。 时间戳值是一个 64 位的值。其中：

  • 前32位是一个 time_t 值（与Unix新纪元相差的秒数）
  • 后32位是在某秒中操作的一个递增的序数

在单个 mongod 实例中，时间戳值通常是唯一的。
在复制集中， oplog 有一个 ts 字段。这个字段中的值使用BSON时间戳表示了操作时间。

BSON 时间戳类型主要用于 MongoDB 内部使用。在大多数情况下的应用开发中，你可以使用 BSON 日期类型。

日期

表示当前距离 Unix新纪元（1970年1月1日）的毫秒数。日期类型是有符号的, 负数表示 1970 年之前的日期。

> var mydate1 = new Date()	//格林尼治时间
> mydate1
ISODate("2018-10-30T07:45:02.506Z")
> typeof mydate1
object

> var mydate2 = ISODate()
> mydate2
ISODate("2018-10-30T07:47:04.517Z")
> typeof mydate2
object

这样创建的时间是日期类型，可以使用 JS 中的 Date 类型的方法。
返回一个时间类型的字符串：

> var mydate1str = mydate1.toString()
> mydate1str
Tue Oct 30 2018 15:45:02 GMT+0800
> typeof mydate1
object

或者：

> Date()
Tue Oct 30 2018 15:49:25 GMT+0800

MongoDB 创建数据库

MongoDB 创建数据库的语法格式如下：

use DATABASE_NAME

如果数据库不存在，则创建数据库，否则切换到指定数据库。
例：

> use new_db
switched to db new_db
> db
new_db

如果想查看所有数据库，可以使用 show dbs 命令：

> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB

可以看到，刚创建的数据库 new_db 并不在数据库的列表中， 要显示它，我们需要向 new_db 数据库插入一些数据。

> db.new_db.insert({'name': 'Michael'})
WriteResult({ "nInserted" : 1 })
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
new_db  0.000GB
test    0.000GB

MongoDB 中默认的数据库为 test，如果你没有创建新的数据库，集合将存放在 test 数据库中。
注意: 在 MongoDB 中，集合只有在内容插入后才会创建! 就是说，创建集合(数据表)后要再插入一个文档(记录)，集合才会真正创建。

MongoDB 删除数据库

MongoDB 删除数据库的语法格式如下：

db.dropDatabase()

删除当前数据库，默认为 test，你可以使用 db 命令查看当前数据库名。
例：

> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
new_db  0.000GB
test    0.000GB

#切换到数据库 new_db
> use new_db
switched to db new_db
#执行删除命令
> db.dropDatabase()
{ "dropped" : "new_db", "ok" : 1 }

> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB

MongoDB 创建集合

MongoDB 中使用 createCollection() 方法来创建集合。

语法格式：

db.createCollection(name, options)

参数说明：

  • name: 要创建的集合名称
  • options: 可选参数, 指定有关内存大小及索引的选项

options 可以是如下参数：

字段类型描述
capped布尔（可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。
autoIndexId布尔（可选）如为 true，自动在 _id 字段创建索引。默认为 false。
size数值（可选）为固定集合指定一个最大值（以字节计）。如果 capped 为 true，也需要指定该字段。
max数值（可选）指定固定集合中包含文档的最大数量。

在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。

例：

> db
test
> show tables
runoob
site
> db.createCollection('user')
{ "ok" : 1 }
> show collections
runoob
site
user

如果要查看已有集合，可以使用 show collections 命令：

> show tables
runoob
site
user

下面是带有几个关键参数的 createCollection() 的用法：
例：创建固定集合 mycol，整个集合空间大小 6142800 KB, 文档最大个数为 10000 个

> db.createCollection('mycol', {capped: true, autoIndexId: true, size: 6142800,
max: 10000})
{
        "note" : "the autoIndexId option is deprecated and will be removed in a
future release",
        "ok" : 1
}
> show collections
mycol
runoob
site
user

在 MongoDB 中，你不需要创建集合。当你插入一些文档时，MongoDB 会自动创建集合。

> db.mycol2.insert({'name': 'Jack'})
WriteResult({ "nInserted" : 1 })
> show collections
mycol
mycol2
runoob
site
user

删除集合

MongoDB 中使用 drop() 方法来删除集合。
语法：

db.collection_name.drop()

返回值：
如果成功删除选定集合，则 drop() 方法返回 true，否则返回 false。

例：

> show collections
mycol
mycol2
runoob
site
user

> db.mycol2.drop()
true

> show collections
mycol
runoob
site
user

MongoDB 插入文档

文档的数据结构和JSON基本一样。
所有存储在集合中的数据都是BSON格式。
BSON是一种类json的一种二进制形式的存储格式,简称Binary JSON。

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

db.COLLECTION_NAME.insert(document)

例：

> db.user.insert({name: 'zhy', age: 24})
WriteResult({ "nInserted" : 1 })

以上实例中 user 是集合名，如果该集合不在该数据库中， MongoDB 会自动创建该集合并插入文档。
查看已插入文档：

> db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }

例：也可以将数据定义为一个变量，如下所示：

> document = ({name: 'Michael', age: 32, address: 'Washton'})
{ "name" : "Michael", "age" : 32, "address" : "Washton" }
> db.user.insert(document)
WriteResult({ "nInserted" : 1 })
> db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 18, "c
lass" : 8 }
{ "_id" : ObjectId("5bd8255896f23c1597143a45"), "name" : "Michael", "age" : 32,
"address" : "Washton" }

插入文档也可以使用 save(document) 命令。如果不指定 _id 字段 save() 方法类似于 insert() 方法。如果指定 _id 字段，则会更新该 _id 的数据。
例：save()

> db.user.save({name: 'Allen', age: 18, class: 8})
WriteResult({ "nInserted" : 1 })
> db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 18, "c
lass" : 8 }

MongoDB 更新文档

MongoDB 使用 update() 和 save() 方法来更新集合中的文档。

（1）update() 方法

update() 方法用于更新已存在的文档。

语法格式如下：

db.collection_name.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 :可选，抛出异常的级别。

例：

> db.user.update({'name': 'Michael'}, {$set: {'age': 100}})		#set age=100 where name='Micheael' 
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.user.find().pretty()
{
        "_id" : ObjectId("5bd8255896f23c1597143a45"),
        "name" : "Michael",
        "age" : 100,
        "address" : "Washton"
}

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

> db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 18,
lass" : 8 }
{ "_id" : ObjectId("5bd8255896f23c1597143a45"), "name" : "Allen", "age" : 100
address" : "Washton" }

> db.user.update({'name': 'Allen'}, {$set: {'age': 1}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 1,
ass" : 8 }
{ "_id" : ObjectId("5bd8255896f23c1597143a45"), "name" : "Allen", "age" : 100
address" : "Washton" }

> db.user.update({'name': 'Allen'}, {$set: {'age': 99}}, {multi: true})
WriteResult({ "nMatched" : 2, "nUpserted" : 0, "nModified" : 2 })
> db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 99,
lass" : 8 }
{ "_id" : ObjectId("5bd8255896f23c1597143a45"), "name" : "Allen", "age" : 99,
ddress" : "Washton" }
（2）save() 方法

save() 方法通过传入的文档来替换已有文档。

语法格式如下：

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

参数说明：

  • document : 文档数据。
  • writeConcern :可选，抛出异常的级别。

例：

> db.user.save({'_id': ObjectId("5bd8255896f23c1597143a45"), name: 'Tom', age
4, class: 8})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.user.find()
{ "_id" : ObjectId("5bd8255896f23c1597143a45"), "name" : "Tom", "age" : 24, "
ss" : 8 }

MongoDB 删除文档

MongoDB remove()函数是用来移除集合中的数据。

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

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

如果你的 MongoDB 是 2.6 版本以后的，语法格式如下：

db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)

参数说明：

  • query :（可选）删除的文档的条件。
  • justOne : （可选）如果设为 true 或 1，则只删除一个文档。默认为false或1。
  • writeConcern :（可选）抛出异常的级别。

例：

db.user.find()
{ "_id" : ObjectId("5bd823aa96f23c1597143a43"), "name" : "zhy", "age" : 24 }
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 99,
lass" : 8 }
{ "_id" : ObjectId("5bd8255896f23c1597143a45"), "name" : "Tom", "age" : 24, "
ss" : 8 }

db.user.remove({age: 24})
WriteResult({ "nRemoved" : 2 })
#删除了两条
> db.user.find()
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 99,
lass" : 8 }

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

> db.user.remove({aage: 20}, 1)
WriteResult({ "nRemoved" : 1 })
> db.user.find()
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 99, "c
lass" : 8 }
{ "_id" : ObjectId("5bd82cef96f23c1597143a47"), "name" : "Michael", "aage" : 20
}

或：

> db.user.find（）
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 99, "c
lass" : 8 }
{ "_id" : ObjectId("5bd82e4496f23c1597143a4a"), "name" : "Michael", "age" : 20 }
{ "_id" : ObjectId("5bd82d9396f23c1597143a48"), "name" : "Tom", "aage" : 20 }

> db.user.remove({age: 20}, {justOne: 1})
WriteResult({ "nRemoved" : 1 })
> db.user.find()
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" : 99, "c
lass" : 8 }
{ "_id" : ObjectId("5bd82e4496f23c1597143a4a"), "name" : "Michael", "age" : 20 }

如果想删除所有数据，可以使用以下方式（类似常规 SQL 的 truncate 命令）：

> db.user.find()
{ "_id" : ObjectId("5bd824a096f23c1597143a44"), "name" : "Allen", "age" :
lass" : 8 }
{ "_id" : ObjectId("5bd82e4496f23c1597143a4a"), "name" : "Michael", "age"

> db.user.remove({})
WriteResult({ "nRemoved" : 2 })
> db.user.find()

MongoDB 查询文档

MongoDB 查询文档使用 find() 方法。
find() 方法以非结构化的方式来显示所有文档。

语法：

db.collection_name.find(query, projection)

参数：

  • query ：可选，使用查询操作符指定查询条件。
  • projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。

如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：

db.collection_name.find().pretty()

pretty() 方法以格式化的方式来显示所有文档。

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

例：

> db.site.find()
{ "_id" : ObjectId("5bd800b9ff37ee5746a7a49e"), "site" : "www.baidu.com" }
{ "_id" : ObjectId("5bd800d6ff37ee5746a7a49f"), "site" : "www.google.com", "name
" : "Google" }
{ "_id" : ObjectId("5bd80106ff37ee5746a7a4a0"), "site" : "www.runoob.com", "name
" : "Runoob", "num" : 5 }

> db.site.find().pretty()
{ "_id" : ObjectId("5bd800b9ff37ee5746a7a49e"), "site" : "www.baidu.com" }
{
        "_id" : ObjectId("5bd800d6ff37ee5746a7a49f"),
        "site" : "www.google.com",
        "name" : "Google"
}
{
        "_id" : ObjectId("5bd80106ff37ee5746a7a4a0"),
        "site" : "www.runoob.com",
        "name" : "Runoob",
        "num" : 5
}

> db.site.findOne()
{ "_id" : ObjectId("5bd800b9ff37ee5746a7a49e"), "site" : "www.baidu.com" }
（1）MongoDB 与 RDBMS Where 语句比较

通过下表可以更好的理解 MongoDB 的条件语句查询：

操作格式范例RDBMS中的类似语句
等于{:}db.col.find({“by”:“菜鸟教程”}).pretty()where by = ‘菜鸟教程’
小于{:{$lt:}}db.col.find({“likes”:{$lt:50}}).pretty()where likes < 50
小于或等于{:{$lte:}}db.col.find({“likes”:{$lte:50}}).pretty()where likes <= 50
大于{:{$gt:}}db.col.find({“likes”:{$gt:50}}).pretty()where likes > 50
大于或等于{:{$gte:}}db.col.find({“likes”:{$gte:50}}).pretty()where likes >= 50
不等于{:{$ne:}}db.col.find({“likes”:{$ne:50}}).pretty()where likes != 50
（2）MongoDB AND 条件

MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。

语法格式如下：

db.col.find({key1:value1, key2:value2}).pretty()

例：

> db.user.find()
{ "_id" : ObjectId("5bd8327a96f23c1597143a4b"), "name" : "Tom", "age" : 24, "cla
ss" : 8 }
{ "_id" : ObjectId("5bd8328a96f23c1597143a4c"), "name" : "Jack", "age" : 20, "cl
ass" : 9 }
{ "_id" : ObjectId("5bd8329896f23c1597143a4d"), "name" : "Jane", "age" : 21, "cl
ass" : 7 }
{ "_id" : ObjectId("5bd8330296f23c1597143a4e"), "name" : "Tom", "age" : 23, "cla
ss" : 6 }

> db.user.find({name: 'Tom'}).pretty()
{
        "_id" : ObjectId("5bd8327a96f23c1597143a4b"),
        "name" : "Tom",
        "age" : 24,
        "class" : 8
}
{
        "_id" : ObjectId("5bd8330296f23c1597143a4e"),
        "name" : "Tom",
        "age" : 23,
        "class" : 6
}

> db.user.find({name: 'Tom', age: 24}).pretty()
{
        "_id" : ObjectId("5bd8327a96f23c1597143a4b"),
        "name" : "Tom",
        "age" : 24,
        "class" : 8
}

注：以上实例中类似于 WHERE 语句：WHERE name=‘Tom’ AND agle=24。

注意：MongoDB 同样提供逻辑运算符 ‘$and’，但一般按照上述方式进行查询。
例：相当与 ‘WHERE status=‘A’ AND qty <30’

> db.inventory.find({$and: [{status: 'A'}, {qty: {$lt: 30}}]}).pretty()
{
        "_id" : ObjectId("5bfca469e7ba3ba345acf4ee"),
        "item" : "journal",
        "qty" : 25,
        "size" : {
                "h" : 14,
                "w" : 21,
                "uom" : "cm"
        },
        "status" : "A"
}
（3）MongoDB OR 条件

MongoDB OR 条件语句使用了关键字 $or,语法格式如下：

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

例：

> db.user.find({$or: [{name: 'Tom'}, {name: 'Jack'}]}).pretty()
{
        "_id" : ObjectId("5bd8327a96f23c1597143a4b"),
        "name" : "Tom",
        "age" : 24,
        "class" : 8
}
{
        "_id" : ObjectId("5bd8328a96f23c1597143a4c"),
        "name" : "Jack",
        "age" : 20,
        "class" : 9
}
{
        "_id" : ObjectId("5bd8330296f23c1597143a4e"),
        "name" : "Tom",
        "age" : 23,
        "class" : 6
（4）AND 和 OR 联合使用

例：查询条件 where age > 20 and (name = ‘Jane’ or class = 6

> db.user.find()
{ "_id" : ObjectId("5bd8327a96f23c1597143a4b"), "name" : "Tom", "age" : 24, "cla
ss" : 8 }
{ "_id" : ObjectId("5bd8328a96f23c1597143a4c"), "name" : "Jack", "age" : 20, "cl
ass" : 9 }
{ "_id" : ObjectId("5bd8329896f23c1597143a4d"), "name" : "Jane", "age" : 21, "cl
ass" : 7 }
{ "_id" : ObjectId("5bd8330296f23c1597143a4e"), "name" : "Tom", "age" : 23, "cla
ss" : 6 }
> db.user.find({'age' : {$gt : 20}, $or : [{'name' : 'Jane'}, {'class' : 6}]})
{ "_id" : ObjectId("5bd8329896f23c1597143a4d"), "name" : "Jane", "age" : 21, "cl
ass" : 7 }
{ "_id" : ObjectId("5bd8330296f23c1597143a4e"), "name" : "Tom", "age" : 23, "cla
ss" : 6 }

MongoDB 条件操作符

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

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

假设集合 col 中含有如下数据：

> db.col.find().pretty()
{
        "_id" : ObjectId("5bda6670c5fb4c86775b1248"),
        "title" : "PHP class",
        "description" : "PHP is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "php"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
}
{
        "_id" : ObjectId("5bda66ddc5fb4c86775b124a"),
        "title" : "MongoDB class",
        "description" : "MongoDB is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb"
        ],
        "likes" : 100
}
（1）MongoDB (>) 大于操作符 - $gt

如果想获取 “col” 集合中 “likes” 大于 100 的数据，你可以使用以下命令：

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

类似于SQL语句：

Select * from col where likes > 100;

例：

> db.col.find({likes : {$gt : 100}}).pretty()
{
        "_id" : ObjectId("5bda6670c5fb4c86775b1248"),
        "title" : "PHP class",
        "description" : "PHP is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "php"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
}
（2）MongoDB（>=）大于等于操作符 - $gte

如果想获取"col"集合中 “likes” 大于等于 100 的数据，你可以使用以下命令：

db.col.find({likes : {$gte : 100}})

类似于SQL语句：

Select * from col where likes >=100;

输出结果：

> db.col.find({likes : {$gte : 150}}).pretty()
{
        "_id" : ObjectId("5bda6670c5fb4c86775b1248"),
        "title" : "PHP class",
        "description" : "PHP is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "php"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
}

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

如果想获取"col"集合中 “likes” 小于 150 的数据，你可以使用以下命令：

db.col.find({likes : {$lt : 150}})

类似于SQL语句：

Select * from col where likes < 150;

输出结果：

> db.col.find({likes : {$lt : 150}}).pretty()
{
        "_id" : ObjectId("5bda66ddc5fb4c86775b124a"),
        "title" : "MongoDB class",
        "description" : "MongoDB is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb"
        ],
        "likes" : 100

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

如果想获取"col"集合中 “likes” 小于等于 150 的数据，你可以使用以下命令：

db.col.find({likes : {$lte : 150}})

类似于SQL语句：

Select * from col where likes <= 150;

输出结果：

> db.col.find({likes : {$lte : 150}}).pretty()
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
}
{
        "_id" : ObjectId("5bda66ddc5fb4c86775b124a"),
        "title" : "MongoDB class",
        "description" : "MongoDB is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb"
        ],
        "likes" : 100
（5）MongoDB 使用 (<) 和 (>) 查询 - $lt 和 $gt

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

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

类似于SQL语句：

Select * from col where likes>100 AND  likes<200;

输出结果：

> db.col.find({likes : {$lt : 200, $gt : 100}}).pretty()
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
}
> db.col.find({likes : {$lte : 200, $gt : 100}}).pretty()
{
        "_id" : ObjectId("5bda6670c5fb4c86775b1248"),
        "title" : "PHP class",
        "description" : "PHP is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "php"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
（6）查询数组中的数据
1.匹配一个数组

使用查询文档 { : } 可以精确匹配一个字段的数组，包括值和顺序。
例：

> db.inventory.find({})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24001"), "item" : "journal", "qty" : 25,
"tags" : [ "blank", "red" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24002"), "item" : "notebook", "qty" : 50,
 "tags" : [ "red", "blank" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24003"), "item" : "paper", "qty" : 100, "
tags" : [ "red", "blank", "plain" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24004"), "item" : "planner", "qty" : 75,
"tags" : [ "blank", "red" ], "dim_cm" : [ 22, 85, 30 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24005"), "item" : "postcard", "qty" : 45,
 "tags" : [ "blue" ], "dim_cm" : [ 10, 15, 25 ] }
> db.inventory.find({tags: ['red', 'blank']}).pretty()
{
        "_id" : ObjectId("5c0dfc28462a1f736ef24002"),
        "item" : "notebook",
        "qty" : 50,
        "tags" : [
                "red",
                "blank"
        ],
        "dim_cm" : [
                14,
                21
        ]
}

如果想要查询数组中包含特定的值而不考虑顺序和其它的值，可以使用 “ $all ”操作符。
例：

> db.inventory.find({tags: {$all: ['red', 'blank']}})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24001"), "item" : "journal", "qty" : 25,
"tags" : [ "blank", "red" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24002"), "item" : "notebook", "qty" : 50,
 "tags" : [ "red", "blank" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24003"), "item" : "paper", "qty" : 100, "
tags" : [ "red", "blank", "plain" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24004"), "item" : "planner", "qty" : 75,
"tags" : [ "blank", "red" ], "dim_cm" : [ 22, 85, 30 ] }

查询字段的数组中含有某个特定值， 使用 { : }。
例：

> db.inventory.find({tags: 'red'})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24001"), "item" : "journal", "qty" : 25,
"tags" : [ "blank", "red" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24002"), "item" : "notebook", "qty" : 50,
 "tags" : [ "red", "blank" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24003"), "item" : "paper", "qty" : 100, "
tags" : [ "red", "blank", "plain" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24004"), "item" : "planner", "qty" : 75,
"tags" : [ "blank", "red" ], "dim_cm" : [ 22, 85, 30 ] }

在数组字段的值上指定条件，使用 { : { : , … } }。
例：查询字段 dim_cm 中至少存在一个值大于 25 的所有文档

> db.inventory.find({dim_cm: {$gt: 25}})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24004"), "item" : "planner", "qty" : 75,
"tags" : [ "blank", "red" ], "dim_cm" : [ 22, 85, 30 ] }

为数组元素指定多个条件：
例：查询字段 dim_cm 中的数组中存在大于15的元素，且存在小于20的元素，或存在一个元素满足二者。

> db.inventory.find({dim_cm: {$gt: 15, $lt: 20}})

{ "_id" : ObjectId("5c0dfc28462a1f736ef24001"), "item" : "journal", "qty" : 25,
"tags" : [ "blank", "red" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24002"), "item" : "notebook", "qty" : 50,
 "tags" : [ "red", "blank" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24003"), "item" : "paper", "qty" : 100, "
tags" : [ "red", "blank", "plain" ], "dim_cm" : [ 14, 21 ] }
{ "_id" : ObjectId("5c0dfc28462a1f736ef24005"), "item" : "postcard", "qty" : 45,
 "tags" : [ "blue" ], "dim_cm" : [ 10, 15, 25 ] }

查询数组字段中至少有一个元素同时满足所有指定的条件，使用“$elemMatch”操作符。
例：查询字段 dim_cm 中的数组中存在大于22且小于30的元素的所有文档

> db.inventory.find({dim_cm: {$elemMatch: {$gt: 22, $lt: 30}}})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24005"), "item" : "postcard", "qty" : 45,
 "tags" : [ "blue" ], "dim_cm" : [ 10, 15, 25 ] }

通过索引位置查询数组元素：使用“.”表示法可以为指定索引或位置的数组元素指定查询条件。索引从 0 开始。
例：查询数组中第二个元素大于25 的所有文档

> db.inventory.find({'dim_cm.1': {$gt: 25}})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24004"), "item" : "planner", "qty" : 75,
"tags" : [ "blank", "red" ], "dim_cm" : [ 22, 85, 30 ] }

注意：使用点表示法查询时，字段和嵌套字段必须放在引号内。

按数组长度查询数组：使用“ $size”操作符可以按数组长度进行查询。
例：查询“tags”标签含有3 个元素的所有文档

> db.inventory.find({tags: {$size: 3}})
{ "_id" : ObjectId("5c0dfc28462a1f736ef24003"), "item" : "paper", "qty" : 100, "
tags" : [ "red", "blank", "plain" ], "dim_cm" : [ 14, 21 ] }

MongoDB $type 操作符

$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。

MongoDB 中可以使用的类型如下表所示：

类型数字备注
Double1
String2
Object3
Array4
Binary data5
Undefined6已废弃。
Object id7
Boolean8
Date9
Null10
Regular Expression11
JavaScript13
Symbol14
JavaScript (with scope)15
32-bit integer16
Timestamp17
64-bit integer18
Min key255Query with -1.
Max key127

集合 col 的数据如下：

> db.col.find()
{ "_id" : ObjectId("5bda6670c5fb4c86775b1248"), "title" : "PHP class", "descript
ion" : "PHP is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com", "tag
s" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("5bda66a8c5fb4c86775b1249"), "title" : "Java class", "descrip
tion" : "Java is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com", "t
ags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5bda66ddc5fb4c86775b124a"), "title" : "MongoDB class", "desc
ription" : "MongoDB is xxxxx", "by" : "cn school", "url" : "http://www.runoob.co
m", "tags" : [ "mongodb" ], "likes" : 100 }
{ "_id" : ObjectId("5bda6c84c5fb4c86775b124b"), "title" : 1 }

如果想获取 “col” 集合中 title 为 String 的数据，可以使用以下命令：

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

或

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

输出结果为：

> db.col.find({title : {$type : 2}}).pretty()
{
        "_id" : ObjectId("5bda6670c5fb4c86775b1248"),
        "title" : "PHP class",
        "description" : "PHP is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "php"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150
}
{
        "_id" : ObjectId("5bda66ddc5fb4c86775b124a"),
        "title" : "MongoDB class",
        "description" : "MongoDB is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb"
        ],
        "likes" : 100

MongoDB Limit与Skip方法

（1）MongoDB Limit() 方法

如果你需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。

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

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

例：

> db.col.find().limit(2)
{ "_id" : ObjectId("5bda6670c5fb4c86775b1248"), "title" : "PHP class", "descript
ion" : "PHP is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com", "tag
s" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("5bda66a8c5fb4c86775b1249"), "title" : "Java class", "descrip
tion" : "Java is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com", "t
ags" : [ "java" ], "likes" : 150 }

> db.col.find({title : {$type : 2}}).limit(2).pretty()
{
        "_id" : ObjectId("5bda6670c5fb4c86775b1248"),
        "title" : "PHP class",
        "description" : "PHP is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "php"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5bda66a8c5fb4c86775b1249"),
        "title" : "Java class",
        "description" : "Java is xxxxx",
        "by" : "cn school",
        "url" : "http://www.runoob.com",
        "tags" : [
                "java"
        ],
        "likes" : 150

注：如果没有指定limit()方法中的参数则显示集合中的所有数据。

（2）MongoDB skip() 方法

除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。

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

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

例：

> db.col.find()
{ "_id" : ObjectId("5bda6670c5fb4c86775b1248"), "title" : "PHP class", "d
ion" : "PHP is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com
s" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("5bda66a8c5fb4c86775b1249"), "title" : "Java class", "
tion" : "Java is xxxxx", "by" : "cn school", "url" : "http://www.runoob.c
ags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5bda66ddc5fb4c86775b124a"), "title" : "MongoDB class"
ription" : "MongoDB is xxxxx", "by" : "cn school", "url" : "http://www.ru
m", "tags" : [ "mongodb" ], "likes" : 100 }
{ "_id" : ObjectId("5bda6c84c5fb4c86775b124b"), "title" : 1 }

> db.col.find().skip(1)
{ "_id" : ObjectId("5bda66a8c5fb4c86775b1249"), "title" : "Java class", "
tion" : "Java is xxxxx", "by" : "cn school", "url" : "http://www.runoob.c
ags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5bda66ddc5fb4c86775b124a"), "title" : "MongoDB class"
ription" : "MongoDB is xxxxx", "by" : "cn school", "url" : "http://www.ru
m", "tags" : [ "mongodb" ], "likes" : 100 }
{ "_id" : ObjectId("5bda6c84c5fb4c86775b124b"), "title" : 1 }

> db.col.find().skip(2)
{ "_id" : ObjectId("5bda66ddc5fb4c86775b124a"), "title" : "MongoDB class"
ription" : "MongoDB is xxxxx", "by" : "cn school", "url" : "http://www.ru
m", "tags" : [ "mongodb" ], "likes" : 100 }
{ "_id" : ObjectId("5bda6c84c5fb4c86775b124b"), "title" : 1 }

注：注:skip()方法默认参数为 0 。

MongoDB 排序

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

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

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

例：

#升序
> db.col.find().sort({likes : -1})
{ "_id" : ObjectId("5bda6670c5fb4c86775b1248"), "title" : "PHP class", "d
ion" : "PHP is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com
s" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("5bda66a8c5fb4c86775b1249"), "title" : "Java class", "
tion" : "Java is xxxxx", "by" : "cn school", "url" : "http://www.runoob.c
ags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5bda66ddc5fb4c86775b124a"), "title" : "MongoDB class"
ription" : "MongoDB is xxxxx", "by" : "cn school", "url" : "http://www.ru
m", "tags" : [ "mongodb" ], "likes" : 100 }
{ "_id" : ObjectId("5bda6c84c5fb4c86775b124b"), "title" : 1 }
#降序
> db.col.find().sort({likes : 1})
{ "_id" : ObjectId("5bda6c84c5fb4c86775b124b"), "title" : 1 }
{ "_id" : ObjectId("5bda66ddc5fb4c86775b124a"), "title" : "MongoDB class"
ription" : "MongoDB is xxxxx", "by" : "cn school", "url" : "http://www.ru
m", "tags" : [ "mongodb" ], "likes" : 100 }
{ "_id" : ObjectId("5bda66a8c5fb4c86775b1249"), "title" : "Java class", "
tion" : "Java is xxxxx", "by" : "cn school", "url" : "http://www.runoob.c
ags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5bda6670c5fb4c86775b1248"), "title" : "PHP class", "d
ion" : "PHP is xxxxx", "by" : "cn school", "url" : "http://www.runoob.com
s" : [ "php" ], "likes" : 200 }

MongoDB 索引

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

（1）创建索引 ensureIndex()

语法：

db.COLLECTION_NAME.ensureIndex(keys[,options])
  • keys，要建立索引的参数列表。如：{KEY:1}，其中key表示字段名，1表示升序排序，也可使用使用数字-1降序。
  • options，可选参数，表示建立索引的设置。可选值如下：

background：Boolean，在后台建立索引，以便建立索引时不阻止其他数据库活动。默认值 false。
unique：Boolean，创建唯一索引。默认值 false。
name：String，指定索引的名称。如果未指定，MongoDB会生成一个索引字段的名称和排序顺序串联。
dropDups：Boolean，创建唯一索引时，如果出现重复删除后续出现的相同索引，只保留第一个。
sparse：Boolean，对文档中不存在的字段数据不启用索引。默认值是 false。
v：index version，索引的版本号。
weights：document，索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。
例：

> db.customer.ensureIndex({'name': 1}, {unique: true})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
（2）查看索引 getIndexes()

语法：

db.connection_name.getIndexes()

例：

> db.customer.getIndexes()
[
        {
                "v" : 2,		#索引版本
                "key" : {
                        "_id" : 1		#索引对于的键
                },
                "name" : "_id_",		#索引名称
                "ns" : "test.customer"	#索引所在的数据库和集合
        }，
         {
		         "v" : 2,
		         "unique" : true,
		         "key" : {
		                 "name" : 1
		         },
		         "name" : "name_1",
		         "ns" : "test.customer"
		 }
]
（3）重建索引 reIndex()
（1）createIndex() 方法

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

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

db.collection.createIndex(keys, options)

语法中 Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。

例：

> db.col.createIndex({title : 1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

createIndex() 接收可选参数，可选参数列表如下：

参数类型描述
backgroundBoolean建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加 “background” 可选参数。 “background” 默认值为false。
uniqueBoolean建立的索引是否唯一。指定为true创建唯一索引。默认值为false.
namestring索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。
dropDupsBoolean3.0+版本已废弃。在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false.
sparseBoolean对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false.
expireAfterSecondsinteger指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
vindex version索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。
weightsdocument索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。
default_languagestring对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语
language_overridestring对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language.

实例
在后台创建索引：

db.values.createIndex({open: 1, close: 1}, {background: true})

通过在创建索引时加 background:true 的选项，让创建工作在后台执行。

删除索引 dropIndex()

语法：

db.connection_name.dropIndex("indexName")

例：

> db.customer.dropIndex('name_1_country_1')
{ "nIndexesWas" : 4, "ok" : 1 }
删除所有索引 dropIndexes()

语法：

db.COLLECTION_NAME.dropIndexes()

MongoDB 聚合

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

（1）aggregate() 方法

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

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

db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

集合 mycol 的数据如下：

> db.mycol.find().pretty()
{
        "_id" : ObjectId("5bda9daf0516d0965a067e91"),
        "title" : "MongoDB",
        "description" : "MongoDB is xxxxx",
        "by_user" : "runoob.com",
        "url" : "www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSql"
        ],
        "likes" : 100
}
{
        "_id" : ObjectId("5bda9de80516d0965a067e92"),
        "title" : "NoSql",
        "description" : "NoSql is xxxxx",
        "by_user" : "runoob.com",
        "url" : "www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSql"
        ],
        "likes" : 10
}
{
        "_id" : ObjectId("5bda9e350516d0965a067e93"),
        "title" : "Neo4j",
        "description" : "Neo4j is xxxxx",
        "by_user" : "Neo4J",
        "url" : "www.neo4j.com",
        "tags" : [
                "neo4j",
                "database",
                "NoSql"
        ],
        "likes" : 750

现在通过以上集合计算每个作者所写的文章数，使用aggregate()计算结果如下：

> db.mycol.aggregate([{$group : {_id : '$by_user', num_likes : {$sum : 1}}}])
{ "_id" : "Neo4J", "num_likes" : 1 }
{ "_id" : "runoob.com", "num_likes" : 2 }

以上实例类似sql语句：

select by_user, count(*) from mycol group by by_user

在上面的例子中，我们通过字段 by_user 对数据进行分组，并计算 by_user 字段相同值的总和。
下表展示了一些聚合的表达式:

表达式描述实例
$sum计算总和。db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { s u m : &quot; sum : &quot; sum:"likes"}}}])
$avg计算平均值db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { a v g : &quot; avg : &quot; avg:"likes"}}}])
$min获取集合中所有文档对应值得最小值。db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { m i n : &quot; min : &quot; min:"likes"}}}])
$max获取集合中所有文档对应值得最大值。db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { m a x : &quot; max : &quot; max:"likes"}}}])
$push在结果文档中插入值到一个数组中。db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", url : { p u s h : &quot; push: &quot; push:"url"}}}])
$addToSet在结果文档中插入值到一个数组中，但不创建副本。db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", url : { a d d T o S e t : &quot; addToSet : &quot; addToSet:"url"}}}])
$first根据资源文档的排序获取第一个文档数据。db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", first_url : { f i r s t : &quot; first : &quot; first:"url"}}}])
$last根据资源文档的排序获取最后一个文档数据db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", last_url : { l a s t : &quot; last : &quot; last:"url"}}}])
（2）管道的概念

管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。
MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

这里我们介绍一下聚合框架中常用的几个操作：

  • $project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
  • m a t c h ： 用 于 过 滤 数 据 ， 只 输 出 符 合 条 件 的 文 档 。 match：用于过滤数据，只输出符合条件的文档。 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
    }});

例：

> db.mycol.aggregate({$project : {title : 1, by_user : 1}})
{ "_id" : ObjectId("5bda9daf0516d0965a067e91"), "title" : "MongoDB", "by_user" :
 "runoob.com" }
{ "_id" : ObjectId("5bda9de80516d0965a067e92"), "title" : "NoSql", "by_user" : "
runoob.com" }
{ "_id" : ObjectId("5bda9e350516d0965a067e93"), "title" : "Neo4j", "by_user" : "
Neo4J" }

> db.mycol.aggregate({$project : {_id : 0, title : 1, by_user : 1}})
{ "title" : "MongoDB", "by_user" : "runoob.com" }
{ "title" : "NoSql", "by_user" : "runoob.com" }
{ "title" : "Neo4j", "by_user" : "Neo4J" }

2.$match实例

db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );

m a t c h 用 于 获 取 分 数 大 于 70 小 于 或 等 于 90 记 录 ， 然 后 将 符 合 条 件 的 记 录 送 到 下 一 阶 段 match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段 match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段group管道操作符进行处理。
例：

> db.mycol.aggregate([{$match : {likes : {$gt : 10, $lte : 750}}}]);
{ "_id" : ObjectId("5bda9daf0516d0965a067e91"), "title" : "MongoDB", "descriptio
n" : "MongoDB is xxxxx", "by_user" : "runoob.com", "url" : "www.runoob.com", "ta
gs" : [ "mongodb", "database", "NoSql" ], "likes" : 100 }
{ "_id" : ObjectId("5bda9e350516d0965a067e93"), "title" : "Neo4j", "description"
 : "Neo4j is xxxxx", "by_user" : "Neo4J", "url" : "www.neo4j.com", "tags" : [ "n
eo4j", "database", "NoSql" ], "likes" : 750 }

3.$skip实例

db.article.aggregate(
    { $skip : 5 });

经过$skip管道操作符处理后，前五个文档被"过滤"掉。

ongoDB 复制（副本集）

MongoDB复制是将数据同步在多个服务器的过程。
复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性， 并可以保证数据的安全性。
复制还允许您从硬件故障和服务中断中恢复数据。

（1）什么是复制?
  • 保障数据的安全性
  • 数据高可用性 (24*7)
  • 灾难恢复
  • 无需停机维护（如备份，重建索引，压缩）
  • 分布式读取数据
（2）MongoDB复制原理

mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。
mongodb各个节点常见的搭配方式为：一主一从、一主多从。
主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。

MongoDB复制结构图如下所示：
在这里插入图片描述
以上结构图中，客户端从主节点读取数据，在客户端写入数据到主节点时， 主节点与从节点进行数据交互保障数据的一致性。

（3）副本集特征
  • N 个节点的集群
  • 任何节点可作为主节点
  • 所有写入操作都在主节点上
  • 自动故障转移
  • 自动恢复
（4）MongoDB副本集设置

我们使用同一个MongoDB来做MongoDB主从的实验， 操作步骤如下：
1、关闭正在运行的MongoDB服务器。

现在我们通过指定 --replSet 选项来启动mongoDB。–replSet 基本语法格式如下：

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

实例：

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0

以上实例会启动一个名为rs0的MongoDB实例，其端口号为27017。
启动后打开命令提示框并连接上mongoDB服务。
在Mongo客户端使用命令rs.initiate()来启动一个新的副本集。
我们可以使用rs.conf()来查看副本集的配置
查看副本集状态使用 rs.status() 命令

（5）副本集添加成员

添加副本集的成员，我们需要使用多台服务器来启动mongo服务。进入Mongo客户端，并使用rs.add()方法来添加副本集的成员。

语法
rs.add() 命令基本语法格式如下：

rs.add(HOST_NAME:PORT)

实例：
假设你已经启动了一个名为mongod1.net，端口号为27017的Mongo服务。 在客户端命令窗口使用rs.add() 命令将其添加到副本集中，命令如下所示：

rs.add("mongod1.net:27017")

MongoDB中你只能通过主节点将Mongo服务添加到副本集中， 判断当前运行的Mongo服务是否为主节点可以使用命令db.isMaster() 。
MongoDB的副本集与我们常见的主从有所不同，主从在主机宕机后所有服务将停止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的情况。

MongoDB 备份(mongodump)与恢复(mongorestore)

（1）MongoDB数据备份

在Mongodb中我们使用mongodump命令来备份MongoDB数据。该命令可以导出所有数据到指定目录中。
mongodump命令可以通过参数指定导出的数据量级转存的服务器。

语法
mongodump命令脚本语法如下：

>mongodump --host dbhost --d dbname -o dbdirectory	#命令提示符下
  • dbhost：
    MongDB所在服务器地址，例如：127.0.0.1，当然也可以指定端口号：127.0.0.1:27017
  • dbname：
    需要备份的数据库实例，例如：test
  • dbdirectory：
    备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据。

例：

C:\Users\Administrator>mongodump --host 127.0.0.1:27017 --db test -o c:\data\dum
p_db
2018-11-01T16:40:11.162+0800    writing test.col to
2018-11-01T16:40:11.178+0800    writing test.user to
2018-11-01T16:40:11.179+0800    writing test.mycol to
2018-11-01T16:40:11.181+0800    writing test.site to
2018-11-01T16:40:11.235+0800    done dumping test.user (4 documents)
2018-11-01T16:40:11.235+0800    writing test.runoob to
2018-11-01T16:40:11.236+0800    done dumping test.mycol (3 documents)
2018-11-01T16:40:11.244+0800    done dumping test.site (3 documents)
2018-11-01T16:40:11.245+0800    done dumping test.col (4 documents)
2018-11-01T16:40:11.259+0800    done dumping test.runoob (1 document)
C:\Users\Administrator>

mongodump 命令可选参数列表如下所示：

语法描述实例
mongodump --host HOST_NAME --port PORT_NUMBER该命令将备份所有MongoDB数据mongodump --host runoob.com --port 27017
mongodump --dbpath DB_PATH --out BACKUP_DIRECTORYmongodump --dbpath /data/db/ --out /data/backup/
mongodump --collection COLLECTION --db DB_NAME该命令将备份指定数据库的集合。mongodump --collection mycol --db test
（2）MongoDB数据恢复

mongodb使用 mongorestore 命令来恢复备份的数据。
语法
mongorestore命令脚本语法如下：

mongorestore --host <hostname><:port> --db dbname --dir/--path <path>
  • <:port>：
    MongoDB所在服务器地址，默认为： localhost:27017
  • dbname ：
    需要恢复的数据库实例，例如：test，当然这个名称也可以和备份时候的不一样，比如test2
  • –drop：
    恢复的时候，先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！
  • <path>：
    mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。

你不能同时指定 <path> 和 --dir 选项，–dir也可以设置备份目录。

–dir：
指定备份的目录

注意：不能同时指定 和 --dir 选项。

例：

C:\Users\Administrator>mongorestore --db test_res --dir c:\data\dump_db\test
weixin_38853600
关注
专栏目录
Linux系统本地部署MongoDB数据库并实现远程访问方法指南
weixin_44976692的博客
06-06 3万+
本文主要介绍如何在Linux Ubuntu系统使用Docker快速部署MongoDB，并结合cpolar内网穿透工具实现公网远程访问本地数据库。MongoDB服务端可以运行在Linux、Windows、MacOS平台，可以存储比较复杂的数据类型，支持的查询语言非常强大，几乎可以实现类似关系数据库单表查询的绝大部分功能，还可以对数据建立索引。直接实用包管理器安装MongoDB比较复杂，使用Docker安装部署MongoDB则相对简单快速，下面就和大家分享一下具体操作流程。
mongodb根据表名查询_mongodb查询数据库有哪些表?
weixin_36358383的博客
12-24 377
MYYAdb.foo.find(...).count()db.foo.find(...).limit(n) 根据条件查找数据并返回指定记录数db.foo.find(...).skip(n)db.foo.find(...).sort(...) 查找排序db.foo.findOne([query]) 根据条件查询只查询一条数据db.foo.getDB() get DB object associate...
mongodb 基本概念
面朝大海，春暖花开
02-20 1082
mongodb 基本概念 基于 mongo:4.4.2 database database 数据库 table collection 数据库表/集合 row document 数据记录行/文档 column field 数据字段/域 index index 索引 table joins 表连接,MongoDB不支持 primary key primary key 主键,MongoDB自动将_id字段设置为主键 MongoDB 数据类型 数据类型 描述
Mongodb的Min key和Max key是能查找最大最小值的新功能吗？
梁小Wai的技术博客
10-20 1598
今天，在一个偶然的机会，在Mongodb的文档中看到$type（https://docs.mongodb.com/manual/reference/operator/query/type/），试了一下其中的功能，觉得不错，在列表最后 Type Number Alias Notes Min key -1 “minKey” Max key 127 “maxKey” 在Robo 3T中对一个collection进行查找 db.getCollection('c1').find({"id"
mongodb基本指令操作
天马行空的专栏
02-16 1023
MongoDB链接： 使用命令：  mongo 创建数据库 (创建数据库名称为：db_mxd)： 使用命令： use db_mxd [说明]use指令，如果数据库不存在，则创建数据库，如果存在，则切换到该数据库; 删除数据库： 使用命令：首先使用use切换到要删除的数据库，然后再使用 db.dropDatabase() 插入文档： 使用指令：  db.COLLECTI
MongoDB分片（sharding）/分区（partitioning）介绍
杨春建的博客
09-19 2万+
分片是指将数据拆分，将其分散存放在不同的机器上的过程。有时也用分区（partitioning）来表示这个概念。   几乎所有数据库软件都能进行手动分片（manual sharding）。应用需要维护与若干不同数据库服务器的连接，每个连接还是完全独立的。应用程序管理不同服务器上不同数据的存储，还管理在合适的数据库上查询数据的工作。   Mongodb支持自动分片（autosharding），可以
mongodb数据库
06-20
MongoDB 是一种流行的开源文档数据库，它属于NoSQL数据库家族，尤其适合处理非结构化或半结构化的数据。与传统的关系型数据库不同，MongoDB不采用预定义的表结构，而是以文档（Document）的形式存储数据，这些文档是...
老生常谈MongoDB数据库基础操作
12-16
MongoDB是一个流行的非关系型数据库系统，以其灵活性和高性能在现代Web应用中占据了重要的位置。作为NoSQL数据库的一种，MongoDB并不遵循传统的关系型数据库模式，而是采用了基于文档的数据模型，支持BSON（Binary ...
MySQL与MongoDB数据库架构介绍.pptx
10-14
MySQL 与 MongoDB 数据库架构介绍 MySQL 数据库架构介绍 MySQL 是由 Oracle 公司开发、发布和支持的受欢迎的开源关系数据库管理系统（RDBMS）。MySQL 将数据存储在表中，并使用结构化查询语句（SQL）来进行数据库...
MongoDB数据库.pdf
07-11
MongoDB数据库.pdf学习资料复习资料教学资源 本文将对MongoDB数据库进行详细的介绍，主要包括MongoDB与SQL的概念对比、数据库概念的介绍、 MongoDB数据库的特点、数据库的命名规则等内容。 一、MongoDB与SQL的概念...
Mongodb数据库实验2--对数据库表的增删改查及索引
m0_56315670的博客
10-12 909
mongodb的实验
mongoDB数据库----简介
我睡觉的时候不困
07-27 1665
目录 目录 一、NoSQL 1、关系型数据库遵循ACID规则 2、分布式系统 3、分布式计算的优点 4、分布式计算的缺点 5、什么是NoSQL？ 6、NoSQL 简史 7、NoSQL的优点/缺点 8、NoSQL 数据库分类 二、MongoDB概念解析 1、数据库 2、文档 3、集合 4、元数据 5、MongoDB数据类型 三、MongoDB简介 1、什么是mongoDB？ 2、主要特点 3、MongoDB的下载 4、MongoDB工具 一、NoSQL NoSQL
mongoDB数据库设置用户名及密码
热门推荐
我的人生，我做主
08-23 3万+
MongoDB数据库在默认是没有用户名及密码，不用安全验证的，只要连接上服务就可以进行CRUD操作。 第一部：开启安全性验证 如果需要给MongoDB数据库使用安全验证，则需要用--auth开启安全性检查，则只有数据库认证的用户才能执行读写操作，开户安全性检查，有两种方式： 第一种：重新创建window service服务器，在创建服务时打开安全性验证。 1. 首先使用
Mongodb入门系列（4）——Mongodb体系结构与客户端基本操作及注意细节
weixin_34015336的博客
03-08 103
2019独角兽企业重金招聘Python工程师标准>>> ...
MongoDB修改数据库名，collection名
weixin_30247307的博客
11-13 2649
利用dropDatabase,copyDatabase修改Database名称 db.copyDatabase('old_name', 'new_name'); use old_name db.dropDatabase(); 利用renameCollection修改collection名称 db.adminCommand({renameCollection:...
MongoDB学习札记
毅个混蛋的专栏
10-04 1万+
1，快速入门 安装MongoDB 我选择的是windows平台的mongodb安装方式，也很简单，只需要 下载 对应操作系统版本的Mongodb即可。（建议下载ZIP的安装包） 怎么验证我们的mongodb已经可以使用了？ 1.通过命令行切换到mongodb的安装目录， 我的目录为 G:\JavaData\mongoDB\bin 2.命令行执行 mongod —d
mysql2016是什么_MySQL数据库的简介---2016/11/13（需要补充）
weixin_27966471的博客
02-04 219
随着PHP的结束，紧接而来的是MySQL的学习。以下开始记录MySQL的学习内容和心得：一、关于MySQL的简介数据库的概念(一)什么是数据库?数据库就是存储数据的“仓库”，电脑中的磁盘、磁盘中文件夹、文件夹中的doc文件都属于数据库。但是仅仅有数据库是不够的，我们还需要管理数据的工具，我都统称为数据库管理系统。(二)数据库管理工具　　　　　　　通常我们用到的数据库管理软件有：MySQL、Orac...
MongoDb进阶实践之三 Mongodb基本命令详解
weixin_33800593的博客
03-29 177
一、引言              从今天开始，我要正式开始介绍MongoDB的使用方法了。在此之前，我用了两篇文章分别介绍了如何在Linux系统和Windows系统上安装和配置MongoDB系统。如果你已经知道了具体的安装方法，感觉还是很简单的，但是如果你从来没有操作过的，心里还是有些心虚的，所以这个系列就从最基本的安装开始。既然是一个系列的文章，肯定会有安装和配置的文章，也会有数据类型，基本操...
数据库语言与事务管理
m0_45442261的博客
10-14 1万+
数据库查询 1.use 【库名】/describle【表名】 /desc【表名】 desc/describle [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I81lq3di-1602650095111)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20201014093506698.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QYGcBzjN-16
mongodb 数据库
最新发布
01-12
MongoDB是一个开源的、面向文档的NoSQL数据库管理系统。它使用JSON样式的文档来存储数据，而不是传统的行和列的关系型数据库。MongoDB具有高性能、可扩展性和灵活性的特点，适用于大规模数据存储和处理。 以下是MongoDB的一些常用工具和操作示例： 1. mongoimport：用于将数据从文件导入到MongoDB数据库中。 ```shell mongoimport --db <database_name> --collection <collection_name> --file <file_path> ``` 2. bsondump：将BSON文件转换为JSON格式。 ```shell bsondump <bson_file> > <json_file> ``` 3. mongodump：备份MongoDB数据库。 ```shell mongodump --db <database_name> --out <output_directory> ``` 4. mongoexport：将MongoDB中的数据导出为JSON、CSV或TSV格式。 ```shell mongoexport --db <database_name> --collection <collection_name> --out <output_file> ``` 5. mongofiles：用于在MongoDB GridFS中存储和检索文件。 ```shell mongofiles put <file_path> # 存储文件 mongofiles get <filename> # 检索文件 ``` 6. mongorestore：从备份文件中恢复MongoDB数据库。 ```shell mongorestore --db <database_name> <backup_directory> ``` 7. mongostat：监视MongoDB服务器的状态。 ```shell mongostat ``` 8. mongotop：监视MongoDB实例中的读写操作。 ```shell mongotop ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值