【Nosql数据库--更新中】

最新推荐文章于 2022-04-30 17:16:21 发布

骑着蜗牛追汤圆

最新推荐文章于 2022-04-30 17:16:21 发布

阅读量807

点赞数 1

分类专栏：数据库

本文链接：https://blog.csdn.net/qq_40003309/article/details/107555748

版权

数据库专栏收录该内容

20 篇文章 2 订阅

订阅专栏

一、NOSQL简介

NoSQL，指的是非关系型的数据库。NoSQL用于超大规模数据的存储。

1.RDBMS与Nosql的比较

RDBMS

高度组织化结构化数据
结构化查询语言（SQL）
数据和关系都存储在单独的表中。
数据操纵语言，数据定义语言
严格的一致性
基础事务

NoSQL

代表着不仅仅是SQL
没有声明性查询语言
没有预定义的模式
-键 - 值对存储，列存储，文档存储，图形数据库
最终一致性，而非ACID属性
非结构化和不可预知的数据
CAP定理：一致性、可用性、分区容忍性
高性能，高可用性和可伸缩性

2.NoSQL 数据库分类：键值数据库、列族数据库、文档数据库和图形数据库.

在这里插入图片描述
3.NoSQL 在国内使用的案例：
1、新浪微博： Redis
2、淘宝数据平台
3、视觉中国网站：MongoDB
4、优酷运营数据分析：MongoDB

二、redis知识

1.redis简介

Remote Dictionary Server（远程字典服务器）。是完全开源免费的，用C语言编写的，遵守BSD协议。是一个高性能的(key/value)分布式内存数据库，基于内存运行并支持持久化的NoSQL数据库（缓存），是当前最热门的NoSql数据库之一,也被人们称为数据结构服务器。
Redis 与其他 key - value 缓存产品有以下三个特点
i）Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用
ii）Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储
iii）Redis支持数据的备份，即master-slave模式的数据备份
1、能干嘛？
（1）内存存储和持久化：redis支持异步将内存中的数据写到硬盘上，同时不影响继续服务
（2）取最新N个数据的操作，如：可以将最新的10条评论的ID放在Redis的List集合里面
（3）模拟类似于HttpSession这种需要设定过期时间的功能
（4）发布、订阅消息系统
（5）定时器、计数器
2、去哪下？
（1）Http://redis.io/
（2）Http://www.redis.cn/
3、怎么玩？
（1）数据类型、基本操作和配置
（2）持久化和复制，RDB/AOF
（3）事务的控制
（4）复制

2.redis两种安装方式

rpm包安装：

步骤：
1.下载epel源：在mirros.aliyun.com(https://developer.aliyun.com/mirror/)

[root@manager ~]# wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

或者fpmfind.net网址里下载
----------上面下载的是3.2版本------下面的是下载新版本--------
yum install ftp://rpmfind.net/linux/remi/enterprise/7/remi/x86_64/redis-4.0.1-1.el7.remi.x86_64.rpm
2.启动服务：

 systemctl start redis
  systemctl enable redis

3. 验证测试：

   [root@localhost ~]# netstat -lnupt | grep :6379
   tcp     0    0 127.0.0.1:6379      0.0.0.0:*       
LISTEN    11413/redis-server
   [root@localhost ~]# ps -ef | grep redis
   redis   11413    1  0 10:46 ?     00:00:03 /usr/bin/redis-server
127.0.0.1:6379
   [root@localhost ~]# lsof -i tcp:6379
   COMMAND   PID USER  FD  TYPE DEVICE SIZE/OFF NODE NAME
   redis-ser 11413 redis  6u IPv4  29352   0t0 TCP localhost:6379
(LISTEN)

Redis命令行客户端:
发送命令：
redis-cli -h 127.0.0.1 -p 6379
redis-cli PING
redis-cli
命令返回值
状态回复，e.g. >PING
错误恢复, e.g. >ECMD
整数回复, e.g. >INCR foo
字符串回复，e.g. >GET foo >GET notexists`
多行字符串回复，e.g. >KEYS *

练习：在线安装redis5.0.9

[root@localhost ~]# ls
redis-5.0.9-1.el7.remi.x86_64.rpm
[root@localhost ~]# yum install redis-5.0.9-1.el7.remi.x86_64.rpm
[root@localhost ~]# systemctl start redis
[root@localhost ~]# systemctl status redis
● redis.service - Redis persistent key-value database
   Loaded: loaded (/usr/lib/systemd/system/redis.service; disabled; vendor preset: disabled)
  Drop-In: /etc/systemd/system/redis.service.d
           └─limit.conf
   Active: active (running) since 六 2020-07-25 21:36:05 CST; 6s ago
 Main PID: 4483 (redis-server)
   CGroup: /system.slice/redis.service
           └─4483 /usr/bin/redis-server 127.0.0.1:6379

7月 25 21:36:05 localhost.localdomain systemd[1]: Starting Redis persist...
7月 25 21:36:05 localhost.localdomain systemd[1]: Started Redis persiste...
Hint: Some lines were ellipsized, use -l to show in full.
[root@localhost ~]# redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> quit

源码安装redis4.0.1版本：

源码安装过程值得一看1
步骤：
1.下载源码包：

curl -O http://download.redis.io/releases/redis-4.0.1.tar.gz

2.解压

tar xf redis-4.0.1.tar.gz -C /usr/local/src/

3.编译安装

[root@localhost ~]# cd /usr/local/src/redis-4.0.1/
[root@localhost redis-4.0.1]# yum install gcc gcc-c++ make -y
[root@localhost redis-4.0.1]# make
[root@localhost redis-4.0.1]# make install

4.提供配置文件

[root@manager redis-4.0.1]# cp redis.conf /etc/redis/
[root@manager redis-4.0.1]# cd /etc/redis/
[root@manager redis]# vim redis.conf
#daemonize no
daemonize yes  #使用yes启用守护进程
[root@manager redis]# redis-server redis.conf 
58342:C 24 Jul 11:34:48.580 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
58342:C 24 Jul 11:34:48.580 # Redis version=4.0.1, bits=64, commit=00000000, modified=0, pid=58342, just started
58342:C 24 Jul 11:34:48.580 # Configuration loaded

5.登录：

[root@localhost ~]# redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> quit

#源码配置服务启动脚本：
1、创建用户和组

groupadd -g 935 -r redis
useradd -u 935 -g 935 -r -d /var/lib/redis -c “redis server” -s
/sbin/nologin redis
mkdir -p /var/lib/redis
chown -R redis /var/lib/redis
chmod -R 700 /var/lib/redis

2、修改配置文件/etc/redis/redis.conf

dir /var/lib/redis/
daemonize no

3、创建服务脚本

[root@localhost ~]# vim /usr/lib/systemd/system/redis.service
[Unit]
Description=Redis persistent key-value database
After=network.target
[Service]
ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf --supervised systemd
ExecStop=/usr/bin/kill -9 $(pidof redis-server)
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
[Install]
WantedBy=multi-user.target

4、测试脚本

[root@localhost ~]# systemctl daemon-reload
[root@localhost ~]# systemctl stop redis
[root@localhost ~]# ps -ef | grep redis
root    14888  5517  0 10:36 pts/1   00:00:00 grep --color=auto redis
[root@localhost ~]# systemctl start redis
[root@localhost ~]# ps -ef | grep redis
redis   14895    1  0 10:37 ?     00:00:00 /usr/local/bin/redis-server 127.0.0.1:6379

练习：源码安装redis5.0.9版本
步骤：
1.安装redis5.0.9

[root@localhost ~]# ls
redis-5.0.9.tar.gz
[root@localhost ~]# yum install gcc gcc-c++ make -y
[root@localhost ~]# tar xf redis-5.0.9.tar.gz -C /usr/local/src/
[root@localhost src]# cd /usr/local/src/redis-5.0.9/
[root@localhost redis-5.0.9]# ls
00-RELEASENOTES  deps       README.md        runtest-moduleapi  tests
BUGS             INSTALL    redis.conf       runtest-sentinel   utils
CONTRIBUTING     Makefile   runtest          sentinel.conf
COPYING          MANIFESTO  runtest-cluster  src
[root@localhost redis-5.0.9]# make MALLOC=libc
[root@localhost redis-5.0.9]# make install PREFIX=/usr/local/redis

2.启动redis
2.1、直接启动redis：./redis-server

[root@localhost redis-5.0.9]# cd src
[root@localhost src]# ./redis-server
6094:C 25 Jul 2020 21:52:57.246 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
6094:C 25 Jul 2020 21:52:57.246 # Redis version=5.0.9, bits=64, commit=00000000, modified=0, pid=6094, just started
6094:C 25 Jul 2020 21:52:57.246 # Warning: no config file specified, using the default config. In order to specify a config file use ./redis-server /path/to/redis.conf
6094:M 25 Jul 2020 21:52:57.247 * Increased maximum number of open files to 10032 (it was originally set to 1024).
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 5.0.9 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 6094
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

6094:M 25 Jul 2020 21:52:57.248 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
6094:M 25 Jul 2020 21:52:57.248 # Server initialized
6094:M 25 Jul 2020 21:52:57.248 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
6094:M 25 Jul 2020 21:52:57.248 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
6094:M 25 Jul 2020 21:52:57.248 * Ready to accept connections

redis启动成功，但是这种启动方式需要一直打开窗口，不能进行其他操作，不太方便。则就需要通过杀掉进程的方式停掉redis或者ctrl+c退出

[root@localhost sh]# ps -aux | grep redis
root       6094  0.1  0.2 144120  2376 pts/3    Sl+  21:52   0:00 ./redis-server *:6379
root       6154  0.0  0.0 112824   980 pts/1    R+   21:54   0:00 grep --color=auto redis
[root@localhost sh]# kill -9  6094
#则之前卡的那个会话就会显示   已杀死

2.2、以后台进程方式启动redis：./redis-server 配置文件路径

[root@localhost redis-5.0.9]# vim redis.conf
将daemonize no
修改为
daemonize yes
然后启动得时候指定配置文件启动：

[root@localhost src]# ./redis-server /usr/local/src/redis-5.0.9/redis.conf 
6512:C 25 Jul 2020 22:01:06.227 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
6512:C 25 Jul 2020 22:01:06.228 # Redis version=5.0.9, bits=64, commit=00000000, modified=0, pid=6512, just started
6512:C 25 Jul 2020 22:01:06.228 # Configuration loaded
[root@localhost src]# ps -aux | grep redis
root       6513  0.1  0.1 144120  1916 ?        Ssl  22:01   0:00 ./redis-server 127.0.0.1:6379
root       6629  0.0  0.0 112824   980 pts/3    R+   22:03   0:00 grep --color=auto redis

2.3、使用redis-server 配置文件路径的命令启动redis
步骤：
1.为了方便，把配置文件的位置复制到/etc/redis/

[root@localhost ~]# mkdir -p /etc/redis
[root@localhost ~]# cp /usr/local/src/redis-5.0.9/redis.conf /etc/redis/

2.创建数据文件，在配置文件中添加数据文件路径

[root@localhost ~]# mldir -p /var/lib/redis
[root@localhost ~]# vim /etc/redis/redis.conf
dir /var/lib/redis

3.创建redis用户，给数据文件提供权限：使数据文件目录下的文件属主和属组都是redis

[root@localhost ~]# groupadd -r -u 995 redis
[root@localhost ~]# useradd -r -u 997 -g 995 -d /var/lib/redis -c 'Redis server' -s /sbin/nologin redis
[root@localhost ~]# id redis
uid=997(redis) gid=995(redis) 组=995(redis)
[root@localhost ~]# chown -R redis /var/lib/redis/
[root@localhost ~]# ll /var/lib/redis
总用量 4
-rw-r--r-- 1 redis redis 92 7月  25 21:40 dump.rdb

4.设置环境变量

[root@localhost ~]# vim /etc/profile.d/redis.sh
export PATH=/usr/local/redis/bin:$PATH
[root@localhost ~]# source /etc/profile.d/redis.sh

5.测试：redis-server /etc/redis/redis.conf

[root@localhost ~]# redis-server  /etc/redis/redis.conf
8042:C 25 Jul 2020 22:31:55.716 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
8042:C 25 Jul 2020 22:31:55.716 # Redis version=5.0.9, bits=64, commit=00000000, modified=0, pid=8042, just started
8042:C 25 Jul 2020 22:31:55.716 # Configuration loaded

2.4、配置服务启动脚本的方式启动redis服务
之前使用rpm安装的时候拷贝了一个redis.service脚本：然后再把这个脚本放到/usr/lib/systemd/system/下

[root@localhost ~]# cp /usr/lib/systemd/system/redis.service 
[root@localhost ~]# cp redis.service /usr/lib/systemd/system/

然后编辑redis.service:更改启动服务命令文件路径和关闭文件路径

[root@localhost ~]# vim /usr/lib/systemd/system/redis.service 
[Unit]
Description=Redis persistent key-value database
After=network.target

[Service]
ExecStart=/usr/local/redis/bin/redis-server /etc/redis/redis.conf --supervised systemd
ExecStop=/usr/bin/kill `pidof redis-server`
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

测试：

[root@localhost ~]# systemctl restart redis
[root@localhost ~]# pidof redis-server
8591
[root@localhost ~]# systemctl stop redis
[root@localhost ~]# ps -ef | grep redis
root      10322   2970  0 23:18 pts/3    00:00:00 grep --color=auto redis

作业：https://docs.qq.com/doc/DT2pmREVWUFlaZlN3

3.redis配置文件:redis.conf

设置redis登录密码值得一看2
对于自己搭建的redis数据库可以修改redis.conf如下：

开启日志记录：修改redis配置文件，修改rsyslog配置文件，最后重启rsyslog和redis服务

1.修改redis配置文件
 syslog-enabled yes
 syslog-facility local0
2.修改/etc/rsyslog.conf配置文件:redis日志路径根据自己的配置进行修改
#Save redis messages also to redis.log
 local0.*                                                /var/log/redis/redis.log
#开启tcp和udp日志收集：
# Provides UDP syslog reception
$ModLoad imudp
$UDPServerRun 514
# Provides TCP syslog reception
$ModLoad imtcp
$InputTCPServerRun 514
3.重启redis和rsyslog
[root@manager etc]# systemctl restart rsyslog
[root@manager etc]# systemctl restart redis

开启套接字

[root@manager etc]# vim /etc/redis/redis.conf
unixsocket /tmp/redis.sock
unixsocketperm 700

修改绑定主机地址

bind 192.168.131.107 127.0.0.1

修改超时时间

timeout 300

以守护进程的方式运行

daemonize yes

Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程
daemonize no
当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过
idfile指定
pidfile /var/run/redis.pid
指定Redis监听端口，默认端口为6379，为什么选用6379作为默认端口，因为6379在手机按键上MERZ对
应的号码，而MERZ取自意大利歌女Alessia Merz的名字
port 6379
绑定的主机地址
bind 127.0.0.1
当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
timeout 300
指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为
verbose
loglevel verbose
日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为
标准输出，则日志将会发送给/dev/null
logfile stdout
设置数据库的数量，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id
databases 16
指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
save
Redis默认配置文件中提供了三个条件：
save 900 1key
save 300 10key
save 60 10000key
分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。
指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可
以关闭该选项，但会导致数据库文件变的巨大
rdbcompression yes
指定本地数据库文件名，默认值为dump.rdb
dbfilename dump.rdb
指定本地数据库存放目录 dir ./
设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进
行数据同步
slaveof
当master服务设置了密码保护时，slav服务连接master的密码
masterauth
设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH 命令
提供密码，默认关闭
requirepass foobared
设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打
开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会
关闭新的连接并向客户端返回max number of clients reached错误信息 maxclients 128
指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清
除已到期或即将到期的Key，当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以
进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区
maxmemory
指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，
可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所
以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no
指定更新日志文件名，默认为appendonly.aof
appendfilename appendonly.aof
指定更新日志条件，共有3个可选值：
no：表示等操作系统进行数据缓存同步到磁盘（快）
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec：表示每秒同步一次（折衷，默认值）
appendfsync everysec
指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问
量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析
Redis的VM机制）
vm-enabled no
虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享
vm-swap-file /tmp/redis.swap
将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内
存存储的(Redis的索引数据就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value
都存在于磁盘。默认值为0 vm-max-memory 0
Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个
对象共享，vm-page-size是要根据存储的数据大小来设定的，作者建议如果存储很多小对象，page大小最
好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不确定，就使用默认
值 vm-page-size 32
设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，
在磁盘上每8个pages将消耗1byte的内存。 vm-pages 134217728
设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是
串行的，可能会造成比较长时间的延迟。默认值为4 vm-max-threads 4
设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启 glueoutputbuf yes
指定在超过一定的数量或者最大的元素超过
某一临界值时，采用一种特殊的哈希算法
hash-max-zipmap-entries 64
hash-max-zipmap-value 512
指定是否激活重置哈希，默认为开启 activerehashing yes
指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例
又拥有自己的特定配置文件 include /path/to/local.conf

4.redis数据类型：

`redis面试简答题:`

1、简述redis应用场景。

答：
1. 热点数据的缓存：因为redis访问速度快，支持的数据类型比较丰富，所以比较适合缓存热点数据
2. 限时业务的运用：redis中可以使用expire命令设置一个键的生存时间，到时间后redis会删除它
3. 计数器相关问题：redis中incrby可以实现原子性的递增，可以用在高并发的没、秒杀活动、分布式序列号的生成等
4. 排行榜相关问题：关系型数据库在排行榜方面查询速度慢，所以借助redis的SortedSet进行热点数据的排序
5. 分布式锁：利用redis的setnx命令进行，setnx："set if not exists"就是如果不存在则成功设置缓存同时返回1，否则返回0
6. 延时操作、分页模糊搜索

2、 redis的优点是什么？

答：
1. 速度快：基于C语言所以执行速度快，采用单线程的架构（避免了多线程的资源竞争问题），源码精简
2. 强大的灵活性，基于键值对的服务器：集合了五种数据类型（字符串、列表、哈希、集合、有序集合），这五种数据结构都是围绕键值对的形式，况且值不仅仅是值还可以是数据结构，所以有强大的灵活性
3. 持久化：将数据写进磁盘
4. 丰富的功能：数据结构的强大，还有键过期、发布订阅等功能

3、常用的NoSQL数据库有那些，列举不少于3个。

答：NoSQL 数据库分类：键值数据库、列族数据库、文档数据库和图形数据库.
键值数据库：redis、memcached
列族数据库：Hbase HadoopDB
文档数据库：MongoDB
图形数据库：GraphDB

三、mongodb知识

1.mongodb简介：文档数据库

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。在高负载的情况下，添加更多的节点，可以保证服务器性能。MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。
MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。
MongoDB特性:
MongoDB是一个可扩展、高性能的下一代数据库，它的特点是高性能、易部署、易使用、存储数据方便，主要特性有：
• 面向文档存储，json格式的文档易读、高效；
• 模式自由，支持动态查询、完全索引，无模式；
• 高效的数据存储，效率提高；
• 支持复制和故障恢复；
• 以支持云级别的伸缩性，支持水平数据库集群，可动态添加额外服务器；
MongoDB的工作方式:
传统的关系型数据库一般有数据库（database）、表（table）、记录（record）三级层次构成。
MongoDB同样是由数据库（database）、集合（collection）、文档对象（documen）三个层次组成。
mongodb数据类型：
MongoDB与传统数据库的比较：

2.MongoDB两种安装方式

rpm安装 :

步骤：
1. 配置mongodb的yum源

[root@node1 ~]# vim /etc/yum.repos.d/mongodb.repo 
[mongodb-enterprise]
name=MongoDB Enterprise Repository
baseurl=https://repo.mongodb.com/yum/redhat/$releasever/mongodb-enterprise/4.2/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.2.asc

2. 安装mongodb:yum install -y mongodb-enterprise

[root@node1 ~]# yum install -y mongodb-enterprise

3. 启动服务：systemctl start mongod

[root@node1 ~]# systemctl start mongod

4. 测试登录：mongo

[root@node1 system]# mongo
MongoDB shell version v4.2.8
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("c6c65c04-83a7-4208-aa61-72e5a5f51e54") }
MongoDB server version: 4.2.8
Server has startup warnings: 
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] 
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] ** WARNING: Access control is not enabled for the database.
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] **          Read and write access to data and configuration is unrestricted.
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] ** WARNING: You are running this process as the root user, which is not recommended.
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] 
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] 
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] **        We suggest setting it to 'never'
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] 
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] **        We suggest setting it to 'never'
2020-07-28T20:59:47.633+0800 I  CONTROL  [initandlisten] 
---
Enable MongoDB's free cloud-based monitoring service, which will then receive and display
metrics about your deployment (disk utilization, CPU, operation statistics, etc).

The monitoring data will be available on a MongoDB website with a unique URL accessible to you
and anyone you share the URL with. MongoDB may use this information to make product
improvements and to suggest MongoDB products and deployment options to you.

To enable free monitoring, run the following command: db.enableFreeMonitoring()
To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---

> db
test
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
> exit
bye

源码安装mongodb:

步骤：
1. 下载软件包：

[root@node1 ~]# wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-4.2.8.tgz

2. 解压:

[root@node1 ~]# tar xf mongodb-linux-x86_64-rhel70-4.2.8.tgz -C /usr/local/

3. 创建数据目录：

[root@node1 ~]# mkdir -p /data/db

4. 启动
创建一个mongodb安装目录的软链接：为了方便

[root@localhost ~]# cd /usr/local/
[root@localhost local]# ln -sv mongodb-linux-x86_64-rhel70-3.4.7/
mongodb
    "mongodb" -> "mongodb-linux-x86_64-rhel70-3.4.7/"

编写环境变量文件：/etc/profile.d/mongo.sh

[root@localhost ~]# vim /etc/profile.d/mongo.sh
export PATH=$PATH:/usr/local/mongodb/bin
[root@localhost ~]# source /etc/profile.d/mongo.sh

以 mongod 指定数据文件路径的方式启动：mongod --dbpath=/data/db &

[root@node1 system]# mongod --dbpath=/data/db &
[1] 3234
[root@node1 system]# 2020-07-28T21:10:24.136+0800 I  CONTROL  [main] Automatically disabling TLS 1.0, to force-enable TLS 1.0 specify --sslDisabledProtocols 'none'
2020-07-28T21:10:24.159+0800 W  ASIO     [main] No TransportLayer configured during NetworkInterface startup
2020-07-28T21:10:24.159+0800 I  CONTROL  [initandlisten] MongoDB starting : pid=3234 port=27017 dbpath=/data/db 64-bit host=node1
2020-07-28T21:10:24.159+0800 I  CONTROL  [initandlisten] db version v4.2.8

5. 检查

[root@node1 system]# netstat -lntup | grep mongod
tcp        0      0 127.0.0.1:27017         0.0.0.0:*               LISTEN      3358/mongod         
[root@node1 system]# ps -ef | grep mongod
root       3358      1  3 21:12 ?        00:00:01 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/bin/mongod.conf
root       3405   2546  0 21:13 pts/2    00:00:00 grep --color=auto mongod

杀掉进程，停止服务：

[root@node1 system]# pidof mongod
3234
[root@node1 system]# kill -9 3234

#以系统服务方式启动：
1. 创建配置文件mongod.conf

[root@node1 system]# vim /usr/local/mongodb/bin/mongod.conf
systemLog:
  destination: file
  logAppend: true
  path: /usr/local/mongodb/log/mongod.log

# Where and how to store data.
storage:
  dbPath: /usr/local/mongodb/data
  journal:
    enabled: true

# how the process runs
processManagement:
  fork: true  # fork and run in background

# network interfaces
net:
  port: 27017
  bindIp: 127.0.0.1  # Enter 0.0.0.0,:: to bind to all IPv4 and IPv6 addresses or, alternatively, use the net.bindIpAll setting.

2. 创建配置文件所需的日志和数据文件存放目录：

[root@localhost ~]# mkdir -p /usr/local/mongodb/{data,log}

3. 配置mongodb服务启动脚本：mongod.service

[root@node1 system]# vim /usr/lib/systemd/system/mongod.service 
[Unit]
Description=mongodb service daemon
After=network.target
[Service]
Type=forking
ExecStart=/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/bin/mongod.conf
ExecStop=/usr/local/mongodb/bin/mongod --shutdown -f /usr/local/mongodb/bin/mongod.conf
PrivateTmp=true
[Install]
WantedBy=multi-user.target

4. 使用系统命令启动服务:systemctl start mongod (要把之前在线安装的时候启动得Mongodb服务的进程杀死：kill -9 `pidof mongod`)

[root@node1 system]# systemctl start mongod
[root@node1 system]# systemctl enable mongod
[root@node1 system]# ps -ef | grep mongod
root       3358      1  0 21:12 ?        00:00:03 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/bin/mongod.conf
root       3453   2546  0 21:18 pts/2    00:00:00 grep --color=auto mongod
[root@node1 system]# netstat -lntup | grep mongod
tcp        0      0 127.0.0.1:27017         0.0.0.0:*               LISTEN      3358/mongod         
[root@node1 system]# systemctl stop mongod
[root@node1 system]# netstat -lntup | grep mongod
[root@node1 system]# ps -ef | grep mongod
root       3470   2546  0 21:19 pts/2    00:00:00 grep --color=auto mongod

有时候启动MongoDB时出错Failed to unlink socket file /tmp/mongodb-27017.sock errno:1 Operation not permitted

3.MongoDB配置文件介绍

新版本的配置文件使用YAML语法编写的：

YAML语言：
1.语法规则：
大小写敏感
使用缩进表示层级关系
缩进时不允许使用Tab键，只允许使用空格。（两个空格作为缩进）
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
2.支持的数据结构：
对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary） #键: 值 (注意冒号后面有个空格)
数组：一组按次序排列的值，又称为序列（sequence） / 列表（list） #depend: - gcc #注意-后面有个空格 - openssl-devel
纯量（scalars）标量：单个的、不可再分的值
#注意：
1.缩进建议用两个空格，不能用tab
2.注释用#
3.冒号后面要有一个空格
4.短横线：-空格代表的是一个列表
新版配置文件介绍：
MongoDB配置文件详解值得一看3

4.MongoDB基本操作：

作业：https://docs.qq.com/doc/DT3dPblpidmdIZEx4

MongoDB基本操作练习值得一看4

1.数据库操作

创建数据库： use 数据库名（不存在则创建并占用；存在则占用）
查询当前是哪个数据库：db 或者 db.getName()
当前库状态：db.stats()
查询所有数据库：show dbs;
删除数据库：db.dropDatabase()

#创建并占用数据库school
MongoDB Enterprise > use school
switched to db school
#查看当前库
MongoDB Enterprise > db
school
MongoDB Enterprise > db.getName()
school
#查看当前库状态
MongoDB Enterprise > db.stats()
{
	"db" : "school",
	"collections" : 0,
	"views" : 0,
	"objects" : 0,
	"avgObjSize" : 0,
	"dataSize" : 0,
	"storageSize" : 0,
	"numExtents" : 0,
	"indexes" : 0,
	"indexSize" : 0,
	"scaleFactor" : 1,
	"fileSize" : 0,
	"fsUsedSize" : 0,
	"fsTotalSize" : 0,
	"ok" : 1
}  
#查询所有数据库
MongoDB Enterprise > show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
#删除当前数据库
MongoDB Enterprise > db.drop    #按两下TAB
db.dropAllRoles(  db.dropDatabase(  db.dropUser(
db.dropAllUsers(  db.dropRole(
MongoDB Enterprise > db
school
MongoDB Enterprise > db.dropDatabase()
 { "ok" : 1 }
 注意：命令严格区分大小写

2.Collection 集合：类似Mysql中的表

1、创建一个聚集集合，db.createCollection(name, {capped: , autoIndexId: , size:
, max } )
name:集合的名字
capped:是否启用集合限制，如果开启需要制定一个限制条件，默认为不启用，这个参数没有实际意义
size:限制集合使用空间的大小，默认为没有限制
max:集合中最大条数限制，默认为没有限制
autoIndexId:是否使用_id作为索引，默认为使用(true或false)
size的优先级比max要高
MongoDB Enterprise > db.createCollection(“books”)
{ “ok” : 1 }
2、得到指定名称的聚集集合：db.getCollection(“account”);
MongoDB Enterprise > db.getCollection(“student”)
school.student
3、得到当前db的所有聚集集合：db.getCollectionNames()
MongoDB Enterprise > db.getCollectionNames()
[ “student” ]
4、显示当前db所有聚集索引的状态
db.printCollectionStats()
5.其他：
1、查询之前的错误信息：db.getPrevError();
2、清除错误记录：db.resetError();
6、查看聚集集合基本信息：
1、查看帮助：db.books.help()
2、查询当前集合的数据条数：db.books.count()
3、查看数据空间大小：db.books.dataSize()
4、得到当前聚集集合所在的db：db.books.getDB()
5、得到当前聚集的状态：db.books.stats()
6、得到聚集集合总大小：db.books.totalSize()
7、聚集集合储存空间大小：db.books.storageSize()
8、Shard版本信息：db.books.getShardVersion()
9、聚集集合重命：db.books.renameCollection(“BOOK”)
10、删除当前聚集集合：db.BOOK.drop()

3.插入文档，类似于MYSQL的记录,键值对类似于MYSQL的字段（一条文档/记录使用{}括起来，多条文档使用[]括起来）
MongoDB 使用 insert() 或 save() 方法向集合中插入文档，语法如下：
db.COLLECTION_NAME.insert(document)。
MongoDB Enterprise > db.student.insert({id:101,name:“张三”,gender:“男”})
WriteResult({ “nInserted” : 1 })
MongoDB Enterprise > db.student.save({id:102,name:“张三”,gender:“男”})
WriteResult({ “nInserted” : 1 })
查找所有的文档：db.student.find()
MongoDB Enterprise > db.student.find()
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
3.2 版本后还有以下几种语法可用于插入文档:
◇ db.collection.insertOne():向指定集合中插入一条文档数据
MongoDB Enterprise > db.student.insertOne({id:102,name:“张三”,gender:“男”})
{
“acknowledged” : true,
“insertedId” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”)
}
◇ db.collection.insertMany():向指定集合中插入多条文档数据
MongoDB Enterprise > db.student.insertMany([
… {id:104,name:“李四”,age:18},
… {id:105,name:“王志刚”,gender:“男”,age:40},
… {id:106,name:“赵薇”,gender:“女”,age:20}]
… )
{
“acknowledged” : true,
“insertedIds” : [
ObjectId(“5f1f8d6f5d060a82f1c43fa6”),
ObjectId(“5f1f8d6f5d060a82f1c43fa7”),
ObjectId(“5f1f8d6f5d060a82f1c43fa8”)
]
}
◇插入多维数据:
db.student.insertMany( [{id:206,name:‘孙
八’,sex:‘男’,age:21,address:{province:‘Hebei’,city:‘tangshan’}}, {id:207,name:‘侯
九’,sex:‘男’,age:20,address:{province:‘Zhejiang’,city:‘hangzhou’}}])
{
“acknowledged” : true,
“insertedIds” : [
ObjectId(“599199e55aa1de0dfdd680b6”),
ObjectId(“599199e55aa1de0dfdd680b7”),
ObjectId(“599199e55aa1de0dfdd680b8”)
]
}
◇数组信息添加:
MongoDB Enterprise > db.student.insertMany([
… {id:208,name:‘吴京’,sex:‘男’,age:43,address:
{province:‘beijing’,city:‘beijing’},hobdy:[‘mil’,‘Fight’,‘sing’]},
… {id:209,name:‘杨幂’,sex:‘女’,age:31,address:
{province:‘HongKong’,city:‘HongKong’},hobdy:[‘dance’,‘shopping’,‘sing’]},
… {id:210,name:‘黄渤’,sex:‘男’,age:43,address:
{province:‘Shandong’,city:‘qingdao’},hobdy:[‘dance’,‘game’,‘sing’]}])
{
“acknowledged” : true,
“insertedIds” : [
ObjectId(“59919dabea892d3424c01998”),
ObjectId(“59919dabea892d3424c01999”),
ObjectId(“59919dabea892d3424c0199a”)
]
}

4、数据查询
1、笼统方式查询
db.数据表.find() //查询全部，相当于：select * from 表;
db.数据表.findOne() //查询第一条
MongoDB Enterprise > db.student.find()
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 103, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }
MongoDB Enterprise > db.student.findOne()
{
“_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”),
“id” : 101,
“name” : “张三”,
“gender” : “男”
}
2 限制条件查询
db.数据表.find(条件)
db.数据表.findOne(条件)
MongoDB Enterprise > db.student.find({id:101})
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
MongoDB Enterprise > db.student.find({id:105}).pretty()
{
“_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”),
“id” : 105,
“name” : “王志刚”,
“gender” : “男”,
“age” : 40
}
3 范围条件查询
$gt $lt $gte $lte $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots教程' 小于 {<key>:{$ lt:}} db.col.find({“likes”:{ $KaTeX parse error: Expected 'EOF', got '}' at position 6: lt:50}̲}).pretty() whe\dots$ lte:}} db.col.find({“likes”:{ $KaTeX parse error: Expected 'EOF', got '}' at position 7: lte:50}̲}).pretty() whe\dots$ gt:}} db.col.find({“likes”:{ $KaTeX parse error: Expected 'EOF', got '}' at position 6: gt:50}̲}).pretty() whe\dots$ gte:}} db.col.find({“likes”:{ $KaTeX parse error: Expected 'EOF', got '}' at position 7: gte:50}̲}).pretty() whe\dots$ ne:}} db.col.find({“likes”:{$ne:50}}).pretty() where
likes!=50

MongoDB Enterprise > db.student.find({age:{$lt:40}})
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }

4 设置多个查询条件
并且（与） db.数据表.find({条件,条件,条件}).pretty()
OR 条件语句使用了关键字 $or,语法格式如下：
db.数据表.find({ $or: [ {条件},{条件},{条件}]}).pretty()

MongoDB Enterprise > db.student.find({age: { $g t e : 20,$ lte:30}})
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }
MongoDB Enterprise > db.student.find({ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotsder:"男"},{age:{$ lte:40}}]})
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }
MongoDB Enterprise > db.student.find({age:{$lte:40},name:/^赵/})
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }

5、查看姓王的记录：
MongoDB Enterprise > db.student.find({name: /^张/})
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 102, “name” : “张三”, “gender” : “男” }
MongoDB Enterprise > db.student.find({name: /赵/}) #包含
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
6、查询指定列的数据：
MongoDB Enterprise > db.student.find({},{name: 1,age :1})
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “name” : “张三” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “name” : “张三” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “name” : “张三” }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “name” : “王志刚”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “name” : “赵薇”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “name” : “haha”, “age” : 80 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “name” : “xixi”, “age” : 20 }
MongoDB Enterprise > db.student.find({},{name: 1,age :1,_id:0})
{ “name” : “张三” }
{ “name” : “张三” }
{ “name” : “张三” }
{ “name” : “李四”, “age” : 18 }
{ “name” : “王志刚”, “age” : 40 }
{ “name” : “赵薇”, “age” : 20 }
{ “name” : “haha”, “age” : 80 }
{ “name” : “xixi”, “age” : 20 }
7、排序：
升序：
MongoDB Enterprise > db.student.find().sort({age: 1})
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
降序：
MongoDB Enterprise > db.student.find().sort({age:-1})
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 102, “name” : “张三”, “gender” : “男” }
8、limit()
MongoDB Enterprise > db.student.find().limit(5)
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
MongoDB Enterprise > db.student.find().sort({age:-1}).limit(3)
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
MongoDB Enterprise > db.student.find({},{name:1,age:1}).sort({age:-1}).limit(3)
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “name” : “haha”, “age” : 80 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “name” : “王志刚”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “name” : “赵薇”, “age” : 20 }
9、skip()
查询4条以后的数据
MongoDB Enterprise > db.student.find().skip(4)
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }
查询第5条和第六条的记录
MongoDB Enterprise > db.student.find().skip(4).limit(2)
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa7”), “id” : 105, “name” : “王志刚”, “gender” : “男”, “age” : 40 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }

10、count()统计
MongoDB Enterprise > db.student.find({age:{ $KaTeX parse error: Expected 'EOF', got '}' at position 7: lte:40}̲}) { "_id" : Ob…$ lte:40}}).count()
4

11、多维字段查询：db.表.find({ ‘key’ :值})
MongoDB Enterprise > db.student.find({“address.province”:“上海”})
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }

12、数组条件限制：db.表.find({字段(数组):val}) //数组元素值，有val即可，存在一个元素
MongoDB Enterprise > db.student.find({hobby:“dance”})
db.表.find({字段(数组):{ ‘ $KaTeX parse error: Expected 'EOF', got '}' at position 14: all’ :[v1,v2]}̲}) //数组元素值，存在v1\dots$ all:[“dance”,“sing”]}})

13、限制查询字段
db.表.find({条件},{字段 :1/0,字段 :1/0})
1:查询此字段
0:排除此字段
#注意，设置字段要么都是0，要么都是1，不能既有0又有1，_id除外，可以任意设置。
MongoDB Enterprise > db.student.find({age:20},{name:1,age:1})
{ “_id” : ObjectId(“599198025aa1de0dfdd680b5”), “name” : “钱七”, “age” : 20 }
{ “_id” : ObjectId(“599199e55aa1de0dfdd680b7”), “name” : “侯九”, “age” : 20 }

14、其他查询
$i n 查询包含的值，$ nin不包含操作
这个与 $i n 相反，查询不包含某一字段的记录这个与$ all不一样，查询的值在 $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotsent.find({age:{$ in:[20,21,22,23]}},
{name:1,age:1,_id:0})
{ “name” : “赵六”, “age” : 21 }
{ “name” : “钱七”, “age” : 20 }
{ “name” : “孙八”, “age” : 21 }
{ “name” : “侯九”, “age” : 20 }
{ “name” : “熊十”, “age” : 21 }

$e x i s t s 判断字段是否存在可以用$ exists判断某一字段是否存在
查询存在age字段的记录
MongoDB Enterprise > db.student.find({age:{ $KaTeX parse error: Expected 'EOF', got '}' at position 12: exists:true}̲}) 查询不存在age字段的记\dots$ exists:false}})
MongoDB Enterprise > db.student.find({address:{$exists:true}})
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }

$KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotsent.find({age:{$ mod:[5,3]}})
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }

$KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotsent.find({age:{$ ne:40}})
{ “_id” : ObjectId(“5f1f8bdc5d060a82f1c43fa3”), “id” : 101, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c2e5d060a82f1c43fa4”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8c6e5d060a82f1c43fa5”), “id” : 102, “name” : “张三”, “gender” : “男” }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa6”), “id” : 104, “name” : “李四”, “age” : 18 }
{ “_id” : ObjectId(“5f1f8d6f5d060a82f1c43fa8”), “id” : 106, “name” : “赵薇”, “gender” : “女”, “age” : 20 }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43fa9”), “id” : 107, “name” : “haha”, “age” : 80, “address” : { “province” : “上海”, “city” : “haha” } }
{ “_id” : ObjectId(“5f1f8f2d5d060a82f1c43faa”), “id” : 108, “name” : “xixi”, “age” : 20, “address” : { “province” : “xixi”, “city” : “xixi” } }

$KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotst.find({hobby:{$ size:2}})

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

db.表.update({条件},{' $KaTeX parse error: Expected 'EOF', got '}' at position 18: \dotst' :{字段:值,字段:值}}̲) db.表.update({\dots$ set的修改：只修改设置的字段，其他字段不变
没有 $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotsender:"男",age:{$ lte:80}},{ $KaTeX parse error: Expected 'EOF', got '}' at position 14: inc:{"age":1}}̲) WriteResult({\dots$ lte:80}},{ $KaTeX parse error: Expected 'EOF', got '}' at position 14: inc:{"age":1}}̲,{multi:true}) \dots$ inc:{age:1}},{multi:true})
WriteResult({ “nMatched” : 6, “nUpserted” : 0, “nModified” : 6 }

$KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotse({name:"li"},{$ push:{hobby:‘sing’}})
$KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots{name:"peng"},{$ push:{hobby:{ $KaTeX parse error: Expected 'EOF', got '}' at position 26: \dotsg','baskeball']}̲}}) wang增加爱好，跑步\dots$ addToSet:{“hobby”:{$each:[‘run’,‘sing’]}}})
WriteResult({ “nMatched” : 1, “nUpserted” : 0, “nModified” : 1 })

6、删除数据
删除记录：db.表.remove(条件)
MongoDB Enterprise > db.student.remove({name:“赵薇”})
删除字段: db.表update({条件},{ ‘ $KaTeX parse error: Expected 'EOF', got '}' at position 20: \dotst’ :{字段:1/字段:0}}̲) MongoDB Enter\dots$ unset:{age:1}})
删除小李兴趣数组中的第一项（头元素）
MongoDB Enterprise > db.class.update({name:“li”},{ $KaTeX parse error: Expected 'EOF', got '}' at position 15: pop:{hobby:-1}}̲) WriteResult({\dots$ pull:{hobby:‘sing’}})
WriteResult({ “nMatched” : 1, “nUpserted” : 0, “nModified” : 1 })

7.分组
增加分数域 score:{‘chinese’:88,‘english’:78,‘math’:98}
MongoDB Enterprise > db.class.update({name:“yun”},{$set:{score:{chinese:77,english:90,math:90}}})
WriteResult({ “nMatched” : 1, “nUpserted” : 0, “nModified” : 1 })

按照性别分组统计每组人数
MongoDB Enterprise > db.class.aggregate([{ $KaTeX parse error: Expected '}', got 'EOF' at end of input: group: {_id: "$ sex", num: {$sum: 1}}}])
{ “_id” : “w”, “num” : 2 }
{ “_id” : “m”, “num” : 3 }
{ “_id” : null, “num” : 1 }
按照姓名分组，过滤出有重名的同学
MongoDB Enterprise > db.class.aggregate([{ $KaTeX parse error: Expected '}', got 'EOF' at end of input: group: {_id: "$ name", num: { $KaTeX parse error: Expected 'EOF', got '}' at position 7: sum: 1}̲}},{$ match:{num:{$gt:1}}}])
统计每名男生的语文成绩
MongoDB Enterprise > db.class.aggregate([{ $KaTeX parse error: Expected 'EOF', got '}' at position 16: match:{sex:"m"}}̲,{$ group: {_id: “ $KaTeX parse error: Expected '}', got 'EOF' at end of input: name", score: {$ sum: { $s u m : ["$ score.chinese”]}}}}])
{ “_id” : “tian”, “score” : 77 }
{ “_id” : “yun”, “score” : 77 }
{ “_id” : “wang”, “score” : 77 }
将女生按照英语分数降序排列
MongoDB Enterprise > db.class.aggregate([{ $KaTeX parse error: Expected 'EOF', got '}' at position 18: \dotstch: {sex: "w"}}̲,{$ group: {_id: “ $KaTeX parse error: Expected '}', got 'EOF' at end of input: name", score: {$ sum: { $s u m : ["$ score.english”]}}}},{$sort: {score: -1}}])
{ “_id” : “sun”, “score” : 90 }
{ “_id” : “peng”, “score” : 66 }

骑着蜗牛追汤圆

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
【Nosql数据库--更新中】

文章目录一、NOSQL简介1.RDBMS与Nosql的比较2.NoSQL 数据库分类：键值数据库、列族数据库、文档数据库和图形数据库.二、reids安装1.rpm包安装三、redis配置文件:redis.conf一、NOSQL简介NoSQL，指的是非关系型的数据库。NoSQL用于超大规模数据的存储。1.RDBMS与Nosql的比较RDBMS高度组织化结构化数据结构化查询语言（SQL）数据和关系都存储在单独的表中。数据操纵语言，数据定义语言严格的一致性基础事务NoSQL代表着不仅
复制链接

扫一扫