2020-12-17 20:00 已编辑华南理工大学广州学院测试工程师

关注

数据库存储计算集群管理

一、命令行管理控制台：

资源管理节点 sdbcm（SequoiaDB Cluster Manager）是一个守护进程，它是以服务的方式常驻系统后台。SequoiaDB 的所有集群管理操作都必须有 sdbcm 的参与，目前每一台物理机器上只能启动一个 sdbcm 进程，负责执行远程的集群管理命令和监控本地的 SequoiaDB 数据库。sdbcm 主要有两大功能：

远程启动，关闭，创建和修改节点：通过 SequoiaDB 客户端或者驱动连接数据库时，可以执行启动，关闭，创建和修改节点的操作，该操作向指定节点物理机器上的 sdbcm 发送远程命令，并得到 sdbcm 的执行结果。
本地监控：对于通过 sdbcm 启动的节点，都会维护一张节点列表，其中保存了所有本地节点的服务名和启动信息，如启动时间、运行状态等。如果某个节点是非正常终止的，如进程被强制终止，引擎异常退出等，sdbcm 会尝试重启该节点。
1）停止sdbcm；
```
sdbcmtop
```
2）启动sdbcm；
```
sdbcmart
```
启停集群和节点

sdbcm 服务启动后会自动启动该物理机中所有注册在 /opt/sequoiadb/conf/local 目录下的节点。使用命令 ps -elf | grep sequoiadb 或者 sdblist -t all 能看到当前正在启动的节点与启动完毕的节点。

1）停止集群；

sdbstop --all

2）启动集群；

sdbstart -t all

3）停止节点；

sdbstop -p 11820

4）启动节点；

sdbstart -p 11820

在 SequoiaDB Shell 中启停数据组

除了在 Linux 命令行中进行节点管理， SequoiaDB Shell 交互界面同样也支持管理节点；
1）在 Linux 命令行中进入 SequoiaDB Shell 交互式界面；

sdb

2）使用 JavaScript 连接协调节点，并获取数据库连接；

var db = new Sdb("localhost", 11810);

3）停止数据组；

db.stopRG("group1", "group2");

4）启动数据组；

db.startRG("group1", "group2");

二、快速创建集群

运行安装脚本；

./setup.sh

此脚本有三个可选参数：
--sdb 安装 SequoiaDB 数据库引擎
--pg 安装 SequoiaSQL-PostgreSQL 实例
--mysql 安装 SequoiaSQL-MySQL 实例
若不加任何参数则根据程序的提示选择安装的内容

检查软件服务状态

安装完毕后对安装的 SequoiaDB 巨杉数据库和 SequoiaSQL-MySQL 实例服务和版本进行检查。

1）系统提示“sdbcm is running”表示服务正在运行；

service sdbcm status

2）确认系统提示“sequoiasql-mysql”服务正在运行；

service sequoiasql-mysql status

3）切换为 SequoiaDB 安装用户；

su - sdbadmin

用户 sdbadmin 的密码为 sdbadmin。

4）检查sdb版本；

sequoiadb --version

快速部署数据库实例

SequoiaDB 巨杉数据库提供快速部署脚本 quickDeploy.sh，能够让用户快速安装数据库存储引擎和 SQL 实例。
通过 quickDeploy.sh 脚本快速部署数据库实例
1）进入 SequoiaDB 巨杉数据库所在目录；

cd /opt/sequoiadb/

2）执行快速部署脚本；

./tools/deploy/quickDeploy.sh --sdb  --mysql

验证部署

在 SequoiaSQL-MySQL 实例中创建的表将会默认使用 SequoiaDB 数据库存储引擎；包含主键或唯一键的表将会默认以唯一键作为分区键，进行自动分区。

在 MySQL 实例中创建表，进行数据操作

1）登录 MySQL Shell；

/opt/sequoiasql/mysql/bin/mysql -h 127.0.0.1 -P 3306 -u root

2）创建数据库；

CREATE DATABASE company;
USE company;

3）创建包含自增主键字段的 employee 表；

CREATE TABLE employee 
( 
empno INT AUTO_INCREMENT PRIMARY KEY, 
ename VARCHAR(128), 
age INT 
);

4）向 employee 表写入数据；

INSERT INTO employee ( ename, age ) VALUES ( "Jacky", 36 );
INSERT INTO employee ( ename, age ) VALUES ( "Alice", 18 );

5）查询 employee 表的数据；

SELECT * FROM employee;

6）退出 MySQL Shell；

\q

在数据引擎查询数据

1）在 Linux 命令行中进入 SequoiaDB Shell 交互式界面；

sdb

2）使用 JavaScript 连接协调节点，并获取数据库连接；

var db = new Sdb("localhost", 11810);

3）使用 find() 方法从集合中查询数据记录；

db.company.employee.find( { ename: "Jacky" } );

4）关闭数据库 db 连接；

db.close();

5）退出 SequoiaDB Shell；

quit;

二、手工创建集群

检查数据库配置服务状态

1）系统提示“sdbcm is running”表示服务正在运行；

service sdbcm status

2）切换为 SequoiaDB 安装用户；

su - sdbadmin

用户 sdbadmin 的密码为 sdbadmin。

3）查看 SequoiaDB 巨杉数据库引擎版本；

sequoiadb --version

三、手工创建集群

创建临时协调节点

该节点只是为了创建其它节点而临时使用，安装完毕后需要删除该节点。

1）在 Linux 命令行中进入 SequoiaDB Shell 交互式界面；

sdb

2）连接到本地的集群管理服务进程 sdbcm；

var oma = new Oma("localhost", 11790);

3）创建临时协调节点；

oma.createCoord(18800, "/opt/sequoiadb/database/coord/18800");

4）启动临时协调节点；

oma.startNode(18800);

创建编目节点

通过命令配置和启动编目节点，编目节点为一种逻辑节点，其中保存了数据库的元数据信息，而不保存其他用户数据。
1）连接到临时协调节点，在 shell 命令中输入；

var db = new Sdb("localhost", 18800);

2）创建一个编目节点组；

db.createCataRG("sdbserver1", 11800, "/opt/sequoiadb/database/cata/11800");

创建数据节点

由于创建的集群为 3 分区单副本，需要创建 3 个数据节点分别是 group1 、group2 和 group3 。

1）创建数据节点组；

var dataRG1 = db.createRG("group1");
var dataRG2 = db.createRG("group2");
var dataRG3 = db.createRG("group3");

2）添加数据节点；

dataRG1.createNode("sdbserver1", 11820, "/opt/sequoiadb/database/data/11820", { "logfilenum": 5 } );
dataRG2.createNode("sdbserver1", 11830, "/opt/sequoiadb/database/data/11830", { "logfilenum": 5 } );
dataRG3.createNode("sdbserver1", 11840, "/opt/sequoiadb/database/data/11840", { "logfilenum": 5 } );

createNode() 方法的定义格式有四个参数：host，service，dbpath，config，如上表所示，host，dbpath 为字符串类型，Service 类型支持 int 或 string ，必填；最后一个是 Json 对象，选填，如配置日志大小，是否打开事务等，具体可参考数据库配置。
格式：( "<主机名>", "<端口号>", "<节点路径>, "[ {key : value, ... } ] )
createNode 方法的详细说明请参考：createNode 方法说明。

3）启动数据节点组；

dataRG1.start();
dataRG2.start();
dataRG3.start();

创建协调节点

1）创建协调节点组；

var rg = db.createCoordRG();

2）创建协调节点；

rg.createNode("sdbserver1", 11810, "/opt/sequoiadb/database/coord/11810", { "logfilenum":5 } );

3）启动协调节点；

rg.start();

删除临时协调节点，完成部署

1）删除临时协调节点；

oma.removeCoord(18800);

2）退出 SequoiaDB Shell；

quit;

3）检查集群节点状态；

sdblist -l -m local

四、安装目录详解

PostgreSQL 实例安装目录

SequoiaSQL-PostgreSQL 实例默认安装目录为 /opt/sequoiasql/postgresql，下面我们以数据节点目录进行说明。

1）对 PostgreSQL 实例的安装目录进行查看；

ls /opt/sequoiasql/postgresql/

2）部分重要目录说明；

PostgreSQL 实例的安装路径是/opt/sequoiasql/postgresql/
bin 子目录下是关于postgresql的可执行文件
share 子目录下是一些常用的SQL文件
conf 子目录下是一些配置信息，例如conf/instance/myinst.conf里面记录了PGDATA和PGLOG的存放路径

五、存储引擎上的数据操作

1、查看节点启动列表

2、域、集合空间与集合的操作

1）通过 Linux 命令行进入 SequoiaDB Shell；

sdb

2）通过 javascript 语言连接协调节点，获取数据库连接；

var db = new Sdb("localhost", 11810);

3）创建 company_domain 逻辑域；

db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );

4）创建 company 集合空间；

db.createCS("company", { Domain: "company_domain" } );

5）创建 employee 集合；

db.company.createCL("employee", { "ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false } );

创建 employee 集合的命令包含了分区键、分区方式、写方式同步副本、压缩类型等参数，详细了解创建集合时可以指定的参数请参考：
创建集合说明

Note:

集合（Collection）是数据库中存放文档的逻辑对象，类似于关系型数据库中的表。任何一条文档必须属于且仅属于一个集合。
集合空间（CollectionSpace）是数据库中存放集合的物理对象，类似于关系型数据库中的表空间。任何一个集合必须属于且仅属于一个集合空间。
域（Domain）是由若干个复制组（ReplicaGroup）组成的逻辑单元。每个域都可以根据定义好的策略自动管理所属数据，如数据切片和数据隔离等。
6）删除集合；

db.company.dropCL("employee");

7）删除集合空间；

db.dropCS("company");

8）删除逻辑域；

db.dropDomain("company_domain");

Note:

删除域前必须保证域中不存在任何数据。

9）为了后续操作，现把域、集合空间和集合重建；

db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );
db.createCS("company", { Domain: "company_domain" } );
db.company.createCL("employee", { "ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false } );

3、集合数据操作

通过 SequoiaDB Shell 操作集合中数据。

集合中插入数据

在 JSON 实例集合 company 中插入数据。

db.company.employee.insert( { empno: 1, ename: "Jacky", age: 28, department: 'Sales Department' } );
db.company.employee.insert( { empno: 2, ename: "Abe", age: 36, department: 'Sales Department' } );
db.company.employee.insert( { empno: 3, ename: "Alice", age: 23, department: 'Personnel Department ' } );
db.company.employee.insert( { empno: 4, ename: "Jane", age: 25, department: 'Personnel Department ' } );

查询集合中的数据

查询集合 employees 中age 大于 20，小于 30 的数据。

db.company.employee.find( { "age": { "$gt": 20, "$lt": 30 } } );

更新集合中的数据

1）更新JSON 实例集合 employee 中的数据，将 empno 为 1 的记录 age 更改为 29 ；

db.company.employee.update( { "$set": { "age": 29 } }, { "empno": 1 } );

2）查询数据结果确认 empno 为1的记录更新是否成功；

db.company.employee.find( { "empno": 1 } );

删除集合中的数据

1）删除集合 employee 中的数据，将 empno 为 2 的记录删除；

db.company.employee.remove( { "empno": 2 } );

2）查询数据结果确认 empno 为 2 的记录是否成功删除；

db.company.employee.find();

聚集操作

1）统计集合 employee 中不同部门的平均年龄；

db.company.employee.aggregate( { "$group": { "_id": "$department", "avg_age": { "$avg": "$age" }, "department": "$department" } } );

aggregate ( ) 方法的详细说明请参考：官网文档

4、索引使用

1）在集合 employee 的 ename 字段上创建索引；

db.company.employee.createIndex("idx_ename", { ename: 1 }, false);

2）查看集合 employee 上创建的索引；

db.company.employee.listIndexes();

Note:
在 SequoiaDB 中，所有集合均包含一个名为“$id”的强制唯一索引。该索引包含一个“_id”字段的索引键。
3）显示集合 employees 查询语句执行计划；

db.company.employee.find( { "ename": "Georgi" } ).explain ();

5、退出 SequoiaDB Shell

1）关闭 db 数据库连接；

db.close();

2）退出 SequoiaDB Shell；

quit;

六、数据库事务管理

本课程介绍了如何管理巨杉数据库的事务，并对事务隔离级别进行了验证。当前实验环境部署的 SequoiaDB 巨杉数据库版本为 3.4 支持 RU（读未提交）、RC（读已提交）和 RS（读稳定性）三种事务隔离级别，最近发布的 5.0 版本通过 MVCC（多版本并发控制）实现了 RR（可重复读）。

环境架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，其中包括 1 个引擎协调节点，1 个编目节点与 3 个数据节点。
创建域、集合空间、集合
1）通过 Linux 命令行进入 SequoiaDB Shell；

sdb

2）通过 javascript 语言连接协调节点，获取数据库连接，表示sessionA；

var db = new Sdb("localhost", 11810);

3）创建 company_domain 逻辑域；

db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );

4）创建 company 集合空间；

db.createCS("company", { Domain: "company_domain" } );

5）创建 employee 集合

db.company.createCL("employee", { "ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false } );

2、巨杉数据库存储引擎事务操作

除了可以在 SequoiaSQL-MySQL 数据库实例中进行事务控制外，SequoiaDB 巨杉数据库存储引擎也支持完整的事务功能：
SequoiaDB 巨杉数据库事务说明
事务提交操作
1）开始事务；

db.transBegin();

2）写入数据；

db.company.employee.insert( { empno: 1, ename: "Jacky", age: 28 } );

3）提交事务；

db.transCommit();

4）查询写入数据；

db.company.employee.find( { empno: 1 } );

事务回滚操作
除了可以在 SequoiaSQL-MySQL 数据库实例中进行事务控制外，SequoiaDB 巨杉数据库存储引擎也支持完整的事务功能：
1）开始事务；

db.transBegin();

2）写入数据；

db.company.employee.insert( { empno: 2, ename: "Alice", age: 23 } );

3）查询写入数据；

db.company.employee.find( { empno: 2 } );

4）回滚事务；

db.transRollback();

5）再次查询写入数据；

db.company.employee.find( { empno: 2 } );

查询返回0条记录，说明 empno 为 2 的记录已经回滚。

3、事务的隔离级别

查询节点配置快照

查询集群当前节点是否开启事务以及隔离级别。

db.snapshot(SDB_SNAP_CONFIGS, {}, { NodeName: "", transisolation: "", transactionon: "" } );

transisolation 参数为事务隔离级别，默认是 0 。取值列表：

- 0: RU，读未提交。
- 1: RC， 读已提交。
- 2: RS，读稳定性。

4、验证 RU 读未提交

1）“终端1”中开始事务；

db.transBegin();

2）“终端1”中写入数据；

db.company.employee.insert( { empno: 3, ename: "Jane", age: 25 } );

3）右键选择 Open Terminal 新开终端，此终端为“终端2”；

4）“终端2”中切换系统用户为 sdbadmin ；

su - sdbadmin

用户 sdbadmin 的密码为 sdbadmin
5）“终端2”在 Linux 命令行中进入 SequoiaDB Shell 交互式界面；

sdb

6）“终端2”使用 JavaScript 连接协调节点，并获取数据库连接，表示sessionB；

var db = new Sdb("localhost", 11810);

7）“终端2”中开始事务；

db.transBegin();

8）“终端2”中查询数据；

db.company.employee.find();

可以看到，即使 sessionA 未进行提交，sessionB 依然可以看到 sessionA 写入的数据；

9）“终端1”中回滚事务；

db.transRollback();

10）“终端2”中查询数据；

db.company.employee.find();

此时事务 sessionB 回滚的数据已经无法查询。
11）“终端2”中关闭当前事务；

db.transRollback();

以上验证了当事务隔离级别设置为读未提交时，事务 B 可以看到事务 A 未提交的数据。

5、验证RC读已提交

1）“终端1”设置事务隔离级别为1，1代表读已提交；

db.updateConf( { transisolation: 1 }, { Global: true } );

transisolation参数指定隔离级别，为在线生效。
Global为true表示对所有节点生效。
关于更多参数说明，请参考如下链接：数据库配置-参数说明
2）“终端1”中开始事务；

db.transBegin();

3）“终端1”中写入数据；

db.company.employee.insert( { empno: 3, ename: "Jane", age: 25 } );

4）“终端2”中开始事务；

db.transBegin();

5）“终端2”中查询数据；

db.company.employee.find();

此时 sessionB 无法看到 sessionA 写入的数据。
6）“终端1”中提交事务；

db.transCommit();

7）“终端2”再次查询数据；

db.company.employee.find();

此时可以看到 sessionA 写入的数据，即只有当事务 A 提交数据后，事务 B 才能看到写入的数据。
8）“终端2”中回滚当前事务；

db.transRollback();

6、验证 RS 读稳定性

此隔离级别下会锁定需要遍历的纪录。不论是读取，还是更新，均会对需要遍历的记录加对应的锁，假设条件能够通过索引区分开来则只会对符合条件的记录加锁。
1）“终端1”设置事务隔离级别为2，2 表示隔离级别为读稳定。

db.updateConf( { transisolation: 2 }, { Global: true } );

2）“终端1”中开始事务；

db.transBegin();

3）“终端1”查询数据；

db.company.employee.find();

4）“终端2”中开始事务；

db.transBegin();

5）“终端2”中更新数据；

db.company.employee.update( { $set: { age: 26 } }, { "ename": "Jane" } );

此时sessionB 中的 update 操作发生锁等待。
6）“终端1”中回滚事务；

db.transRollback();

此时发现sessionB 中的更新成功。说明只有等事务 A 执行 rollback 或者 commit 后，事务 B 才能执行成功。

7、总结

本课程对 SequoiaDB 巨杉数据库的事务进行了配置管理和隔离级别的验证，分别验证了 RU（读未提交）、RC（读已提交）和 RS（读稳定性）三种事务隔离级别。

七、集群扩容和缩容

1、切换用户及查看数据库版本

2、查看节点启动列表

3、创建域、集合空间、集合

1）通过 Linux 命令行进入 SequoiaDB Shell；

sdb

2）通过 javascript 语言连接协调节点，获取数据库连接；

var db = new Sdb("localhost", 11810);

3）创建 company_domain 逻辑域；

db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );

4）创建 company 集合空间；

db.createCS("company", { Domain: "company_domain" } );

5）创建 employee 集合；

db.company.createCL("employee", { "ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false } );

4、写入测试数据

本小节使用 JavaScript 的 for 循环向 employee 表写入 1000 条记录，用于测试。

for (var i = 0; i < 1000; i++) 
{ 
db.company.employee.insert( { ename: "TEST", age: 20 } ); 
}

5、集群扩容

集群扩容是通过在集群中新增分区组实现的，新增分区组可以在原有服务器也可以是新加入集群的服务器，本小节通过在本机新增 group4 展示扩容的场景。

1）创建一个新的数据组；

db.createRG("group4");

2）在 group4 上创建1个数据节点副本；

db.getRG("group4").createNode("sdbserver1", 11850, "/opt/sequoiadb/database/data/11850/");

Note:

createNode() 方法的定义格式有四个参数：host，service，dbpath，config，如上表所示，host，dbpath 为字符串类型，Service 类型支持 int 或 string ，必填；最后一个是 Json 对象，选填，如配置日志大小，是否打开事务等，具体可参考数据库配置。
请在这里输入引用内容
格式：( "<主机名>", "<端口号>", "<节点路径>, "[ {key : value, ... } ] )
请在这里输入引用内容
createNode 方法的详细说明请参考：createNode 方法说明。

3）启动 group4 数据组；

db.getRG("group4").start();

数据域 company_domain 增加数据组；

db.getDomain("company_domain").addGroups( { Groups: [ 'group4' ] } );

将集合的数据迁移部分到新的数据组上；

db.company.employee.split("group1", "group4", 25);
db.company.employee.split("group2", "group4", 25);
db.company.employee.split("group3", "group4", 25);

Note:

以上split的含义时是把 group1、group2 和 group3 上的数据分别移25%到 group4 上。 split 方法的详细说明请参考：split 方法说明。

分析数据分布

1）连接第一个数据分区的存储节点；

var db1 = new Sdb("localhost", 11820);

2）统计第一个数据分区的数据量；

db1.company.employee.count();

3）连接第二个数据分区的存储节点；

var db2 = new Sdb("localhost", 11830);

4）统计第二个数据分区的数据量；

db2.company.employee.count();

5）连接第三个数据分区的存储节点；

var db3 = new Sdb("localhost", 11840);

6）统计第三个数据分区的数据量；

db3.company.employee.count();

5）连接第四个数据分区的存储节点；

var db4 = new Sdb("localhost", 11850);

6）统计第四个数据分区的数据量；

db4.company.employee.count();

可以看到，四个数据组上的记录数基本为平均分布。

6、集群缩容

本小节展示把 group4 的数据迁移到其他节点后把其剔出 company_domain 域，并把 group4 删除的操作。

1）将集合1在新数据组上的数据迁移回旧的数据组；

db.company.employee.split("group4", "group1", 33);
db.company.employee.split("group4", "group2", 50);
db.company.employee.split("group4", "group3", 100);

2）统计 group1，group2，group3 数据量，它们加起来等于 1000 ；

db1.company.employee.count();

db2.company.employee.count();

db3.company.employee.count();

3）把 group4 移出 company_domain 域；

db.getDomain("company_domain").removeGroups( { Groups: [ 'group4' ] } );

4）删除上一章新增加的数据组和数据节点；

db.removeRG("group4");

5）统计 employee 的数据量；

db.company.employee.count();

数据量为1000，说明数据被正确迁移回来了。

关闭数据库连接

1）关闭 db、db1、db2、db3、db4 数据库连接；

db.close();
db1.close();
db2.close();
db3.close();
db4.close();

2）退出 SequoiaDB Shell；

quit;

检查集群状态是否正常；

sdblist -l -m local

可以看到，group4 已经从集群中剔除。

7、总结

本课程简单介绍了如何完成巨杉数据库集群的扩容和缩容操作。在使用 split 方法对数据进行迁移时，如果一条命令迁移的数据量太大，对系统的性能是有影响的，要将影响程度降到最低，建议对数据进行分批迁移。例如：对一张大表通过一条命令迁移 50% 的数据，可分为 5 条命令，每次迁移总数据量的 10% 。

八、快照监控

快照是一种得到系统当前状态的命令，主要分为以下类型：

1、快照类型

快照标示快照类型

SDB_SNAP_CONTEXTS    上下文快照
SDB_SNAP_CONTEXTS_CURRENT    当前会话上下文快照
SDB_SNAP_SESSIONS    会话快照
SDB_SNAP_SESSIONS_CURRENT    当前会话快照
SDB_SNAP_COLLECTIONS    集合快照
SDB_SNAP_COLLECTIONSPACES    集合空间快照
SDB_SNAP_DATABASE    数据库快照
SDB_SNAP_SYSTEM    系统快照
SDB_SNAP_CATALOG    编目信息快照
SDB_SNAP_TRANSACTIONS    事务快照
SDB_SNAP_TRANSACTIONS_CURRENT    当前事务快照
SDB_SNAP_ACCESSPLANS    访问计划缓存快照
SDB_SNAP_HEALTH    节点健康检测快照
SDB_SNAP_CONFIGS    配置快照
SDB_SNAP_SVCTASKS    服务任务快照
SDB_SNAP_SEQUENCES    序列快照

详细了解 SequoiaDB 巨杉数据库快照类型：

SequoiaDB 快照类型

1）在 Linux 命令行中进入 SequoiaDB Shell 交互式界面；

sdb

2）使用 JavaScript 连接协调节点，并获取数据库连接；

var db = new Sdb("localhost", 11810);

3）创建集合空间与集合；

db.createCS("company").createCL("employee");

4）上下文快照列出当前数据库节点中所有的会话所对应的上下文；

db.snapshot(SDB_SNAP_CONTEXTS);

5）当前上下文快照列出当前数据库节点中当前会话所对应的上下文；

db.snapshot(SDB_SNAP_CONTEXTS_CURRENT);

6）会话快照列出当前数据库节点中所有的会话；

db.snapshot(SDB_SNAP_SESSIONS);

7）当前会话快照列出当前数据库节点中当前的会话；

db.snapshot(SDB_SNAP_SESSIONS_CURRENT);

8）集合快照列出当前数据库节点或集群中所有非临时集合；

db.snapshot(SDB_SNAP_COLLECTIONS);

9）集合空间快照列出当前数据库节点或集群中所有集合空间（编目集合空间除外）；

db.snapshot(SDB_SNAP_COLLECTIONSPACES);

10）数据库快照列出当前数据库节点的数据库监视信息；

db.snapshot(SDB_SNAP_DATABASE);

11）系统快照列出当前数据库节点的系统监视信息；

db.snapshot(SDB_SNAP_SYSTEM);

12）编目信息快照用于查看编目信息；

db.snapshot(SDB_SNAP_CATALOG);

13）事务快照列出数据库中正在进行的事务信息；

db.snapshot(SDB_SNAP_TRANSACTIONS);

14）当前事务快照列出当前会话正在进行的事务信息；

db.snapshot(SDB_SNAP_TRANSACTIONS_CURRENT);

15）访问计划缓存快照列出数据库中缓存的访问计划的信息；

db.snapshot(SDB_SNAP_ACCESSPLANS);

16）节点健康检测快照列出数据库中所有节点的健康信息；

db.snapshot(SDB_SNAP_HEALTH);

17）配置快照列出数据库中指定节点的配置信息；

db.snapshot(SDB_SNAP_CONFIGS);

18）服务任务快照列出当前数据库节点中服务任务的统计信息；

db.snapshot(SDB_SNAP_SVCTASKS);

19）序列快照列出当前数据库的全部序列信息；

db.snapshot(SDB_SNAP_SEQUENCES);

20）退出；

quit;

2、脚本准备

使用以下脚本模拟应用发起服务，用于观察集群情况。

1）切换至sdbadmin用户目录；

2）复制以下代码到实验环境终端执行，生成数据查询脚本 query.sh；

cat > query.sh <<EOF
#!/bin/bash
sdb 'var i=1;'
sdb 'var db=new Sdb("localhost", 11810);'
sdb 'while(true){
       db.company.employee.insert( { "empno": i, "ename": "Test", "age": 20 } );
       db.company.employee.count();
       i=i+1;
    }'
sdb 'db.close();'
EOF

3）后台运行 query.sh 脚本；

nohup sh query.sh > /home/sdbadmin/out.log 2 >&1 &

3、sdbtop监控使用示例

九、备份恢复

1、切换用户及查看数据库版本

2、查看节点启动列表

3、准备测试数据

1）通过 Linux 命令行进入 SequoiaDB Shell；

sdb

2）通过 javascript 语言连接协调节点，获取数据库连接；

var db = new Sdb("localhost", 11810);

3）创建 company_domain 逻辑域；

db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );

4）创建 company 集合空间；

db.createCS("company", { Domain: "company_domain" } );

5）创建 employee 集合；

db.company.createCL("employee", { "ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false } );

6）写入测试数据。使用 javascript 的 for 循环向 employee 表写入1000条记录；

for (var i = 0; i < 1000; i++) 
{ 
db.company.employee.insert( { empno: i, ename: "TEST", age: 20 } );
}

4、全量备份与增量备份

当前版本中，数据库备份支持全量备份和增量备份。全量备份过程中会阻塞数据库变更操作，即数据插入、更新、删除等变更操作会被阻塞直到全量备份完成才会执行；增量备份过程中不阻塞数据库变更操作。
请在这里输入引用内容

全量备份：备份整个数据库的配置、数据和日志（可选）；
请在这里输入引用内容
增量备份：在上一个全量备份或增量备份的基础上备份新增的日志和配置；增量备份需要保证日志的连续性和一致性，如果日志不连续，或日志 Hash 校验不一致，则增量备份失败。因此，周期性的增量备份需要计算好日志和周期的关系，以防止日志覆写。

在协调节点上对整个数据库或指定组进行备份，默认是只在该数据组主节点上进行备份。Catalog 编目组的名称固定为 SYSCatalogGroup。

使用 Sdb.backup() 命令可以进行备份。具体参数说明参考
请在这里输入引用内容

数据备份

全量备份

1）执行集群全量备份命令

db.backup( { Name: "cluster_backup", Path: "/tmp/%g", Overwrite: true, Description: "full backup" } );

Path 中的 “%g”是一个通配符代表group name，当在协调节点上执行命令使用该参数时，需要使用通配符，以避免所有的节点往同一个路径下进行操作而导致未知IO错误。

2）退出 SequoiaDB Shell；

quit;

3）检查备份文件是否生成；

ls /tmp
ls /tmp/group1/
ls /tmp/group2/
ls /tmp/group3/

可以看到，在/tmp目录下有 4 个文件夹，SYSCatalogGroup，group1，group2 和 group3 ，分别对应编目节点组，数据组 1 ，数据组 2，数据组 3。

增量备份

1）通过 Linux 命令行进入 SequoiaDB Shell；

sdb

2）通过 javascript 语言连接协调节点，获取数据库连接；

var db = new Sdb("localhost", 11810);

3)写入 500 条增量数据；

for (var i = 1000; i < 1500; i++) 
{ 
db.company.employee.insert( { empno: i, ename: "TEST", age: 20 } );
}

4）执行增量备份；

db.backup( { Name: "cluster_backup", Path: "/tmp/%g", EnsureInc: true } );

5）查看备份信息；

db.listBackup( { Path: "/tmp" } );

6）退出 SequoiaDB Shell；

quit;

7）检查备份文件是否生成；

ls /tmp/group1/
ls /tmp/group2/
ls /tmp/group3/

增量备份的备份名应和上一次全量备份保持一致。
可以看到，相比于第一次备份生成的文件，本次增量备份在 group1 ，group2 和 group3 目录下新生成了两个文件。

5、全量恢复与增量恢复

使用备份的数据恢复当前集群中的节点或者恢复到离线数据的说明：

恢复当前集群中的节点：执行数据恢复必须确保该节点对应的数据组已停止运行，数据恢复首先会清空原节点的所有数据和日志，然后从备份的数据中恢复配置、数据和日志。
恢复到离线数据：可以将全量备份和增量备份的数据不断合并成一份与节点内数据完全相同格式的离线数据，可以在原节点故障后使用该离线数据实现快速恢复。
请在这里输入引用内容
如果一个分区组包含多个数据节点，必须停止该组中每个数据节点并进行恢复。如果将备份的数据恢复至非备份数据节点，添加 --isSelf 参数并设置成 false，同时设置相关的配置参数。

恢复分区组其他节点数据，恢复方式有以下几种：

1）删除该分区组中其它数据节点的所有 .data 和 .idx 、.lobd、.lobm 文件以及 replicalog 日志，节点启动后会自行同步数据。

2）拷贝恢复节点的所有 .data 和 .idx 、.lobd、.lobm文件拷贝至其它数据节点的数据目录和索引目录下，以及将该节点的所有 replicalog 日志拷贝至其它数据节点的 replicalog 日志目录下。

3）将备份文件拷贝至其它数据节点，并通过 sdbrestore 工具恢复。

使用 sdbrestore 可以进行数据恢复，具体参数说明参考下面这个链接：http://doc.sequoiadb.com/cn/sequoiadb-cat_id-1432190666-edition_id-0

全量恢复
1）通过 Linux 命令行进入 SequoiaDB Shell；

sdb

2）通过 javascript 语言连接协调节点，获取数据库连接；

var db = new Sdb("localhost", 11810);

3）删除集群上的集合空间；

db.dropCS("company");

4）退出 SequoiaDB Shell；

quit;

5）停止所有节点；

sdbstop -t all

6）执行全量恢复操作；

sdbrestore -p /tmp/SYSCatalogGroup/ -n cluster_backup -b 0 -i 0
sdbrestore -p /tmp/group1/ -n cluster_backup -b 0 -i 0
sdbrestore -p /tmp/group2/ -n cluster_backup -b 0 -i 0
sdbrestore -p /tmp/group3/ -n cluster_backup -b 0 -i 0

-b 后面带的参数代表需要从第几次备份开始恢复，从 0 开始算起，缺省由系统自动计算 ( -1 )。

-i 后面带的参数代表需要恢复到第几次数据备份，从 0 开始算起，缺省恢复到最后一次 ( -1 )。

7）启动节点；

sdbstart -t all

执行全量恢复时要先停节点，恢复完后再启动，为了方便，将整个集群停下来恢复的时候需要按节点恢复，分别是编目节点，数据组1，数据组2，数据组3
9）检查数据是否正确，此时只能查到集合中的第一次插入的数据；

通过 Linux 命令行进入 SequoiaDB Shell；

sdb

通过 javascript 语言连接协调节点，获取数据库连接；

var db = new Sdb("localhost", 11810);

统计 company.employee 数据量；

db.company.employee.count();

操作截图：

全量恢复后检查

退出 SequoiaDB Shell；

quit;

此时只能看到第一次插入的 1000 条记录，第二次插入的 500 条记录看不到。

增量恢复
1）停止所有节点；

sdbstop -t all

2）增量恢复操作；

sdbrestore -p /tmp/group1/ -n cluster_backup -b -1
sdbrestore -p /tmp/group2/ -n cluster_backup -b -1
sdbrestore -p /tmp/group3/ -n cluster_backup -b -1

3）启动节点；