MongoDB总结

最新推荐文章于 2024-01-14 16:43:01 发布

czxh

最新推荐文章于 2024-01-14 16:43:01 发布

阅读量1.1k

点赞数 1

分类专栏： Nosql 文章标签： mongodb 数据库

本文链接：https://blog.csdn.net/wjl4107336123/article/details/68142606

版权

Nosql 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文档和集合

文档

文档是Mongodb中的最基本数据单元，类似于关系数据库中的行。
在mongodb中，文档的键通常都是字符串。Mongodb对文档的键是区分大小写的，对键值是区分数据类型的
例如：
{username:”admin”}和{userName:”admin”}  {age:20}和{age:”20”}是不同的文档
特别注意：{username:”admin”,username:”非法键”}，同一文档中 键值是不能重复的。

集合

集合是文档组成的，在关系型数据库中就是表。
在mongodb中，对集合中存储的文档是非常开放的，一个集合中可以存放各式各样的文档。
例如：
{username:”admin”} , {role:”admin”} (强烈反对)
{username:”admin”},{username:”pp”} (强烈推荐)

子集合

   组织子集合的一种惯例是使用“.”字符分开的按命名空间划分的子集合。在MongoDB中使用子集合来组织数据是很好的方法。
例如:
   用户与用户详细信息包含两个集合，分别是user.user和user.userinfo。这样做的目的只是为了使组织结构更好些，也就是说 user这个集合（这里根本就不需要存在）及其子集合没有任何关系。把数据库的名字放到集合名前面，得到就是集合的完全限定名，称为命名空间。

数据库

admin

   从权限的角度来看，这是“root”数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。

local

这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合

config

当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

命名规则

1、不能是“”空字符串

2、不可以含有空格，在mongodb中 空格代表结束字符。

3、文档的键不可以有“.”和“$”符号，集合名中不可以包含“$”

4、集合不能以 “system.”开头，mongodb中system是系统保留前缀

5、集合名长度不得超过121字节，在实际使用当中应该小于100字节；数据库名最多不超过64个字节 

(mongodb最终是以文件方式存储的，操作系统中的非法文件名，在mongodb中就是非法的，这样便于理解与记忆)

数据类型

    MongoDB的文件存储格式为BSON,同JSON一样支持往其它文档对象和数组中再插入文档对象和数组，同时扩展了JSON的数据类型.与数据库打交 道的那些应用。

MongoDB的支持的数据类型：

类型	描述	举例
null	null用于表示空值或者不存在的字段	{“x”:null}
浮点数	都是这种类型	{“pi”:3.1415926} {“pi”:3}
布尔	布尔类型有两个值’true’和’false’	{“x”:true}
符号	符号类型转换成了字符串。
对象id	对象id是文档的12字节的唯一 ID	{“X” :ObjectId() }
日期:	日期类型存储的是从标准纪元开始的毫秒数。	{“x” ：new Date()}
正则表达式	文档中可以包含正则表达式，采用JavaScript的正则表达式语法:	{“x” ： /test/i}
代码	文档中还可以包含JavaScript代码	{“x”：function() {/* …… */}}
二进制数据	二进制数据可以由任意字节的串组成。
未定义	文档中也可以使用未定义类型	{“x”:undefined}
数组	值的集合或者列表可以表示成数组	{“x”：[“a”, “b”, “c”]}
内嵌文档	文档可以包含别的文档，也可以作为值嵌入到父文档中，数据可以组织得更自然些	{“x” ：{“sex”：“woman”}}

CRUD

insert

db.mydb.user.insert({name:”test1”}) 
这个操作是向mydb.user集合中增加“_id”建，并添加到MongoDB中。检验是否含有“_id”键和文档不超过16M，除之，不做任何数据验证。

save

db.mydb.user.save({name:”test2”})
这个操作也是向mydb.user集合中增加“_id”建，并添加到MongoDB中。save函数实际就是根据参数条件,调用了insert或update函数.如果想插入的数据对象存在,insert函数会报错,而save函数是改变原来的对象;如果想插入的对象不存在,那么它们执行相同的插入操作.这里可以用几个字来概括它们两的区别,即所谓"有则改之,无则加之".

update

1. db.mydb.user.update({name:”test1”} , {name:”test1”,age:20}) 
2. 使用findOne()函数： user=db.mydb.user.findOne({name:”test1”})
 user.name=“test1” 
 user.age++
 db.mydb.user.update({_id:user._id},user)

修改器

$inc修改器

update({键:值},{$inc:{键:值}})
db.mydb.user.update({users:"dsm"},{$inc:{age:1}})
age自增1(age必须为数字类型)

$set修改器

update({键:值},{$set:{键:值}})
set为该文档设置一条属性，如果没有则创建一条属性
db.mydb.user.update({users:"dsm"},{$set:{hobby:"皮"}})
也可以修改内嵌文档
db.mydb.user.update({users:"dsm"},{$set:{"skills.name":["正方形打野","边缘OB","假设性原则"]}})
db.mydb.user.update({users:"dsm"},{$set:{"skills.发动结果":["队友崩盘","永不团灭","马半仙模式"]}})
修改内嵌文档不同于修改属性，不会覆盖。

$unset修改器

    update({键:值},{$unset:{键:-1/0/1}})
    -1/0/1都表示删除
删除该文档的一条属性
db.mydb.user.update({users:"dsm"},{$unset:{"skills.基地爆炸":-1}})

$push数组修改器

   update({…},{$push:{键：值}})  
   $push修改器是会往键已有的数组中追加值，如果数组不存在，则创建新的数组并更新键值。
   db.mydb.user.update({users:"dsm"},{$push:{hobby:"养大象"}})

$push + $ne数组修改器

update({键：{$ne:值}},{$push:{键：值}})
$push+$ne 组合键使用于如果追加值不在数组中则追加进去。
db.mydb.user.update({users:"dsm",hobby:{$ne:"折磨王"}},{$push:{hobby:"折磨王"}})

addToSet数组修改器

update({…},{$addToSet:{键：值}})
相当于$push+$ne
db.mydb.user.update({users:"dsm"},{$addToSet:{hobby:"折磨王"}})
db.mydb.user.update({users:"dsm"},{$addToSet:{hobby:"拳皇"}})

$addToSet + $each数组修改器

update({…},{$addToSet:{键：{$each:[…]}}})
当我们一次要追加多个值得时候，而且需要判断数组中是否存在，这时$push+$ne 组合就不能实现了，需求用到$addToSet+$each组合键。
db.mydb.user.update({users:"dsm"},{$addToSet:{hobby:{$each:["马氏跑动杀","葵花三式","折磨王"]}}})
只加入了马氏跑动杀和葵花三式，折磨王没有加入

$pop数组修改器

{$pop:{键:1}}  - 从数组尾部删除一个元素
{$pop:{键:-1}} - 从数组头部删除一个元素
“$pop”修改器用于删除数组里面值，如果把数组看成一个队列或者栈的话，可以从数组任何一端删除元素。
db.mydb.user.update({users:"dsm"},{$pop:{hobby:1}})

$pull数组修改器

{$pull:{键:值}}
“$pull”修改器也是用于删除数组里面值，它可以删除数组中任意位置的值，并且删除所有匹配到的值
db.mydb.user.update({users:"dsm"},{$pull:{hobby:"折磨王"}})

$定位修改器

“$”定位修改器也是用于数组里面值的数据类型为内嵌文档，可以使用$实行定位修改。
db.mydb.user.update({users:"dsm"},{$set:{"skills.name":["萧峰","胡里亚","马化腾"]}})
db.mydb.user.update({"skills.test" :11},{$set:{"skills.name":["跑之小跳"]}})

upsert

update({匹配文档},{更新文档},true)
Upsert 可以理解为 update与insert的缩写 ，它是update函数的第三个参数，其实际含义就是更新或插入。
Update参数upsert默认值是fasle,它是一种特殊的更新。根据这个参数值，update函数判断对匹配不到的文档，将更新文档基于匹配文档之上以一个新的文档是否增加到集合中。
db.mydb.user.update({users:"pdd"},{users:"pddd"},true)

mutli

update({…},{…}, false, true)
它是update函数的第四个参数，其实际含义就是是否实现多更新操作。
update函数的mutli默认值是false, 代表只对第一个匹配到的文档进行更新操作；需要更新多个符合匹配条件的文档，则要设置mutli值为true.
例如：所有名称为test3的年龄加2
db.mydb.user.update({name:”test3”},{$inc:{age:2}, false, true})
db.runCommand({getLastError:1})可以查看受影响的文档数

返回更新文档

用法：db.集合名.findAndModify({
    query:{匹配文档},
    update:{更新文档}
    [,remove:布尔值，sort:{排序文档},new:布尔值]
    })
     query: 匹配文档，也就是查询条件
     sort:  排序匹配文档的条件
     update: 修改器文档，执行文档更新操作
     remove: true/false,是否对匹配到的文档进行删除
     new: true/false, 表示返回的是更新前还是更新后的文档，默认值是false
update 与remove 必须而且只能存在一个。
它一次只能操作一个文档，不能进行upsert操作,只能更新已存在的文档。
findAndModify 执行效率有点低，话虽这么说，不代表避免使用，mongo每一个函数的存在，都有其实际存在的价值。它的执行效率相当于 一次查询、更新外加getLastError 顺序执行的时间。
db.mydb.user.findAndModify({query:{users:"dsm"},update:{$pop:{hobby:1}}})

安全操作

    mongoDB 开发者采用不安全模式作为默认选择，这是由于他们与关系型数据库打交道的经验所致的，很多构建在关系型数据库的应用，都不关心返回的代码，也不会处理这个返回码，但又得苦苦等待这个返回码，这会造成性能极大的下降。mongoDB可以让用户来选择采用何种方式。有些操作可以使用不安全模式（速度快），有些操作使用安全模式。
    安全操作是在执行完操作后立即执行getLastError命令，来检查是否成功执行。然后适当的处理数据库返回的错误，一般情况下数据库会抛出一个可捕获的错误，我们可以采用自己的开发语言来捕获和处理。如果执行成功，getLastError会给出额外的信息作为响应（比如：更新或删除操作给出的更新数）。

请求和连接

    数据库会为每个mongoDB连接创建一个独立的队列，来存放连接的请求，当客户端发送请求，会被存放到该连接队列的末尾，当队列的请求都执行完毕后，才会执行后续的请求。对于实际应用的交错插入、查询，会产生秒级的延迟。

查询

查询 find

查询就是返回一个集合中文档的子集，子集合的范围从0个文档到整个集合。
例如：
db.mydb.user.find({name:”test1”})

指定返回值

有时并不需要返回文档中的所有键和值，遇到这样的情况，使用find 的第二个参数来指定返回键，这样做既可以节省传输的数据量，也可以节省客户端解码文档的时间和内存开销。
例如： db.mydb.user.find({},{age:1，_id:0})
1代表显示，0代表不显示

限制

查询还是有些限制的，数据库所关心的查询文档的值必须是常量，也就是所不可以使用文档的其他键值

条件查询

查询条件

类型	描述	举例
< $t	(小于)	db.mydb.user.find({age:{$lt:35}})
<=$lte	(小于等于)	db.mydb.user.find({age:{$lte:35}})
> $gt	（大于）	db.mydb.user.find({age:{$gt:31}})
>=$gte	（大于等于）	db.mydb.user.find({age:{$gte:31}})
≠$ne	（不等于）	db.mydb.user.find({name:{$ne:”test3”}})
模糊查询	/^…/	db.mydb.user.find({name:/^test/})

$OR和$not查询

$in 用来查询一个键的多个值 相对的是$nin
db.mydb.user.find({users:{$in:["dsm","pddd"]}})
db.mydb.user.find({users:{$nin:["dsm","pddd"]}})
$or：比$in更通用一些，是用来查询多个键的任意给定键值,其值是一个数组形式
db.mydb.user.find({$or:[{users:"dsm"},{name:"aaa"}]})
db.mydb.user.find({$or:[{users:{$in:["dsm","pddd"]}},{name:"aaa"}]})
$not是元条件句，就是可以用在任意的其他查询条件上。
$not：是用来查询与特定模式不相符的文档。
db.mydb.user.find({age:{$not:{$mod:[5,0]}}})
$not 与正值表达是联合使用的时候极为有用。

条件句规则

在查询中，类似$lt的键处在内层文档，如修改器$inc则处在外层文档。
如：{age：{$lt:30}} 与  {$inc:{age:1}}
而且一个键可以含有多个条件，但不可以含有多个修改器：
{age:{$lt:30,$gt:20}}  √     
{$inc:{age:1},$set:{age:40}}  × 不能在同一行修改同一个对age的修改

数组查询

$all

对于数组查询中，多个元素的匹配时，需要用到关键键$all. 如下：
db.mydb.insert({shop:”B”,fruit:[“apple”,” peach”,”orange”],size:3})
db.mydb.insert({shop:”C”,fruit:[“mango”,”banana”,” apple”],size:3})
查询既有”apple”又有”banana”的文档：
db.mydb.find({fruit:{$all:[“apple”，”banana”]}})
注：$all 查询不考虑键值的先后顺序问题。

精确匹配

使用[ ]精确匹配数组元素，既要考虑键值的个数，也要考虑元素位置： 
db.mydb.find({fruit:[“apple”,”banana”,”orange”]})

下标查询

Key: 代表键。
Index:代表数组下标。
数组键值下标是从0开始。如下：
 db.mydb.find({“fruit.1”:“banana”})
查询数组中第二的元素为“banana”的文档。

$size

在数组查询中，$size的查询意义非凡，顾名思义，该键就是查询指定长度的数组。
如：db.mydb.find({fruit:{$size：3}})
但是很不幸的是，它不可以与其他查询子句组合使用（”$lt“、”$gt“）;
如：db.mydb.find({fruit:{$size:{$gt:3}}})  是非法的。
但是这种查询可以通过在文档中增加一个size键来实现。
如：db.mydb.update({shop:”A”},{“$push”:{fruit:“Watermelon”},$inc:{size:1}})
 db.mydb.find({size:{“$lt”:4}})

$slice

$slice 是用于子集查询，其返回值是一个子集合。如：
db.mydb.find({shop:”A”},{fruit:{$slice:2}})
上面查询表示查询数组的前2个子集。
也可以返回后2个子集：
db.mydb.find({shop:”A”},{fruit:{$slice:-2}})
它也可以接受偏移量[m,n]:
db.mydb.find({shop:”A”},{fruit:{$slice:[1,2]}})
表示跳过第一个,查询2个子集。

内嵌文档查询

单个内嵌文档

db.mydb.km.find({“person.name”:”zhangsan”,”person.age”:25})
这种点的查询方式就是区别于其他普通文档的主要特点，而且为什么对于键名不能使用.这个符号做出了最好的诠释。
注：键值匹配查询，对于内嵌文档值多个或者顺序未知的情况下，是有效的。

复杂内嵌文档

$where查询

需求：查询apple和banana值相等的文档。（就是如何匹配键值相等？）
普通查询是满足不了的。Mongo也没有提供这样的$关键键。只能通过$where表达式来执行：
 db.mydb.fruit.find({“$where”：function(){
      if(this.apple==this.banana) return true;
      return false;
}}) 
等价db.mydb.fruit.find({“$where”:”this.apple==this.banana”})
$where 查询其返回值是表达式返回reture的当前文档。
优点：就是由于它可以使用javascript表达式，可想而知，查询非常灵活、多样。
缺点：使用$where查询，比起普通的查询速度要慢的多。因为其查询原理是将被查询文档转化成javacript对象，然后通过$where表达式去比较，而且还不能使用索引。所以不到万不得已尽量避免使用$where查询。

limit、skip和sort 使用

limit

limit 是限制返回结果集的数量，在find函数后使用该函数。
limit(number): 返回匹配number个文档。这里的number是上限，不是下限。
例如：
 db.mydb.fruit.find().limit(3) // 返回匹配到的3个文档
如果结果少于3个，则全部返回。

skip

skip 类似于limit，区别在于：
skip(number): 略过匹配到的前number个文档，返回剩下的文档。
例如：
 db.mydb.fruit.find().skip(3)  //略过匹配到的前3个文档，返回余下的所有文档。
如果结果少于3个，则返回空。

sort

sort 是排序函数，它的参数一个文档对象（键、值），键是集合中的键，值是1或-1；
1 代表升序；-1 代表降序。
例如：
 db.mydb.fruit.find().sort({apple:1,banana:-1})
由于文档型数据库的数据类型是不规则的，但mongo预定义了数据类型的排序规则。如：{a:[1,2]} 、{a:true}
从小到大 ：
1、最小值                  7、二进制                    13、最大值
2、null                       8、对象ID
3、数字                      9、布尔型
4、字符串                  10、日期
5、文档                      11、时间戳
6、数组                      12、正则表达式
实际开发中，三个函数组合使用的情况比较多。
例如（分页：第一页）：
   db.mydb.fruit.find().limit(20).sort({apple:1})
 第二页：
   db.mydb.fruit.find().limit(20).skip(20).sort({apple:1})

随机抽取文档

方法一

在实际应用中，随机抽取一个或多个文档是非常常见的需求，在mongo中实现起来有点繁琐：
最简单的实现方法：
先计算出一个从0到记录总数之间的随机数，然后采用skip(随机数)方法 。
var total=db.mydb.fruit.count();
var random=Math.floor(Math.random()*total);
  db.mydb.fruit.find().skip(random).limit(1);

方法二

当数据量很大时，skip操作会变的很慢，应该避免使用skip来跳过大量的数据 。
可以采用另一种查询方式：
为每一条记录增设random字段，并赋值为Math.random()，查询时采用$gte和$lte。
db.mydb.fruit.update({banana:1},{$set:{random: Math.random()}})
var rand=Math.random();
db.mydb.fruit.find({random:{$gte:rand}});

方法三

高大上：借助Mongodb对地理空间索引（geospatial indexes）的支持，从而可以在上一个方法的基础上来实现随机记录的获取。 

创建地理空间索引
 db.mydb.fruit.ensureIndex({random:”2d”})
 db.mydb.fruit.update({banana:1},{random:[Math.random,0]})
 db. mydb.fruit.find ({random: { $near: [Math.random(), 0] } })

null

在查询中，null有点奇怪，它不仅可以匹配键值为null的文档，而且还可以匹配“不存在”的键。
如果仅仅想要匹配键值为null的文档，既要判断该键值是否为null,还有通过“$exists”判断该键是否存在。
例如：
db.mydb.test.find({z:{$in:[null],$exist:true}})

正则表达式

正值表达式能更灵活有效的匹配字符串。MongoDB使用Perl兼容的正值表达式（PCRE）库来匹配正值表达式，PCRE所支持的正值表达式都能被MongoDB接受。正值表达式也可以匹配自身。
例如：
{name:/jack/}    全匹配
{name:/jack/i}   忽略大小写
{name:/jac?/i}   相似匹配
{name:/^ja/}     模糊查询

聚合查询

count

    最简单的聚合查询就是count查询，它的查询方式跟find是一样的，但是返回值不一样。Find 返回值是文档集，count 返回值是文档数。
   例如：
   db.mydb.fruit.count()    ->查询文档总数
   db.mydb.fruit.count({banana:1}) ->查询限定文档总数

distinct

 distinct 是键值去重。其返回值是一个数组。
用法：
db.mydb.fruit.distinct(“键”[,查询条件])
如：
db.mydb.fruit.distinct(“apple”)
db.mydb.fruit.distinct(“apple”,{banana:1})

group

在mongodb里面做group操作有点小复杂,利用group可以将集合中的记录按一个或多个键分组，然后可以聚合每个分组内的文档产生新的结果。 
用法：db.mydb.fruit.group({‘key’:{},'$reduce':function(doc,prev){},'initial':{}})  
key：分组的键；
initial：累加器初始值，分组之后，每一组的reduce函数会调用这个初始文档，并在组内传递累加器；
$reduce：分组处理函数，分组之后会对每组元素遍历处理，该函数两个参数，第一个参数是当前的文档对象和第二个参数是上一次function操作的累计对象；
结果返回值为文档数组：
 [{分组键，累加器}]
例如：
 db.mydb.fruit.db.group({key:{apple:1},$reduce:function(doc,pre){
     pre.bananaArr.push(doc.banana)
},initial:{bananaArr:[]}})