数据库应用开发
一、MySQL/MariaDB 实例应用开发
1. 课程介绍
本课程将带领您在已经部署 SequoiaDB 巨杉数据库引擎及创建了 MySQL 实例的环境中，使用 SQL 语句访问 SequoiaDB 数据库，完成对数据的增、删、查、改操作以及其他 MySQL 语法操作。
请点击右侧选择使用的实验环境
部署架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，其中包括：1 个 SequoiaSQL-MySQL 数据库实例节点、1 个引擎协调节点、1 个编目节点与3个数据节点。
图片描述
详细了解 SequoiaDB 巨杉数据库系统架构：
SequoiaDB 系统架构
实验环境
课程使用的实验环境为 Ubuntu Linux 16.04 64 位版本。SequoiaDB 数据库引擎以及 SequoiaSQL-MySQL 实例均为 3.4 版本。
2. 切换用户及查看数据库版本
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库和 SequoiaSQL-MySQL 实例的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version
3. 查看节点启动列表
1）查看 SequoiaDB 巨杉数据库引擎节点列表；
sdblist
copy
操作截图：
图片描述
Note:
如果显示的节点数量与预期不符，请稍等初始化完成并重试该步骤。
C: 编目节点，S：协调节点，D：数据节点
2）检查 MySQL 实例；
/opt/sequoiasql/mysql/bin/sdb_sql_ctl status
copy
操作截图：
图片描述
4. 创建数据库及数据表
进入 MySQL shell ，连接 SequoiaSQL-MySQL 实例并创建 company 数据库，为接下来验证 MySQL 语法特性做准备。
登录 MySQL 实例 Shell
/opt/sequoiasql/mysql/bin/mysql -h 127.0.0.1 -P 3306 -u root
copy
创建数据库
在MySQL实例中创建新数据库 company，并切换至 company 库；
CREATE DATABASE company;
USE company;
copy
创建分区表
1）在 MySQL 实例 company 数据库中创建分区表 employee：
CREATE TABLE employee
(
empno INT,
ename VARCHAR(128),
age INT,
PRIMARY KEY (empno)
) ENGINE = sequoiadb COMMENT = "雇员表, sequoiadb: { table_options: { ShardingKey: { 'empno': 1 }, ShardingType: 'hash', 'Compressed': true, 'CompressionType': 'lzw', 'AutoSplit': true, 'EnsureShardingIndex': false } } ";
copy
Note:
在 MySQL 上创建表时，可以在其表选项 COMMENT 中通过指定关键词 "sequoiadb" ，并紧跟一 json 对象以传入自定义的表配置参数。
MySQL 实例建表参数配置
2）查看 MySQL 实例分区表结构；
SHOW CREATE TABLE employee;
copy
操作
5. 分区表中数据操作
通过 SequoiaSQL-MySQL 实例进行数据插入、查询、更新、删除操作。
分区表中插入数据
在分区表 employee 中插入数据：
INSERT INTO employee VALUES (10001, 'Georgi', 48);
INSERT INTO employee VALUES (10002, 'Bezalel', 21);
INSERT INTO employee VALUES (10003, 'Parto', 33);
INSERT INTO employee VALUES (10004, 'Chirstian', 40);
INSERT INTO employee VALUES (10005, 'Kyoichi', 23);
INSERT INTO employee VALUES (10006, 'Anneke', 19);
copy
查询分区表中的数据
查询分区表 employee 中 age 大于 20，小于 30 的数据；
SELECT * FROM employee WHERE age > 20 AND age < 30;
copy
操作截图：
图片描述
更新分区表中的数据
1）更新分区表 employee 中的数据，将 empno 为 10001 的记录 age 更改为 34；
UPDATE employee SET age=34 WHERE empno = 10001;
copy
2）查询数据结果确认 empno 为 10001 的记录更新是否成功；
SELECT * FROM employee;
copy
操作截图：
图片描述
删除分区表中的数据
1）删除分区表 employee 中的数据，将 empno 为 10005 的记录删除；
DELETE FROM employee WHERE empno = 10005;
copy
2）查询数据结果确认 empno 为 10005 的记录是否成功删除；
SELECT * FROM employee;
copy
6. 索引使用
通过 SequoiaSQL-MySQL 实例进行表上索引的创建及查看执行计划。
分区表中索引使用
1）在分区表 employee 的 ename 字段上创建索引；
ALTER TABLE employee ADD INDEX idx_ename(ename);
copy
2）显示分区表 employee 查询语句执行计划；
EXPLAIN SELECT * FROM employee WHERE ename = 'Georgi';
copy
3）退出 MySQL 客户端
\q
copy
7. Java 语言操作 MySQL 实例中的数据
本节内容主要用来演示 Java 语言操作 SequoiaSQL-MySQL 实例中的数据，为相关开发人员提供参考。源码已经放置在 /home/sdbadmin/source/mysql 目录下。
1）进入源码放置目录；
cd /home/sdbadmin/source/mysql
copy
2）查看 java 文件，一共5个 java 文件；
ls -trl
copy
Note：
MySQLConnection.java 连接数据库类
Insert.java 写入数据类
Select.java 查询数据类
Update.java 更新数据类
Delete.java 删除数据类
3）首先对连接的 java 文件进行编译；
javac -d . MySQLConnection.java
copy
在 MySQL 实例中插入数据
1）增加 empno 为 20001 、 20002 和 20003 这三条记录，Insert.java 源代码如下；
package com.sequoiadb.mysql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Insert {
private static String url = "jdbc:mysql://127.0.0.1:3306/company?useUnicode=true&charac
terEncoding=utf-8&useSSL=false";
private static String username = "root";
private static String password = "";
public static void main(String[] args) throws SQLException {
insert();
}
public static void insert() throws SQLException {
MySQLConnection mysqlConnection = new MySQLConnection(url, username, password);
Connection connection = mysqlConnection.getConnection();
String sql = "INSERT INTO employee VALUES";
PreparedStatement psmt = connection.prepareStatement("");
StringBuffer sb = new StringBuffer();
sb.append("(").append(20001).append(",").append("'Quincy'").append(",").append(30).append("),");
sb.append("(").append(20002).append(",").append("'Newton'").append(",").append(31).
append("),");
sb.append("(").append(20003).append(",").append("'Dan'").append(",").append(32).app
end("),");
sb.deleteCharAt(sb.length() - 1);
sql = sql + sb.toString();
System.out.println(sql);
psmt.addBatch(sql);
psmt.executeBatch();
connection.close();
}}
copy
2）对 Insert.java 文件进行编译；
javac -d . Insert.java
copy
3）运行 Insert 类的代码可以将数据插入；
java -cp .:../mysql-connector-java-5.1.48.jar com.sequoiadb.mysql.Insert
copy
操作截图：
图片描述
从 MySQL 实例中查询数据
1）查询表中 empno 、 ename 和 age 这三个字段，Select.java 源代码如下；
package com.sequoiadb.mysql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Select {
private static String url = "jdbc:mysql://127.0.0.1:3306/company?useUnicode=true&charac
terEncoding=utf-8&useSSL=false";
private static String username = "root";
private static String password = "";
public static void main(String[] args) throws SQLException {
select();
}
public static void select() throws SQLException {
MySQLConnection mysqlConnection = new MySQLConnection(url, username, password);
Connection connection = mysqlConnection.getConnection();
String sql = "select * from employee";
PreparedStatement psmt = connection.prepareStatement(sql);
ResultSet rs = psmt.executeQuery();
System.out.println("-------------------------------------------");
System.out.println("empno \t ename \t age");
System.out.println("-------------------------------------------");
while(rs.next()){
Integer empno = rs.getInt("empno");
String ename = rs.getString("ename");
String age = rs.getString("age");
System.out.println(empno + "\t" + ename + "\t" + age);
}
connection.close();
}}
copy
2）对 Select.java 文件进行编译；
javac -d . Select.java
copy
3）运行 Select 类的代码；
java -cp .:../mysql-connector-java-5.1.48.jar com.sequoiadb.mysql.Select
copy
操作截图：
图片描述
在 MySQL 实例中更新数据
1）将 empno 为 10001 的 age 修改为 49 ，Update.java 文件源代码如下；
package com.sequoiadb.mysql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Update {
private static String url = "jdbc:mysql://127.0.0.1:3306/company?useUnicode=true&charac
terEncoding=utf-8&useSSL=false";
private static String username = "root";
private static String password = "";
public static void main(String[] args) throws SQLException {
update();
}
public static void update() throws SQLException {
MySQLConnection mysqlConnection = new MySQLConnection(url, username, password);
Connection connection = mysqlConnection.getConnection();
String sql = "update employee set age = ? where empno = ?";
PreparedStatement psmt = connection.prepareStatement(sql);
psmt.setInt(1, 49);
psmt.setInt(2, 10001);
psmt.execute();
connection.close();
}}
copy
2）对 Update.java 文件进行编译；
javac -d . Update.java
copy
3）运行 Update 类代码；
java -cp .:../mysql-connector-java-5.1.48.jar com.sequoiadb.mysql.Update
copy
4）查询确认 empno 为 10001 的记录 age 值是否被更改为 49 ；
java -cp .:../mysql-connector-java-5.1.48.jar com.sequoiadb.mysql.Select
copy
操作截图：
图片描述
在 MySQL 实例中删除数据
1）将 empno 值为 10006 的记录删除， Delete.java 源代码如下；
package com.sequoiadb.mysql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Delete {
private static String url = "jdbc:mysql://127.0.0.1:3306/company?useUnicode=true&charac
terEncoding=utf-8&useSSL=false";
private static String username = "root";
private static String password = "";
public static void main(String[] args) throws SQLException {
delete();
}
public static void delete() throws SQLException {
MySQLConnection mysqlConnection = new MySQLConnection(url, username, password);
Connection connection = mysqlConnection.getConnection();
String sql = "delete from employee where empno = ?";
PreparedStatement psmt = connection.prepareStatement(sql);
psmt.setInt(1, 10006);
psmt.execute();
connection.close();
}}
copy
2）对 Delete.java 文件进行编译；
javac -d . Delete.java
copy
3）运行 Delete 类的代码；
java -cp .:../mysql-connector-java-5.1.48.jar com.sequoiadb.mysql.Delete
copy
4）检查确认 empno 为 10006 的雇员信息已经被删除；
java -cp .:../mysql-connector-java-5.1.48.jar com.sequoiadb.mysql.Select
8. 总结
通过本课程，我们通过 MySQL 语法在 SequoiaSQL-MySQL 实例上创建数据库和数据表，并对数据表进行了 CRUD 的基本数据操作；同时展示了使用 JAVA 语言对数据表进行数据操作。可以看出：
SequoiaSQL-MySQL 实例兼容标准的 MySQL 语法；
应用开发过程中数据操作与原生 MySQL 一致；
二、PostgreSQL 实例应用开发
1. 课程介绍
本课程将带领您在已经部署 SequoiaDB 巨杉数据库引擎及创建了 PostgreSQL 实例的环境中，使用 SQL 语句访问 SequoiaDB 数据库，完成对数据的增、删、查、改操作以及其它 PostgreSQL 语法操作。
请点击右侧选择使用的实验环境
部署架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，其中包括： 1 个 SequoiaSQL-PostgreSQL 数据库实例节点、1 个引擎协调节点，1 个编目节点与3个数据节点。
图片描述
详细了解 SequoiaDB 巨杉数据库系统架构：
SequoiaDB 系统架构
实验环境
课程使用的实验环境为 Ubuntu Linux 16.04 64 位版本。SequoiaDB 数据库引擎以及 SequoiaSQL-PostgreSQL 实例均为 3.4 版本。
2. 切换用户及查看数据库版本
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库和 SequoiaSQL-PostgreSQL 实例的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version### 3. 检查就绪状态
查看节点启动列表
查看 SequoiaDB 巨杉数据库引擎节点列表：
sdblist
copy
操作截图：
图片描述
Note:
如果显示的节点数量与预期不符，请稍等初始化完成并重试该步骤。
C: 编目节点，S：协调节点，D：数据节点
检查实例状态
查看 PostgreSQL 实例状态：
/opt/sequoiasql/postgresql/bin/sdb_sql_ctl status
4. 创建数据库
1）在 SequoiaSQL-PostgreSQL 实例中并创建 company 数据库，为接下来验证 PostgreSQL 语法特性做准备；
以 sdbadmin 用户登录，在 PostgreSQL 实例创建数据库 company；
/opt/sequoiasql/postgresql/bin/sdb_sql_ctl createdb company myinst
copy
2）查看数据库；
/opt/sequoiasql/postgresql/bin/psql -l
5. 配置 PostgreSQL 实例
加载 SequoiaDB 连接驱动
1）登录到 PostgreSQL 实例 Shell；
/opt/sequoiasql/postgresql/bin/psql -p 5432 company
copy
2）加载SequoiaDB连接驱动；
CREATE EXTENSION sdb_fdw;
copy
配置与 SequoiaDB 连接参数
在 PostgreSQL 实例中配置 SequoiaDB 连接参数：
1）创建 sdb_server 这个连接器
CREATE SERVER sdb_server FOREIGN DATA WRAPPER sdb_fdw OPTIONS
(
address '127.0.0.1',
service '11810',
user '',
password '',
preferedinstance 'A',
transaction 'on'
);
copy
Note:
如果没有配置数据库密码验证，可以忽略user与password字段；
如果需要提供多个协调节点地址，options 中的 address 字段可以按格式 'ip1:port1,ip2:port2,ip3:port3'填写。此时，service 字段可填写任意一个非空字符串；
preferedinstance 设置 SequoiaDB 的连接属性。多个属性以逗号分隔，如：preferedinstance '1,2,A'；
transaction 设置 SequoiaDB 是否开启事务，默认为off。开启为on ；
其他详细参数请参考 PostgreSQL-连接说明
2）退出 PostgreSQL 客户端
\q
copy
6. 创建关联集合空间、集合
首先在 SequoiaDB 巨杉数据库引擎中创建集合空间 company 和集合 employee，然后在 PostgreSQL 实例中关联 SequoiaDB 数据库引擎中创建的集合空间和集合。
SequoiaDB 数据库引擎中创建集合
1）通过 Linux 命令行进入 SequoiaDB Shell；
sdb
copy
2）通过 JavaScript 语言连接协调节点，获取数据库连接；
var db = new Sdb("localhost", 11810);
copy
3）创建 company_domains 逻辑域；
db.createDomain("company_domains", [ "group1", "group2", "group3" ], { AutoSplit: true } );
copy
4）创建 company 集合空间；
db.createCS("company", { Domain: "company_domains" } );
copy
5）创建 employee 集合；
db.company.createCL("employee", { "ShardingKey": { "_id": 1}, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false });
copy
6）退出 SequoiaDB Shell；
quit;
copy
操作截图：
图片描述
实例与数据引擎中集合关联
1）登录到 PostgreSQL 实例 Shell；
/opt/sequoiasql/postgresql/bin/psql -p 5432 company
copy
2）创建 PostgreSQL 实例中的外表并与 SequoiaDB 中的集合空间和集合关联；
CREATE FOREIGN TABLE employee
(
empno INT,
ename VARCHAR(128),
age INT
)
SERVER sdb_server OPTIONS ( collectionspace 'company', collection 'employee', decimal 'on' );
copy
3）检查 PostgreSQL 中创建的表；
\d
copy
操作截图：
图片描述
Note:
集合空间与集合必须已经存在于 SequoiaDB，否则查询出错；
如果需要对接 SequoiaDB 的 decimal 字段，则需要在 options 中指定 decimal 'on' 。
默认情况下，表的字段映射到 SequoiaDB 中为小写字符，如果强制指定字段为大写字符，需要将字段名用双引号引起来；
如果字段名或者字段类型有 PostgreSql 的关键字也是创建不成功表的，需要把关键字用双引号引起来。
其他详细参数请参考 PostgreSQL-连接说明
7. 实例操作数据库引擎集合的数据
使用 PostgreSQL 实例操作关联表中的数据。
通过关联表插入数据
在 PostgreSQL 实例中向外表 employee 中插入数据:
INSERT INTO employee VALUES (10001, 'Georgi', 48);
INSERT INTO employee VALUES (10002, 'Bezalel', 21);
INSERT INTO employee VALUES (10003, 'Parto', 33);
INSERT INTO employee VALUES (10004, 'Chirstian', 40);
INSERT INTO employee VALUES (10005, 'Kyoichi', 23);
INSERT INTO employee VALUES (10006, 'Anneke', 19);
copy
查询 employee 表中的数据
查询 PostgreSQL 实例外表 employee 中 age 大于20，小于30的数据：
SELECT * FROM employee WHERE age > 20 AND age < 30;
copy
操作截图：
图片描述
更新关联表中的数据
1）更新 PostgreSQL 实例外表 employee 中的数据，将 empno 为10001的记录 age 更改为34；
UPDATE employee SET age=34 WHERE empno = 10001;
copy
2）查询数据结果确认 empno 为10001的记录更新是否成功：
SELECT * FROM employee;
copy
操作截图：
图片描述
删除关联表中的数据
1）删除 PostgreSQL 实例外表 employee 中的数据，将 empno 为 10006 的记录删除；
DELETE FROM employee WHERE empno = 10006;
copy
2）查询数据结果确认 empno 为10006的记录是否成功删除；
SELECT * FROM employee;
copy
操作截图：
图片描述
3）退出 PostgreSQL 客户端
\q
8. 索引使用
使用 PostgreSQL 实例操作关联表中的数据。
通过关联表插入数据
在 PostgreSQL 实例中向外表 employee 中插入数据:
INSERT INTO employee VALUES (10001, 'Georgi', 48);
INSERT INTO employee VALUES (10002, 'Bezalel', 21);
INSERT INTO employee VALUES (10003, 'Parto', 33);
INSERT INTO employee VALUES (10004, 'Chirstian', 40);
INSERT INTO employee VALUES (10005, 'Kyoichi', 23);
INSERT INTO employee VALUES (10006, 'Anneke', 19);
copy
查询 employee 表中的数据
查询 PostgreSQL 实例外表 employee 中 age 大于20，小于30的数据：
SELECT * FROM employee WHERE age > 20 AND age < 30;
copy
操作截图：
图片描述
更新关联表中的数据
1）更新 PostgreSQL 实例外表 employee 中的数据，将 empno 为10001的记录 age 更改为34；
UPDATE employee SET age=34 WHERE empno = 10001;
copy
2）查询数据结果确认 empno 为10001的记录更新是否成功：
SELECT * FROM employee;
copy
操作截图：
图片描述
删除关联表中的数据
1）删除 PostgreSQL 实例外表 employee 中的数据，将 empno 为 10006 的记录删除；
DELETE FROM employee WHERE empno = 10006;
copy
2）查询数据结果确认 empno 为10006的记录是否成功删除；
SELECT * FROM employee;
copy
操作截图：
图片描述
3）退出 PostgreSQL 客户端
\q
9. Java 语言操作 PostgreSQL 实例中的数据
本节内容主要用来演示 Java 语言操作 SequoiaSQL-PostgreSQL 实例中的数据，为相关开发人员提供参考。源码已经放置在 /home/sdbadmin/source/postgresql 目录下。
1）进入源码放置目录；
cd /home/sdbadmin/source/postgresql
copy
2）查看 java 文件，一共5个 java 文件；
ls -trl
copy
Note：
PostgreSQLConnection.java 连接数据库类
Insert.java 写入数据类
Select.java 查询数据类
Update.java 更新数据类
Delete.java 删除数据类
3）首先对连接的 java 文件进行编译；
javac -d . PostgreSQLConnection.java
copy
在 PostgreSQL 实例中插入数据：
1）增加 empno 为 30001 、 30002 和 30003 这三条记录，Insert.java 源代码如下；
package com.sequoiadb.postgresql;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class Insert {
private static String url = "jdbc:postgresql://127.0.0.1:5432/company";
private static String username = "sdbadmin";
private static String password = "";
public static void main(String[] args) throws SQLException {
insert();
}
public static void insert() throws SQLException {
PostgreSQLConnection pgConnection = new PostgreSQLConnection(url, username, password);
Connection connection = pgConnection.getConnection();
String sql = "INSERT INTO employee VALUES";
Statement stmt = connection.createStatement();
StringBuffer sb = new StringBuffer();
sb.append("(").append(30001).append(",").append("'Mike'").append(",").append(20).ap
pend("),");
sb.append("(").append(30002).append(",").append("'Donna'").append(",").append(21).a
ppend("),");
sb.append("(").append(30003).append(",").append("'Jack'").append(",").append(22).ap
pend("),");
sb.deleteCharAt(sb.length() - 1);
sql = sql + sb.toString();
System.out.println(sql);
stmt.executeUpdate(sql);
connection.close();
}
}
copy
2）对 Insert.java 文件进行编译；
javac -d . Insert.java
copy
3）运行 Insert 类的代码；
java -cp .:../postgresql-9.3-1104-jdbc41.jar com.sequoiadb.postgresql.Insert
copy
4）操作截图： 图片描述
从 PostgreSQL 实例中查询数据：
1）查询返回 empno 、 ename 和 age 这三个字段 ，Select.java 源代码如下；
package com.sequoiadb.postgresql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Select {
private static String url = "jdbc:postgresql://127.0.0.1:5432/company";
private static String username = "sdbadmin";
private static String password = "";
public static void main(String[] args) throws SQLException {
select();
}
public static void select() throws SQLException {
PostgreSQLConnection pgConnection = new PostgreSQLConnection(url, username, password);
Connection connection = pgConnection.getConnection();
String sql = "select * from employee";
PreparedStatement psmt = connection.prepareStatement(sql);
ResultSet rs = psmt.executeQuery();
System.out.println("---------------------------------------------------------------
-------");
System.out.println("empno \t ename \t age");
System.out.println("---------------------------------------------------------------
-------");
while(rs.next()){
Integer empno = rs.getInt("empno");
String ename = rs.getString("ename");
String age = rs.getString("age");
System.out.println(empno + "\t" + ename + "\t" + age);
}
connection.close();
}}
copy
2）对 Select.java 文件进行编译；
javac -d . Select.java
copy
3）运行 Select 类的代码；
java -cp .:../postgresql-9.3-1104-jdbc41.jar com.sequoiadb.postgresql.Select
copy
4）操作截图： 图片描述
在 PostgreSQL 实例中更新数据：
1）将 empno 值为 10004 的 age 修改为 41 ， Update.java 源代码如下；
package com.sequoiadb.postgresql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Update {
private static String url = "jdbc:postgresql://127.0.0.1:5432/company";
private static String username = "sdbadmin";
private static String password = "";
public static void main(String[] args) throws SQLException {
update();
}
public static void update() throws SQLException {
PostgreSQLConnection pgConnection = new PostgreSQLConnection(url, username, password);
Connection connection = pgConnection.getConnection();
String sql = "update employee set age = ? where empno = ?";
PreparedStatement psmt = connection.prepareStatement(sql);
psmt.setInt(1, 41);
psmt.setInt(2, 10004);
psmt.execute();
connection.close(); }
}
copy
2）对 Update.java 文件进行编译；
javac -d . Update.java
copy
3）运行 Update 类的代码；
java -cp .:../postgresql-9.3-1104-jdbc41.jar com.sequoiadb.postgresql.Update
copy
4）更新后查看 empno 为 10004 的 age 值是否更新为 41；
java -cp .:../postgresql-9.3-1104-jdbc41.jar com.sequoiadb.postgresql.Select
copy
5）操作截图 ： 图片描述
在 PostgreSQL 实例中删除数据
1）将 empno 值为 10005 的记录删除 , Delete.java 源代码如下；
package com.sequoiadb.postgresql;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Delete {
private static String url = "jdbc:postgresql://127.0.0.1:5432/company";
private static String username = "sdbadmin";
private static String password = "";
public static void main(String[] args) throws SQLException {
delete();
}
public static void delete() throws SQLException {
PostgreSQLConnection pgConnection = new PostgreSQLConnection(url, username, password);
Connection connection = pgConnection.getConnection();
String sql = "delete from employee where empno = ?";
PreparedStatement psmt = connection.prepareStatement(sql);
psmt.setInt(1, 10005);
psmt.execute();
connection.close();
}
}
copy
2）对 Delete.java 文件进行编译；
javac -d . Delete.java
copy
3）运行 Delete 类的代码；
java -cp .:../postgresql-9.3-1104-jdbc41.jar com.sequoiadb.postgresql.Delete
copy
4）检查确认 empno 为 10005 的雇员信息已经被删除；
java -cp .:../postgresql-9.3-1104-jdbc41.jar com.sequoiadb.postgresql.Select
10. 总结
通过本课程，我们验证了 SequoiaDB 巨杉数据库所支持的 PostgreSQL 语法，并展示了使用 JAVA 语言对 SequoiaSQL-PostgreSQL 实例中的表进行 CRUD 操作。可以看出：
SequoiaSQL-PostgreSQL 实例兼容标准的 PostgreSQL 语法；
Java语言操作 SequoiaSQL-PostgreSQL 实例中的数据与操作原生 PostgreSQL 中的数据无任何差异，可做到无缝切换；
三、SparkSQL 实例应用开发
1. 课程介绍
本课程将带领您在已经部署 SequoiaDB 巨杉数据库引擎和 SparkSQL 实例环境中，使用 Beeline 客户端访问 SparkSQL 完成对数据的写入、查询操作，另外重点介绍如何使用 JDBC 接口访问 SparkSQL 进行应用开发。
请点击右侧选择使用的实验环境
部署架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，其中SequoiaSQL-SparkSQL 数据库实例包括 2 个 worker 节点，SequoiaDB 巨杉数据库包括 1 个引擎协调节点，1 个编目节点与 3 个数据节点。
图片描述
详细了解 SequoiaDB 巨杉数据库系统架构：
SequoiaDB 系统架构
实验环境
课程使用的实验环境为 Ubuntu Linux 16.04 64 位版本。SequoiaDB 数据库引擎以及 SequoiaSQL-SparkSQL 实例连接器均为 3.4 版本。
2. 切换用户及查看数据库版本
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库和 SequoiaSQL-SparkSQL 实例的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version
3. 查看节点启动列表
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库和 SequoiaSQL-SparkSQL 实例的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version
4. SequoiaDB 创建集合空间和集合
进入 SequoiaDB Shell，在 SequoiaDB 中创建集合空间 company，集合 employee，存储 SparkSQL 操作的数据。
1）使用 Linux 命令行进入 SequoiaDB Shell；
sdb
copy
2）使用 javascript 语言连接协调节点；
var db = new Sdb("localhost", 11810);
copy
3）创建 company_domains 逻辑域；
db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );
copy
4）创建 company 集合空间；
db.createCS("company", { Domain: "company_domain" } );
copy
5）创建 employee 集合，并使用 _id 进行 hash 分区；
db.company.createCL("employee", { "ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false });
copy
6）退出 SequoiaDB Shell；
quit;
copy
5. SparkSQL 创建数据库及映射表
在 SparkSQL 实例中创建数据库及数据表并与 SequoiaDB 数据库引擎中的集合空间和集合关联。
创建数据库
1）使用 Beeline 客户端连接 SparkSQL 实例服务；
/opt/spark/bin/beeline -u 'jdbc:hive2://localhost:10000'
copy
2）在 SparkSQL 实例中创建数据库 company，并切换至company库；
CREATE DATABASE company;
USE company;
copy
关联实例与数据库引擎中的集合
在 SparkSQL 实例中创建表并与 SequoiaDB 数据库存储引擎中的集合空间和集合关联；
CREATE TABLE employee
(
empno INT,
ename STRING,
age INT
) USING com.sequoiadb.spark OPTIONS ( host 'localhost:11810', collectionspace 'company', collection 'employee' );
copy
从 SparkSQL 实例中创建视图、表及数据类型对应关系的详细说明请参考： SparkSQL 实例访问SequoiaDB数据库存储引擎
6. 在 Beeline 中进行数据操作
使用 SparkSQL 实例操作关联表中的数据。
1）在 SparkSQL 实例关联表 employee 中插入数据；
INSERT INTO employee VALUES (10001, 'Georgi', 48);
INSERT INTO employee VALUES (10002, 'Bezalel', 21);
INSERT INTO employee VALUES (10003, 'Parto', 33);
INSERT INTO employee VALUES (10004, 'Chirstian', 40);
INSERT INTO employee VALUES (10005, 'Kyoichi', 23);
INSERT INTO employee VALUES (10006, 'Anneke', 19);
copy
2）使用 SparkSQL 实例查询员工年龄为20至24之间的记录；
SELECT * FROM employee WHERE age BETWEEN 20 AND 24;
copy
操作截图：
图片描述
3）退出 SparkSQL 的客户端；
!quit
copy
7. 创建 JAVA 工程项目
SparkSQL 支持 JDBC 的访问方式，在使用前需要启动 Thriftserver 服务，在开发应用中通过 JDBC 访问 SparkSQL 时，需要在 Java 工程中加入 Thriftserver 依赖的库。
1）创建 JAVA 工程目录；
mkdir -p /home/sdbadmin/spark/lib
copy
2）进入工程目录；
cd /home/sdbadmin/spark
copy
3）拷贝 JDBC 接口需要的 jar 包；
cp /opt/spark/jars/commons-logging-1.1.3.jar ./lib
cp /opt/spark/jars/hadoop-common-2.7.3.jar ./lib
cp /opt/spark/jars/hive-exec-1.2.1.spark2.jar ./lib
cp /opt/spark/jars/hive-jdbc-1.2.1.spark2.jar ./lib
cp /opt/spark/jars/hive-metastore-1.2.1.spark2.jar ./lib
cp /opt/spark/jars/httpclient-4.5.6.jar ./lib
cp /opt/spark/jars/httpcore-4.4.10.jar ./lib
cp /opt/spark/jars/libthrift-0.9.3.jar ./lib
cp /opt/spark/jars/log4j-1.2.17.jar ./lib
cp /opt/spark/jars/slf4j-api-1.7.16.jar ./lib
cp /opt/spark/jars/slf4j-log4j12-1.7.16.jar ./lib
cp /opt/spark/jars/spark-network-common_2.11-2.4.4.jar ./lib
cp /opt/spark/jars/spark-hive-thriftserver_2.11-2.4.4.jar ./lib
copy
4）复制以下代码到实验环境终端执行，生成通过 JDBC 接口操作 SparkSQL 数据的 Select.java 文件；
cat > /home/sdbadmin/spark/Select.java << EOF
package com.sequoiadb.spark;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Select {
private static String driverName = "org.apache.hive.jdbc.HiveDriver";
public static void main(String args[])
{
try {
Class.forName(driverName);
} catch (ClassNotFoundException e) {
e.printStackTrace();
System.exit(1);
}
String url = "jdbc:hive2://localhost:10000/company";
Connection conn = null;
try {
conn = DriverManager.getConnection(url, "sdbadmin", "");
} catch (SQLException e) {
e.printStackTrace();
}
System.out.println("Connection success!");
try {
System.out.println("--------- Get Records ---------");
Statement st = conn.createStatement();
String sql = " select * from employee";
ResultSet rs = st.executeQuery(sql);
while (rs.next()) {
System.out.println(rs.getInt("empno") + "\t" + rs.getString("ename") + "\t" + rs.getInt("age"));
}
rs.close();
st.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
EOF
copy
5）查询是否已经生成 Select.java 文件；
ls -trl /home/sdbadmin/spark/Select.java
copy
8. 编译运行代码
上一小节已经创建了 JAVA 工程和代码并且拷贝了 JAVA 驱动，接下来我们对代码进行编译运行。
1）编译 Select.java 文件；
javac -d . Select.java
copy
2）运行 Select 类代码，查询数据；
java -cp .:./lib/* com.sequoiadb.spark.Select
9. 总结
通过本课程，我们学习了通过 SparkSQL 操作 SequoiaDB 巨杉数据库中的数据，同时介绍了如何使用 JDBC 接口操作 SparkSQL 实例中的数据。
四、JSON 实例应用开发
1. 课程介绍
本课程将介绍使用 JavaScript 脚本开发语言在 SequoiaDB Shell 中进行创建数据域、集合空间、集合、索引等操作，随后使用 JAVA 驱动对创建的集合进行写入和查询操作。
JSON 实例简介
SequoiaDB 巨杉数据库为用户提供了 JSON 实例, 通过此实例可以与 SequoiaDB 巨杉数据库进行交互操作。JSON 实例支持多种方式执行集群管理、运行实例检查、数据增删改查等操作。
请点击右侧选择使用的实验环境
部署架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，其中包括1个引擎协调节点，1个编目节点与3个数据节点。
图片描述
详细了解 SequoiaDB 巨杉数据库系统架构：
SequoiaDB 系统架构
实验环境
课程使用的实验环境为 Ubuntu Linux 16.04 64 位版本。SequoiaDB 数据库引擎为 3.4 版本。
2. 切换用户及查看数据库版本
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version
copy
3. 查看节点启动列表
查看 SequoiaDB 巨杉数据库引擎节点列表：
sdblist
copy
操作截图：
图片描述
Note:
如果显示的节点数量与预期不符，请稍等初始化完成并重试该步骤。
C: 编目节点，S：协调节点，D：数据节点
4. 创建域、集合空间和集合
在 SequoiaDB Shell 中创建集合空间和集合用于后续章节进行数据操作。
1）通过 Linux 命令行进入 SequoiaDB Shell；
sdb
copy
2）通过 javascript 语言连接协调节点，获取数据库连接；
var db = new Sdb("localhost", 11810);
copy
3）创建 company_domain 逻辑域；
db.createDomain("company_domain", [ "group1", "group2", "group3" ], { AutoSplit: true });
copy
4）创建 company 集合空间；
db.createCS("company", { Domain: "company_domain" });
copy
5）创建 employee 集合；
db.company.createCL("employee", {"ShardingKey": { "_id": 1 }, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false });
copy
Note:
集合（Collection）是数据库中存放文档的逻辑对象。任何一条文档必须属于一个且仅一个集合。
集合空间（CollectionSpace）是数据库中存放集合的物理对象。任何一个集合必须属于一个且仅一个集合空间。
域（Domain）是由若干个复制组（ReplicaGroup）组成的逻辑单元。每个域都可以根据定义好的策略自动管理所属数据，如数据切片和数据隔离等。
5. 集合数据操作
通过 SequoiaDB Shell 进行集合数据的 CRUD 操作。
集合中写入数据
在 JSON 实例集合 company 中写入数据：
db.company.employee.insert( { "empno": 10001, "ename": "Georgi", "age": 48 } );
db.company.employee.insert( { "empno": 10002, "ename": "Bezalel", "age": 21 } );
db.company.employee.insert( { "empno": 10003, "ename": "Parto", "age": 33 } );
db.company.employee.insert( { "empno": 10004, "ename": "Chirstian", "age": 40 } );
db.company.employee.insert( { "empno": 10005, "ename": "Kyoichi", "age": 23 } );
db.company.employee.insert( { "empno": 10006, "ename": "Anneke", "age": 19 } );
copy
查询集合中的数据
查询集合 employees 中age 大于20，小于30的数据：
db.company.employee.find( { "age": { "lt": 30 } } );
操作截图：
图片描述
更新集合中的数据
1）集合 employees 中的数据，将 empno 为10001的记录 age 更改为34；
db.company.employee.update( { "$set": { "age": 34 } }, { "empno": 10001 } );
2）查询数据结果确认 empno 为10001的记录更新是否成功；
db.company.employee.find( { "empno": 10001 } );
copy
操作截图：
图片描述
删除集合中的数据
1）删除集合 employees 中的数据，将 empno 为10006的记录删除；
db.company.employee.remove( { "empno": 10006 } );
copy
2）查询数据结果确认 empno 为10006的记录是否成功删除；
db.company.employee.find( {}, { "empno": "" } );
copy
操作截图：
图片描述
6. 索引使用
在 SequoiaDB 巨杉数据库中，索引是一种特殊的数据对象。索引本身不做为保存用户数据的容器，而是作为一种特殊的元数据，提高数据访问的效率。
1）在集合 employee 的 ename 字段上创建索引；
db.company.employee.createIndex("idx_ename", { ename: 1 }, false);
copy
2）查看集合 employee 上创建的索引；
db.company.employee.listIndexes();
copy
操作截图：
图片描述
3）显示集合 employees 查询语句执行计划；
db.company.employee.find( { "ename": "Georgi" } ).explain();
copy
操作截图： 图片描述
4）退出 SequoiaDB Shell；
quit;
7. 创建 JAVA 工程项目
使用 Java 语言操作 JSON 实例中的数据，为相关开发人员提供参考，更多开发语言的操作请参考官网提供的驱动文档。
1）创建 JAVA 工程目录；
mkdir -p /home/sdbadmin/json/lib
copy
2）进入工程目录；
cd /home/sdbadmin/json
copy
3）拷贝 JSON 实例驱动包；
cp /opt/sequoiadb/java/sequoiadb-driver-3.4.jar ./lib
copy
4）复制以下代码到实验环境终端执行，生成 Datasource.java 文件；
cat > /home/sdbadmin/json/Datasource.java << EOF
package com.sequoiadb.samples;
import java.util.ArrayList;
import org.bson.BSONObject;
import org.bson.BasicBSONObject;
import com.sequoiadb.base.CollectionSpace;
import com.sequoiadb.base.ConfigOptions;
import com.sequoiadb.base.DBCollection;
import com.sequoiadb.base.DBCursor;
import com.sequoiadb.base.Sequoiadb;
import com.sequoiadb.datasource.ConnectStrategy;
import com.sequoiadb.datasource.DatasourceOptions;
import com.sequoiadb.datasource.SequoiadbDatasource;
import com.sequoiadb.exception.BaseException;
public class Datasource {
public static void main(String[] args) throws InterruptedException {
ArrayList<String> addrs = new ArrayList<String>();
String user = "";
String password = "";
ConfigOptions nwOpt = new ConfigOptions();
DatasourceOptions dsOpt = new DatasourceOptions();
SequoiadbDatasource ds = null;
// 提供coord节点地址
addrs.add("sdbserver1:11810");
// 设置网络参数
nwOpt.setConnectTimeout(500); // 建连超时时间为500ms。
nwOpt.setMaxAutoConnectRetryTime(0); // 建连失败后重试时间为0ms。
// 设置连接池参数
dsOpt.setMaxCount(500); // 连接池最多能提供500个连接。
dsOpt.setDeltaIncCount(20); // 每次增加20个连接。
dsOpt.setMaxIdleCount(20); // 连接池空闲时，保留20个连接。
dsOpt.setKeepAliveTimeout(0); // 池中空闲连接存活时间。单位:毫秒。
// 0表示不关心连接隔多长时间没有收发消息。
dsOpt.setCheckInterval(60 * 1000); // 每隔60秒将连接池中多于
// MaxIdleCount限定的空闲连接关闭，
// 并将存活时间过长（连接已停止收发
// 超过keepAliveTimeout时间）的连接关闭。
dsOpt.setSyncCoordInterval(0); // 向catalog同步coord地址的周期。单位:毫秒。
// 0表示不同步。
dsOpt.setValidateConnection(false); // 连接出池时，是否检测连接的可用性，默认不检测。
dsOpt.setConnectStrategy(ConnectStrategy.BALANCE); // 默认使用coord地址负载均衡的策略获取连接。
// 建立连接池
ds = new SequoiadbDatasource(addrs, user, password, nwOpt, dsOpt);
// 使用连接池运行任务
runTask(ds);
// 任务结束后，关闭连接池
ds.close();
}
static void runTask(SequoiadbDatasource ds) throws InterruptedException {
String clFullName = "company.employee";
// 准备任务
Thread insertTask = new Thread(new InsertTask(ds, clFullName));
Thread queryTask = new Thread(new QueryTask(ds, clFullName));
// 往集合插记录
insertTask.start();
Thread.sleep(3000);
// 从集合中查记录
queryTask.start();
// 等待任务结束
insertTask.join();
queryTask.join();
}}
class InsertTask implements Runnable {
private SequoiadbDatasource ds;
private String csName;
private String clName;
public InsertTask(SequoiadbDatasource ds, String clFullName) {
this.ds = ds;
this.csName = clFullName.split("\\\.")[0];
this.clName = clFullName.split("\\\.")[1];
}
@Override
public void run() {
Sequoiadb db = null;
CollectionSpace cs = null;
DBCollection cl = null;
BSONObject record = null;
// 从连接池获取连接
try {
db = ds.getConnection();
} catch (BaseException e) {
e.printStackTrace();
System.exit(1);
} catch (InterruptedException e) {
e.printStackTrace();
System.exit(1);
}
// 使用连接获取集合对象
cs = db.getCollectionSpace(csName);
cl = cs.getCollection(clName);
// 使用集合对象插入记录
record = genRecord();
cl.insert(record);
// 将连接归还连接池
ds.releaseConnection(db);
System.out.println("Suceess to insert record: " + record.toString());
}
private BSONObject genRecord() {
BSONObject obj = new BasicBSONObject();
obj.put("empno", 10007);
obj.put("ename", "JACK");
obj.put("age", 30);
return obj;
}}
class QueryTask implements Runnable {
private SequoiadbDatasource ds;
private String csName;
private String clName;
public QueryTask(SequoiadbDatasource ds, String clFullName) {
this.ds = ds;
this.csName = clFullName.split("\\\.")[0];
this.clName = clFullName.split("\\\.")[1];
}
@Override
public void run() {
Sequoiadb db = null;
CollectionSpace cs = null;
DBCollection cl = null;
DBCursor cursor = null;
// 从连接池获取连接
try {
db = ds.getConnection();
} catch (BaseException e) {
e.printStackTrace();
System.exit(1);
} catch (InterruptedException e) {
e.printStackTrace();
System.exit(1);
}
// 使用连接获取集合对象
cs = db.getCollectionSpace(csName);
cl = cs.getCollection(clName);
// 使用集合对象查询
cursor = cl.query();
try {
while (cursor.hasNext()) {
System.out.println("The inserted record is: " + cursor.getNext());
}
} finally {
cursor.close();
}
// 将连接对象归还连接池
ds.releaseConnection(db);
}}
EOF
copy
5）查询是否已经生成 Datasource.java 文件；
ls -trl /home/sdbadmin/json/Datasource.java
8. 编译运行代码
上一小节已经创建了 JAVA 工程和代码并且拷贝了 JAVA 驱动，接下来我们对代码进行编译运行。
1）编译 Datasource.java 文件；
javac -cp .:./lib/sequoiadb-driver-3.4.jar -d . Datasource.java
copy
2）运行 Datasource 类代码，查询数据；
java -cp .:./lib/sequoiadb-driver-3.4.jar com.sequoiadb.samples.Datasource
9. 总结
本课程通过 javascript 语法对 SequoiaDB 巨杉数据库 JSON 实例进行了创建集合空间、集合、索引以及数据的 CRUD 基本操作，通过 JAVA 开发语言展示了连接池和集合的写入和查询操作。
五、S3 对象存储部署与应用开发
1. 课程介绍
本课程将带领您在已经部署 SequoiaDB 巨杉数据库引擎中部署 S3 对象存储，及使用 S3 接口实现桶的增、删、查，对象的增、删、查，对象的版本管理，以及分段上传的操作。
请点击右侧选择使用的实验环境
部署架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，包括1个 SequoiaS3 实例，1个引擎协调节点，1个编目节点与3个数据节点。
图片描述
详细了解 SequoiaDB 巨杉数据库系统架构：
SequoiaDB 系统架构
实验环境
课程使用的实验环境为 Ubuntu Linux 16.04 64 位版本。SequoiaDB 数据库引擎以及 SequoiaS3 实例均为 3.4 版本。
2. 切换用户及查看数据库版本
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库和 SequoiaS3 实例的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version
copy
3. 环境检查及配置
查看节点启动列表
查看 SequoiaDB 巨杉数据库引擎节点列表：
sdblist
copy
操作截图：
图片描述
Note:
如果显示的节点数量与预期不符，请稍等初始化完成并重试该步骤。
C: 编目节点，S：协调节点，D：数据节点
检查Java环境
SequoiaS3 对象存储实例采用Java语言开发，实例运行时需Java环境。
1）查看java是否已部署；
java -version
copy
操作截图：
图片描述
检查 SequoiaS3 实例文件
S3 实例相关文件在 SequoiaDB 安装目录 /opt/sequoiadb/tools/sequoias3 中，具体文件和目录如下；
ls -ltr /opt/sequoiadb/tools/sequoias3
copy
4. 配置 SequoiaDB 巨杉数据库存储引擎
在 SequoiaDB 巨杉数据库存储引擎中开启 RC 级别事务，并且配置为等锁模式，同时为 SequoiaS3 的存储创建专属的域。
1）通过 Linux 命令行进入 SequoiaDB Shell；
sdb
copy
2）通过 javascript 语言连接协调节点，获取数据库连接；
var db = new Sdb("localhost", 11810);
copy
3）开启 RC 级别事务，且配置为等锁模式；
db.updateConf( { transactionon: true, transisolation: 1, translockwait: true } );
copy
4）创建存储元数据的集合空间所在的域；
db.createDomain("metaDomain", [ "group1", "group2", "group3" ], { AutoSplit: true} );
copy
5）创建存储对象数据的集合空间所在的域；
db.createDomain("dataDomain", [ "group1", "group2", "group3" ], { AutoSplit: true} );
copy
6）退出 SequoiaDB Shell；
quit;
5. 配置 SequoiaS3 系统
为 SequoiaS3 系统设置监听端口、数据存储域、存储引擎的协调节点等启动的基础配置。
1）进入 SequoiaS3 包目录；
cd /opt/sequoiadb/tools/sequoias3
copy
2）配置 SequoiaS3，配置对外监听端口；
echo 'server.port=8002' >> config/application.properties
copy
3）配置 coord 节点的 IP 和端口，可以配置多组并使用逗号分隔
echo 'sdbs3.sequoiadb.url=sequoiadb://localhost:11810' >> config/application.properties
copy
4）配置 SequoiaS3 的存储创建了专属的域
echo 'sdbs3.sequoiadb.meta.domain=metaDomain' >> config/application.properties
echo 'sdbs3.sequoiadb.data.domain=dataDomain' >> config/application.properties
copy
Note:
详细配置说明： SequoiaS3 实例参数配置
6. 启动 SequoiaS3 系统
1）配置修改完成后，通过 ./sequoias3.sh 可执行脚本启动 SequoiaS3；
/opt/sequoiadb/tools/sequoias3/sequoias3.sh start
copy
2）进入 SequoiaDB Shell，查看 SequoiaS3 元数据表,SequoiaS3 实例在启动的时候如果这些元数据表不存在会自动创建；
sdb
copy
3）使用javascript语法连接协调节点，获取 db 数据库连接；
var db = new Sdb("localhost", 11810);
copy
4）查看集合列表；
db.list(SDB_SNAP_COLLECTIONS);
copy
操作截图： 图片描述
5）退出 SequoiaDB Shell；
quit;
copy
Note:
系统启动时需确保数据库已经正常运行，系统启动后会创建默认管理员用户，您可以使用该默认管理员用户创建新的用户，然后使用新用户角色进行桶操作，对象操作。
默认管理员账户名：administrator
默认管理员AccessKeyID：ABCDEFGHIJKLMNOPQRST
默认管理员用户SecreatKeyID：abcdefghijklmnopqrstuvwxyz0123456789ABCD
7. 用户接口相关操作
在本例中将使用 curl restful 方式来测试 SequoiaS3 用户接口，主要包括用户创建、密钥获取、用户删除等相关操作。后续操作需要启动 SequoiaS3 进程，如有关闭需要打开。
创建用户
使用 curl 创建用户 s3user（其中 ABCDEFGHIJKLMNOPQRST 为默认管理员 AccessKeyID ，为 abcdefghijklmnopqrstuvwxyz0123456789ABCD 默认管理员用户 SecreatKeyID ）：
curl -v -X POST "http://localhost:8002/users/?Action=CreateUser&UserName=s3user&role=admin" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
8. 桶增删查接口相关操作
在本例中将使用 curl restful 方式来测试 SequoiaS3 桶接口，主要包括桶创建、桶获取、桶删除等相关操作。
创建桶
使用 curl 创建桶 sdbbucket：
curl -v -X PUT "http://localhost:8002/sdbbucket" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrs
tuvwxyz0123456789ABCD"
copy
操作截图：
图片描述
获取桶信息
使用 curl 获取所有桶信息：
curl -v -X GET "http://localhost:8002" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
copy
操作截图：
图片描述
删除桶
1）使用 curl 删除桶 sdbbucket；
curl -v -X DELETE "http://localhost:8002/sdbbucket" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
copy
操作截图：
图片描述
2）检查桶是否存在，确认结果中是否存在桶 sdbbucket；
curl -v GET "http://localhost:8002" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
copy
操作截图：
9. 文件上传和下载相关操作
在本例中将使用 curl restful 方式来测试 SequoiaS3 文件对象接口，主要包括文件对象上传、下载、删除相关操作。
如果已经删除桶则需要重新创建，需要先确保 sdbbucket 桶已创好。
使用 curl 创建桶 sdbbucket ：
curl -v -X PUT "http://localhost:8002/sdbbucket" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
copy
文件对象上传
1）检查 /opt/sequoiadb/tools/sequoias3/ 目录下是否存在 sequoia-s3-3.4.jar 这个文件，后面向 sdbbucket 桶上传此文件；
ls /opt/sequoiadb/tools/sequoias3/sequoia-s3-3.4.jar
copy
2）使用 curl 向 sdbbucket 中写入文件 "sequoia-s3-3.4.jar" ，在S3中的名称是 "sdbs3.jar"；
curl -X PUT -T "/opt/sequoiadb/tools/sequoias3/sequoia-s3-3.4.jar" "http://localhost:8002/sdbbucket/sdbs3.jar" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD" -H "Content-Type: text/plain"
copy
3）进入 SequoiaDB Shell，查看对象是否上传成功；
sdb
copy
4）使用javascript语法连接协调节点，获取 db 数据库连接；
var db = new Sdb("localhost", 11810);
copy
5）在元数据集合中查找文件名，确定是否上传成功；
db.S3_SYS_Meta.S3_ObjectMeta.find( { "Key": "sdbs3.jar" } );
copy
6）退出 SequoiaDB Shell；
quit;
copy
Note:
上传前去确保桶 sdbbucket 存在，如不存在，使用之前命令创建 sdbbucket 桶对象。
第一次上传对象时，会创建 S3_ObjectData* 的集合，该集合用于保存对象文件。
文件对象下载
1）从桶 sdbbucket 中读取文件对象 “sdbs3.jar”，并存放到本地目录 sdbs3.jar 文件中；
curl -o sdbs3.jar -X GET "http://localhost:8002/sdbbucket/sdbs3.jar" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD" -H "Content-Type: text/plain"
copy
操作截图：
图片描述
2）查看下载的文件 sdbs3.jar，观察该文件与 sequoia-s3-3.4.jar 大小是否一致；
ls -trl
copy
操作截图：
图片描述
文件对象删除
1）从桶 sdbbucket 中删除文件对象 “sdbs3.jar”；
curl -X DELETE "http://localhost:8002/sdbbucket/sdbs3.jar" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
copy
2）进入 SequoiaDB Shell，查看对象是否删除成功；
使用 linux 命令进入 SequoiaDB Shell；
sdb
copy
使用javascript语法连接协调节点，获取 db 数据库连接；
var db = new Sdb("localhost", 11810);
copy
在元数据集合中查找文件名，如果返回值为空，则对象删除成功；
db.S3_SYS_Meta.S3_ObjectMeta.find( { "Key": "sdbs3.jar" } );
copy
退出 SequoiaDB Shell；
quit;
10. 创建 JAVA 工程项目
本小节介绍使用 Java S3 的使用样例，实现基本读写操作。
1）创建 JAVA 工程目录；
mkdir -p /home/sdbadmin/s3/lib
copy
2）进入工程目录；
cd /home/sdbadmin/s3
copy
3）拷贝 S3 接口需要的 jar 包；
cp /home/sdbadmin/package/s3/* ./lib
copy
4）复制以下代码到实验环境终端执行，生成创建桶和上传文件的 Init.java 文件；
cat > /home/sdbadmin/s3/Init.java << EOF
package com.sequoiadb.samples;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.PutObjectRequest;
import java.io.File;
import java.io.IOException;
public class Init {
public static void main(String[] args) throws IOException {
//初始化客户端, 生成一个与SequoiaS3的连接, 此处需要修改endPoint的地址和端口, 使之指向SequoiaS3的地址和端口.
AWSCredentials credentials = new BasicAWSCredentials("ABCDEFGHIJKLMNOPQRST", "abcdefghijklmnopqrstuvwxyz0123456789ABCD");
String endPoint = "http://127.0.0.1:8002";
AwsClientBuilder.EndpointConfiguration endpointConfiguration = new AwsClientBuilder.EndpointConfiguration(endPoint, null);
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(endpointConfiguration)
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.build();
//创建一个名为"javabucket"的桶
s3.createBucket("javabucket");
//从本地上传文件 sequoia-s3-3.4.jar 到"javabucket"的存储桶中，并命名为"objectname"
PutObjectRequest request = new PutObjectRequest("javabucket", "objectname", new File("/opt/sequoiadb/tools/sequoias3/sequoia-s3-3.4.jar"));
s3.putObject(request);
}}
EOF
copy
5）复制以下代码到实验环境终端执行，生成查询桶内对象列表和下载对象的 GetObject.java 文件；
cat > /home/sdbadmin/s3/GetObject.java << EOF
package com.sequoiadb.samples;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.GetObjectRequest;
import com.amazonaws.services.s3.model.PutObjectRequest;
import com.amazonaws.services.s3.model.S3Object;
import com.amazonaws.services.s3.model.S3ObjectInputStream;
import com.amazonaws.services.s3.model.ListObjectsV2Result;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class GetObject {
public static void main(String[] args) throws IOException {
AWSCredentials credentials = new BasicAWSCredentials("ABCDEFGHIJKLMNOPQRST", "abcdefghijklmnopqrstuvwxyz0123456789ABCD");
String endPoint = "http://127.0.0.1:8002";
AwsClientBuilder.EndpointConfiguration endpointConfiguration = new AwsClientBuilder.EndpointConfiguration(endPoint, null);
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(endpointConfiguration)
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.build();
//查询名为"bucketname"的桶中所有对象名称
ListObjectsV2Result listObj = s3.listObjectsV2("javabucket");
System.out.println("ListObjectsV2Result: "+listObj);
//从"javabucket"获得"objectname"对象, 并将对象内容存储在本地文件中
GetObjectRequest request = new GetObjectRequest("javabucket", "objectname");
S3Object result = s3.getObject(request);
S3ObjectInputStream s3is = result.getObjectContent();
FileOutputStream fos = new FileOutputStream(new File("/home/sdbadmin/s3/java_test_s3.jar"));
byte[] read_buf = new byte[1024];
int read_len = 0;
while ((read_len = s3is.read(read_buf)) > 0) {
fos.write(read_buf, 0, read_len);
}
s3is.close();
fos.close();
}}
EOF
copy
6）复制以下代码到实验环境终端执行，生成删除对象和桶的 DeleteBucket.java 文件；
cat > /home/sdbadmin/s3/DeleteBucket.java << EOF
package com.sequoiadb.samples;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.PutObjectRequest;
import java.io.IOException;
public class DeleteBucket {
public static void main(String[] args) throws IOException {
AWSCredentials credentials = new BasicAWSCredentials("ABCDEFGHIJKLMNOPQRST", "abcdefghijklmnopqrstuvwxyz0123456789ABCD");
String endPoint = "http://127.0.0.1:8002";
AwsClientBuilder.EndpointConfiguration endpointConfiguration = new AwsClientBuilder.EndpointConfiguration(endPoint, null);
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(endpointConfiguration)
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.build();
//删除"javabucket"桶中名为"objectname"的对象
s3.deleteObject("javabucket", "objectname");
//删除名为"javabucket"的存储桶
s3.deleteBucket("javabucket");
}}
EOF
copy
7）查询是否已经生成以上 JAVA 文件；
ls -trl /home/sdbadmin/s3/Init.java
ls -trl /home/sdbadmin/s3/GetObject.java
ls -trl /home/sdbadmin/s3/DeleteBucket.java
copy
11. 编译运行代码
上一小节已经创建了 JAVA 工程和代码并且拷贝了 JAVA 驱动，接下来我们对代码进行编译运行。
1）编译 Init.java 文件；
javac -cp .:./lib/* -d . Init.java
copy
2）运行 Init 类代码，创建"javabucket"桶和上传文件；
java -cp .:./lib/* com.sequoiadb.samples.Init
copy
3）编译 GetObject.java 文件；
javac -cp .:./lib/* -d . GetObject.java
copy
4）运行 GetObject 类代码，查询桶内对象列表和获取对象；
java -cp .:./lib/* com.sequoiadb.samples.GetObject
copy
5）查看对象是否下载成功；
ls -trl
copy
操作截图：
图片描述
6）编译 DeleteBucket.java 文件；
javac -cp .:./lib/* -d . DeleteBucket.java
copy
7）运行 DeleteBucket 类代码，查询桶内对象列表和获取对象；
java -cp .:./lib/* com.sequoiadb.samples.DeleteBucket
copy
8）检查桶是否存在，确认结果中是否存在桶 javabucket；
curl -v GET "http://localhost:8002" -H "Host: localhost:8002" -H "Authorization: AWS ABCDEFGHIJKLMNOPQRST:abcdefghijklmnopqrstuvwxyz0123456789ABCD"
copy
12. 总结
在本课程中我们通过 AWS S3 的 Rest 接口访问 SequoiaS3 实例，从而实现文件的上传、下载和删除操作，通过 JAVA 开发语言展示了使用 S3 的接口创建删除桶、上传下载对象等操作。
六、NFS文件系统部署与应用开发
1. 课程介绍
本课程将带领您在已经安装部署 SequoiaDB 巨杉数据库的环境中部署 SequoiaFS 文件系统，及使用 Linux Shell 和 JAVA 开发语言对文件和目录进行操作。
SequoiaFS 文件系统简介
SequoiaFS 文件系统是基于 FUSE 在 Linux 系统下实现的一套文件系统，支持通用的文件操作 API。SequoiaFS 利用 SequoiaDB 的元数据集合存储文件和目录的属性信息，lob 对象存储文件的数据内容，从而实现了类似 NFS 分布式网络文件系统。用户可以将远程 SequoiaDB 的某个目标集合通过映射的方式挂载到本地 FS 节点，在 FS 节点的挂载目录下实现通过通用文件系统 API 对文件和目录进行操作。
请点击右侧选择使用的实验环境
部署架构：
本课程中 SequoiaDB 巨杉数据库的集群拓扑结构为三分区单副本，包括1个 SequoiaFS 实例、1个引擎协调节点，1个编目节点与3个数据节点。
图片描述
详细了解 SequoiaDB 巨杉数据库系统架构：
SequoiaDB 系统架构
实验环境
课程使用的实验环境为 Ubuntu Linux 16.04 64 位版本，SequoiaDB 数据库引擎以及 SequoiaFS 实例均为 3.4 版本。
2. 切换用户及查看数据库版本
切换到 sdbadmin 用户
部署 SequoiaDB 巨杉数据库和 SequoiaFS 实例的操作系统用户为 sdbadmin。
su - sdbadmin
copy
Note:
用户 sdbadmin 的密码为 sdbadmin
查看巨杉数据库版本
查看 SequoiaDB 巨杉数据库引擎版本：
sequoiadb --version
3. 环境检查及配置
查看节点启动列表
查看 SequoiaDB 巨杉数据库引擎节点列表：
sdblist
copy
操作截图：
图片描述
Note:
如果显示的节点数量与预期不符，请稍等初始化完成并重试该步骤。
C: 编目节点，S：协调节点，D：数据节点
检查 fuse 依赖包
检查 fuse 是否安装,在本例中，已经安装了fuse 2.9.4：
fusermount --version
copy
操作截图：
图片描述
查看 SequoiaFS 实例程序
ls /opt/sequoiadb/bin/sequoiafs
copy
4. 创建集合空间和集合
进入 SequoiaDB Shell，在 SequoiaDB 中创建测试用的集合空间和集合 fscs.fscl，用于存放存储在巨杉数据库中的文件系统文件。
1）通过 Linux 命令行进入 SequoiaDB Shell；
sdb
copy
2）通过 javascript 语言连接协调节点，获取数据库连接；
var db = new Sdb("localhost", 11810);
copy
3）创建 fs_domain 逻辑域；
db.createDomain("fs_domain", [ "group1", "group2", "group3" ], { AutoSplit: true } );
copy
4）创建 fscs 集合空间；
db.createCS("fscs", { Domain: "fs_domain" } );
copy
5）创建 fscl 集合；
db.fscs.createCL("fscl", { "ShardingKey": { "_id": 1}, "ShardingType": "hash", "ReplSize": -1, "Compressed": true, "CompressionType": "lzw", "AutoSplit": true, "EnsureShardingIndex": false } );
copy
6）退出 SequoiaDB Shell；
quit;
copy
5. 创建挂载点及配置文件
SequoiaFS 实例将集合 fscl 通过映射的方式挂载到 /opt/sequoiadb/sequoiafs/mountpoint 目录，从而在挂载目录下实现通过通用文件系统 API 对文件和目录进行操作。
1）创建挂载点 mountpoint；
mkdir -p /opt/sequoiadb/sequoiafs/mountpoint
copy
2）以 sdbadmin 用户登录，创建sequoiafs的配置文件目录和日志目录；
mkdir -p /opt/sequoiadb/sequoiafs/conf/fscs_fscl/001/
mkdir -p /opt/sequoiadb/sequoiafs/log/fscs_fscl/001/
copy
3）生成一个空的配置文件，SequoiaFS 服务在启动时会将指定的值写入该文件中，其他参数使用缺省值；
touch /opt/sequoiadb/sequoiafs/conf/fscs_fscl/001/sequoiafs.conf
6. 启动 SequoiaFS 服务
启动服务之后 mountpoint 目录下的所有文件信息会存放在远程数据库节点上，可以在数据库的目录元数据集合及文件元数据集合中查看，文件内容会以 LOB对象 的形式存放在目标集合下。
sequoiafs /opt/sequoiadb/sequoiafs/mountpoint -i localhost:11810 -l fscs.fscl --autocreate -c /opt/sequoiadb/sequoiafs/conf/fscs_fscl/001/ --diagpath /opt/sequoiadb/sequoiafs/log/fscs_fscl/001/ -o big_writes -o max_write=131072 -o max_read=131072
copy
Note:
指定数据库的协调节点通过 -i (或 --hosts) 进行指定； 目录元数据集合可以通过 -d (或--metadircollection) 进行指定；
文件元数据集合可以通过 -f (或--metafilecollection) 进行指定；
以上参数可以直接通过指定--autocreate默认生成，该例指定默认生成；
挂载目录时，除了目标集合collection外，还需要指定一系列参数，具体参数选项详情请查看选项。SequoiaFS 实例参数配置
7. 查看挂载目录和和底层存储信息
上一小节已经完成了目录的挂载，接下来我们对挂载的信息和 SequoiaDB 巨杉数据库的底层数据进行查看，确认在巨杉数据库底层是否已经自动生成与挂载相关的信息相关的集合。
1）本地 SequoiaFS 节点通过 mount 可以看到挂载信息；
mount
copy
操作截图：
图片描述
可以看到 /opt/sequoiadb/sequoiafs/mountpoint 已经通过 sequoiafs 已经挂载上了，文件系统类型为 fuse.sequoiafs。
2）通过 Linux 命令行进入 SequoiaDB Shell ，在 SequoiaDB 节点可以查看相关挂载信息；
sdb
copy
3）通过 javascript 语言连接协调节点，获取数据库连接；
var db = new Sdb("localhost", 11810);
copy
4）查看创建的集合信息
db.list(SDB_LIST_COLLECTIONS);
copy
操作截图：
图片描述
5）sequoiafs.maphistory 为映射挂载历史信息表，记录历史挂载的关键数据信息。
db.sequoiafs.maphistory.find();
copy
操作截图：
图片描述
Note:
对于每次 mount，可以通过 sequoiafs.maphistory 查看映射挂载历史信息。
历史信息记录中描述说明：SourceCL：目标映射集合名称，DirMetaCL：目录元数据集合名称，FileMetaCL：文件元数据集合名称，Address：FS节点地址，MountPoint：FS节点挂载时的目录。
sequoiafs.fscl_dir 和 fscl_file 分别为目录和文件的元数据集合表，由于 SequoiaFS 启动挂载时指定了--autocreate，所以这里是默认生成的，用以记录 FS 挂载目录下的目录和文件信息。
6）退出 SequoiaDB Shell；
quit;
8. 挂载目录下文件、目录操作
使用 Linux 命令直接在挂载的目录进行文件和目录的操作。
创建目录
进入到 /opt/sequoiadb/sequoiafs/mountpoint/ 中，创建目录 fsdir 并查看。
1）进入挂载目录；
cd /opt/sequoiadb/sequoiafs/mountpoint/
copy
2）创建目录；
mkdir fsdir
copy
3）查看目录是否存在；
ls -trl
copy
创建文件并写入内容
进入到 /opt/sequoiadb/sequoiafs/mountpoint/fsdir 中，创建文件 fsfile 并写入内容。
1）进入创建的 fsdir 目录；
cd /opt/sequoiadb/sequoiafs/mountpoint/fsdir
copy
2）使用 echo 重定向内容创建文件；
echo 'hello, this is a fsfile!' >> fsfile.txt
copy
3）查看文件内容是否存在；
cat fsfile.txt
9. 查看挂载目录创建的文件及存储内容
确认在本地 FS 节点进行操作的文件是否已经存储在了对应的集合空间下。
1）通过 Linux 命令行进入 SequoiaDB Shell；，查看文件和目录是否在 SequoiaDB 数据库存储引擎中存储情况；
sdb
copy
2）通过 javascript 语言连接协调节点，获取数据库连接；
var db = new Sdb("localhost", 11810);
copy
3）查看数据库中文件存储情况；
db.sequoiafs.fscl_file142361856883863522.find();
copy
操作截图： 图片描述
4）查看数据库中目录存储情况；
db.sequoiafs.fscl_dir142361856883863522.find();
copy
操作截图： 图片描述
Note:
fscl_file142361856883863522,fscl_dir142361856883863522是自动产生的，有可能和课程中产生的不一样，可以使用: db.list(SDB_LIST_COLLECTIONS)查看。
5）查看集合中的 LOB 信息， 文件已经保存为一条 LOB 记录
db.fscs.fscl.listLobs();
copy
操作截图： 图片描述
6）退出SequoiaDB Shell；
quit;
10. 创建 JAVA 工程项目
本小节学习使用 JAVA 开发语言对挂载后的目录进行创建目录和复制文件的操作。
1）创建 JAVA 工程目录；
mkdir -p /home/sdbadmin/nfs
copy
2）进入工程目录；
cd /home/sdbadmin/nfs
copy
4）复制以下代码到实验环境终端执行生成 CopyFile.java 文件，用于操作 NFS 文件系统；
cat > /home/sdbadmin/nfs/CopyFile.java << EOF
package com.sequoiadb.samples;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class CopyFile {
public static void main(String[] args) throws IOException {
// 创建目录
File dir = new File("/opt/sequoiadb/sequoiafs/mountpoint/fsdir/cpdir");
if (!dir.exists()) {
dir.mkdirs();
System.out.println("Directory created successfully");
} else {
System.out.println("Directory already exists");
}
// 复制文件到新目录
File source = new File("/opt/sequoiadb/sequoiafs/mountpoint/fsdir/fsfile.txt");
File dest = new File("/opt/sequoiadb/sequoiafs/mountpoint/fsdir/cpdir/fsfile.txt");
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream(source);
output = new FileOutputStream(dest);
byte[] buf = new byte[1024];
int bytesRead;
while ((bytesRead = input.read(buf)) != -1) {
output.write(buf, 0, bytesRead);
}
System.out.println("File copied successfully");
} finally {
input.close();
output.close();
}
}}
EOF
copy
4）查询是否已经生成 CopyFile.java 文件；
ls -trl /home/sdbadmin/nfs/CopyFile.java
11. 编译运行代码
上一小节已经创建了 JAVA 工程和代码，接下来我们对代码进行编译运行。
1）编译 Select.java 文件；
javac -d . CopyFile.java
copy
2）运行 Select 类代码，查询数据；
java -cp .:./lib/* com.sequoiadb.samples.CopyFile
copy
操作截图：
图片描述
3）检查复制后的文件内容；
cat /opt/sequoiadb/sequoiafs/mountpoint/fsdir/cpdir/fsfile.txt
copy
操作截图：
12. 总结
通过本课程，我们验证了 SequoiaDB 巨杉数据库所支持的 NFS文件系统存储，并对底层数据存储分布进行了直接验证。可以看出：
SequoiaFS 实例支持通过操作系统文件系统接口访问 SequoiaDB；
SequoiaDB 巨杉数据库底层存储为分布式架构，数据可均匀分布在多个分区中；
七、考试
此考试是在完成部署 SequoiaDB 巨杉数据库引擎的环境中使用 JSON 实例完成对数据进行操作、启动和使用 SequoiaFS 服务。
SequoiaDB巨杉数据库采用“计算存储分离”架构，支持 MySQL、PostgreSQL 与 SparkSQL 三种关系型数据库实例、类 MongoDB 的 JSON 文档类数据库实例、以及 S3 对象存储与 Posix 文件系统的非结构化数据实例。
Note:
考试内容需在系统用户 sdbadmin 下完成，用户密码为 sdbadmin
SequoiaDB 巨杉数据库安装目录（/opt/sequoiadb）
FUSE（用户空间文件系统） 已经通过在线方式安装
知识点
1）创建集合空间和集合；
2）基于 SequoiaDB 巨杉数据库引擎 JSON 实例 的 CRUD 操作；
3）启动和使用 SequoiaFS 服务；
考试内容
JSON 实例应用
1）创建域 company_domain ，在域下创建集合空间 company ， 在集合空间下创建集合 employee ；
2）给创建的 employee 集合插入下面 6 条数据；
{ "empno": 10001, "ename": "Georgi", "age": 48 }
{ "empno": 10002, "ename": "Bezalel", "age": 21 }
{ "empno": 10003, "ename": "Parto", "age": 33 }
{ "empno": 10004, "ename": "Chirstian", "age": 40 }
{ "empno": 10005, "ename": "Kyoichi", "age": 23 }
{ "empno": 10006, "ename": "Anneke", "age": 19 }
3）连接查询集合 employee 中age 大于20，小于30的数据；
4）将集合 employee 中 empno 为 10001 的记录的 age 更改为34；
5）删除集合 employee 中 empno 为 10006 的记录删除；
SequoiaFS 实例应用
1） 创建 fs_domain 域使用,在此域下创建集合空间 fscs，在此集合空间下创建集合 fscl ；
2）创建挂载点目录" /opt/sequoiadb/sequoiafs/mountpoint "；
3） 创建 SequoiaFS 的配置文件夹" /opt/sequoiadb/sequoiafs/conf/fscs_fscl/001/ "和日志目录" /opt/sequoiadb/sequoiafs/log/fscs_fscl/001/ " ；
4） 生成一个空的配置文件，SequoiaFS 服务在启动时会将指定的值写入该文件中，其他参数使用缺省值" /opt/sequoiadb/sequoiafs/conf/fscs_fscl/001/sequoiafs.conf " ；
5）启动 SequoiaFS 服务，挂载上面创建的目录（可参考学习章节 “启动 SequoiaFS 服务” 相关内容 ）；
6） 在 mount 目录下创建子目录 fsdir ，且在这个目录下创建文件 fsfile.txt 向文件 fsfile.txt 写入 " hello, this is a fsfile ! "；
7） 在数据库检查是否将文件夹中的文件挂载上去 ；
S3 对象存储部署
1）开启 RC 级别事务为读已提交，且配置为等锁模式；
2）创建元数据逻辑域；
3）创建对象数据逻辑域；
4）配置启动 SequoiaS3 实例；
5）创建桶 exambucket；
6）向 exambucket 中写入文件"/opt/sequoiadb/version.conf"，命名为"version.conf"；
7）从桶 exambucket 中下载文件对象 "version.conf" 保存为 /home/sdbadmin/version.conf ；
考试要求
1）使用 JSON 实例创建集合空间和集合；
2）使用 JSON 实例完成数据的增、删、查、改功能；
3）创建 NFS 域 fs_domain，启动和使用 SequoiaFS 服务；
4）创建 S3 专属域 S3_domain，开启 RC 事务级别,修改 S3 相应配置文件并启动 SequoiaS3 实例；
CVTE一面86人在聊