解锁YashanDB 23.2 YAC 共享集群部署实战：国产数据库的崛起！

本文链接：https://blog.csdn.net/Zhiyilang/article/details/146083940

前言

大家好，我是小支同学，今天来和大家聊聊国产数据库的崛起之路。在数据库领域，Oracle、MySQL、PostgreSQL 等一直是主流选择，但随着信创（信息技术应用创新）的推进，国产数据库逐渐崭露头角。今天，我就来分享一下我在学习和部署 YashanDB 过程中的经验，以及如何在实际环境中使用它。

一、初识 YashanDB

YashanDB 是由崖山数据库团队开发的一款高性能、高可用的企业级数据库。它不仅支持传统的关系型数据库功能，还具备分布式、共享集群等先进特性，能够满足不同场景下的业务需求。 YashanDB 的核心优势在于其对 Oracle 的高度兼容性，这意味着使用 Oracle 的用户可以无缝迁移到 YashanDB，而无需对应用进行大量改造。

二、上手 YashanDB

（一）安装部署

官方文档中写到 YashanDB 能与 Oracle 完全兼容，基于以上信息，YashanDB 的学习成本大大降低了。由于我对 Oracle 的接触不多，因此选择从头开始阅读 YashanDB 的官方文档。首先要体验数据库，那就得先安装部署它。YashanDB 的安装部署并不算困难，按照官方文档的步骤，可以很顺利地完成部署。

（二）图形化工具

经过一段时间的折腾，我也成功启动了 YashanDB。看着熟悉的界面，我立马就知道该如何往下操作了。如果对这个界面写 SQL 不太适应，YashanDB 官方也提供了一个图形化工具 DBeaver for YashanDB，部署起来就能通过图形化界面来操作数据库。

（三）学习资源

目前关于 YashanDB 的学习还只是初步探索，但官方提供了一系列工具，例如数据迁移工具、监控运维工具，可见 YashanDB 的使用将会很方便。此外，YashanDB 最近在开展 YCA 免费认证活动，技多不压身，了解一下也是好的。

TPCC-C简介;

(1)TPC-C测试是针对业务处理系统的规范，由TPC（Transaction Processing Performance Council）委员会制定。该测试模拟了大型商品批发商的交易业务场景，包括库存查询、新订单提交、支付费用、发货和查询订单状态等五类事务。通过对这些事务的处理能力进行测试，可以评估数据库系统的吞吐量、响应时间等关键性能指标。

(2)TPC-C测试中模拟了大型商品批发商的交易业务场景，该批发商总共生产销售100000种产品，拥有多个负责不同区域的商品仓库，每个仓库需要为10个分销商进行供货，且每个分销商需要为3000个客户进行服务，对数据库进行TPC-C测试时可根据服务器及数据库的配置对商品仓库的数量进行调整，从而模拟出不同的压力场景。

业务场景中主要包含如下5类事务：

Stock-Level：用于表示分销商库存状态，库存较低时需要进行补货。
New-Order：用于表示客户提交了一笔新订单，每笔订单平均包括10件产品。

Payment：用于表示客户为订单支付费用，更新其账户余额。
Delivery：用于表示根据用户提交的订单进行发货。
Order-Status：用于表查询用户的最近交易状态。

测试环境准备

BenchmarkSQL是一个开源的Java程序，用于在数据库上运行TPC-C测试。在测试之前，需要从官方渠道下载BenchmarkSQL工具，并根据YashanDB数据库的特点进行相应的配置。这包括修改Java文件、编译源码以及创建必要的配置文件等步骤，使之支持YashanDB数据库。

1、TPC-C测试工具下载

请自行于BenchmarkSQL官网下载BenchmarkSQL5 :https://sourceforge.net/projects/benchmarksql/https://sourceforge.net/projects/benchmarksql/

2、请确保服务器中已有JDK1.8及以上版本的JDK。

[root@worker2 benchmarksql-5.0]# java -version
openjdk version "1.8.0_412"
OpenJDK Runtime Environment (build 1.8.0_412-b08)
OpenJDK 64-Bit Server VM (build 25.412-b08, mixed mode)

3、创建目录并解压BenchmarkSQL5

[root@worker2 redo]# mkdir tpc-c
[root@worker2 redo]# cd tpc-c/
[root@worker2 tpc-c]#

解压

[root@worker2 redo]# cd tpc-c/
[root@worker2 tpc-c]# ls
benchmarksql-5.0.zip
[root@worker2 tpc-c]# unzip benchmarksql-5.0.zip 
Archive:  benchmarksql-5.0.zip
6036b15716cf8c142465ac8092d53a777d609684
   creating: benchmarksql-5.0/

4、修改jTPCC.java文件

在操作系统终端执行如下命令并输入密码，切换至root用户。

4.1 执行如下命令，进入tpc-c目录:

[root@worker2 redo]# cd tpc-c/
[root@worker2 tpc-c]# ls
benchmarksql-5.0  benchmarksql-5.0.zip
[root@worker2 tpc-c]#

4.2编辑jTPCC.java文件

执行如下命令，在vi编辑器中打开/home/yashan/tpc-c/benchmarksql-5.0/src/client/jTPCC.java文件，请注意区分大小写：

[root@worker2 tpc-c]# vim benchmarksql-5.0/src/client/jTPCC.java

4.3 在文件中查找下图内容：

4.3 新增 dbType

按i进入编辑模式，在dbType = DB_POSTGRES后新增如下内容：

else if (iDB.equals("yashandb"))
   dbType = DB_YASHANDB;

修改完成后，按Esc，输入:wq保存并退出文件编辑。

5、修改jTPCCConfig.java文件

5.1编辑jTPCCConfig.java文件

执行如下命令，在vi编辑器中打开jTPCCConfig.java文件：

[root@worker2 tpc-c]# vim benchmarksql-5.0/src/client/jTPCCConfig.java 
[root@worker2 tpc-c]#

5.2 在文件中查找下图内容：

5.3 新增 DB_YASHANDB

按i进入编辑模式，将该部分内容修改为如下内容：

public final static int DB_UNKNOWN = 0,
			DB_FIREBIRD = 1,
			DB_ORACLE = 2,
			DB_POSTGRES = 3,
			DB_YASHANDB = 4;

修改完成后，按Esc，输入:wq保存并退出文件编辑。

6、编译源码

执行如下命令进入benchmarksql-5.0目录，并执行ant命令进行编译：

[root@worker2 tpc-c]# cd benchmarksql-5.0/
[root@worker2 benchmarksql-5.0]# ls
build.xml  doc  HOW-TO-RUN.txt  lib  README.md  run  src
[root@worker2 benchmarksql-5.0]# ant
-bash: ant: command not found
[root@worker2 benchmarksql-5.0]#

注意：如此时返回ant:command not found，可通过执行yum install ant安装ant编译工具。

[root@worker2 benchmarksql-5.0]# yum install ant
Loaded plugins: fastestmirror

再次执行ant命令进行编译：

[root@worker2 tpc-c]# cd benchmarksql-5.0/
[root@worker2 benchmarksql-5.0]# ant
Buildfile: /redo/tpc-c/benchmarksql-5.0/build.xml
 
init:
 
compile:
    [javac] Compiling 11 source files to /redo/tpc-c/benchmarksql-5.0/build
 
dist:
      [jar] Building jar: /redo/tpc-c/benchmarksql-5.0/dist/BenchmarkSQL-5.0.jar
 
BUILD SUCCESSFUL
Total time: 1 second
[root@worker2 benchmarksql-5.0]#

7、创建文件props.yashandb

7.1 进入benchmarksql-5.0/run目录

执行如下命令，进入/home/yashan/tpc-c/benchmarksql-5.0/run目录：

[root@worker2 tpc-c]# cd benchmarksql-5.0/
[root@worker2 benchmarksql-5.0]# cd run/
[root@worker2 run]# ls
funcs.sh           log4j.properties  props.ora        runDatabaseBuild.sh    runSQL.sh     sql.oracle
generateGraphs.sh  misc              props.pg         runDatabaseDestroy.sh  sql.common    sql.postgres
generateReport.sh  props.fb          runBenchmark.sh  runLoader.sh           sql.firebird
[root@worker2 run]#

7.2 创建文件props.yashandb

执行如下命令，通过vi编辑器创建文件props.yashandb：

[root@worker2 run]# vim props.yashandb

按i进入编辑模式，将如下内容新增至文件中（可根据实际环境进行修改）：

db=yashandb
driver=com.yashandb.jdbc.Driver
conn=jdbc:yasdb://172.20.2.122:1688/yashandb
user=sys
password=w3UjbGI%@6ND
warehouses=10
loadWorkers=2
terminals=10
runTxnsPerTerminal=0
runMins=5
limitTxnsPerMin=0
terminalWarehouseFixed=true
newOrderWeight=45
paymentWeight=43
orderStatusWeight=4
deliveryWeight=4
stockLevelWeight=4
resultDirectory=my_result_%tY-%tm-%td_%tH%tM%tS
osCollectorScript=./misc/os_collector_linux.py
osCollectorInterval=1

其中：

参数 含义
db 数据库，须与上述修改文件中添加的数据库名称相同
driver 驱动程序文件，须使用YashanDB的JDBC驱动
conn 连接描述符，格式为：conn=jdbc:yasdb://ip:port/database_name
user 数据库用户
password 数据库用户的密码
warehouses 用于指定测试中商品仓库的数量，通常测试场景为100~1000仓
loadWorkers 数据导入的并发数，通常设置为CPU线程总数的2~4倍
terminals 业务运行的并发数，通常设置为CPU线程总数的2~4倍
runTxnsPerTerminal 每个会话运行的固定事务数量，通常配置为0，以runMins限制测试时间
runMins 用于指定测试运行的时间，通常建议压测时间为10~30分钟
limitTxnsPerMin 每秒事务数上限，压测场景下通常设置为0
terminalWarehouseFixed 会话和仓库的绑定模式，通常设置为true
newOrderWeight
paymentWeight
orderStatusWeight
deliveryWeight
stockLevelWeight 五种事务的占比，所有值的和须为100
标准的业务比率配置为45:43:4:4:4
resultDirectory 指定存储测试结果的目录。%tY、%tm、%td、%tH、%tM和%tS是时间格式化参数
osCollectorScript 指定操作系统收集器的脚本路径。通常用于收集操作系统资源使用情况的统计信息，例如CPU使用率、内存使用情况、磁盘I/O等
osCollectorInterval 指定操作系统收集器脚本运行间隔（单位：秒）
修改完成后，按Esc，输入:wq保存并退出文件编辑。

8、修改文件funcs.sh

执行如下命令，在vi编辑器中打开funcs.sh文件：

[root@worker2 run]# ls
funcs.sh           log4j.properties  props.ora       runBenchmark.sh        runLoader.sh  sql.firebird
generateGraphs.sh  misc              props.pg        runDatabaseBuild.sh    runSQL.sh     sql.oracle
generateReport.sh  props.fb          props.yashandb  runDatabaseDestroy.sh  sql.common    sql.postgres
[root@worker2 run]# vim funcs.sh

按i进入编辑模式，将文档内容替换为如下内容：

# ----
# $1 is the properties file
# ----
PROPS=$1
if [ ! -f ${PROPS} ] ; then
    echo "${PROPS}: no such file" >&2
    exit 1
fi
 
# ----
# getProp()
#
#   Get a config value from the properties file.
# ----
function getProp()
{
    grep "^${1}=" ${PROPS} | sed -e "s/^${1}=//"
}
 
# ----
# getCP()
#
#   Determine the CLASSPATH based on the database system.
# ----
function setCP()
{
    case "$(getProp db)" in
        firebird)
            cp="../lib/firebird/*:../lib/*"
            ;;
        oracle)
            cp="../lib/oracle/*"
            if [ ! -z "${ORACLE_HOME}" -a -d ${ORACLE_HOME}/lib ] ; then
                cp="${cp}:${ORACLE_HOME}/lib/*"
            fi
            cp="${cp}:../lib/*"
            ;;
        postgres)
            cp="../lib/postgres/*:../lib/*"
            ;;
        yashandb)
            cp="../lib/yashandb/*:../lib/*"
            ;;
    esac
    myCP=".:${cp}:../dist/*"
    export myCP
}
 
# ----
# Make sure that the properties file does have db= and the value
# is a database, we support.
# ----
case "$(getProp db)" in
    firebird|oracle|postgres|yashandb)
        ;;
    "") echo "ERROR: missing db= config option in ${PROPS}" >&2
        exit 1
        ;;
    *)  echo "ERROR: unsupported database type 'db=$(getProp db)' in ${PROPS}" >&2
        exit 1
        ;;
esac

修改完成后，按Esc，输入:wq保存并退出文件编辑。

9、添加yashandb java connector驱动

执行此步骤前须确保已安装YashanDB JDBC驱动，本例中驱动包所在路径为/home/yashan/yashandb_jdbc/。

ODBC驱动安装（Linux）
本文以Centos 7.3.1为例，介绍YashanDB ODBC驱动在该环境下的安装配置过程。

9.1：安装unixODBC

[root@worker2 redo]# yum install unixODBC-devel
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.aliyun.com
 * epel: repo.jing.rocks
 * extras: mirrors.aliyun.com
 * updates: mirrors.aliyun.com
Resolving Dependencies
--> Running transaction check
---> Package unixODBC-devel.x86_64 0:2.3.1-14.el7 will be installed

9.2：下载C驱动安装包

参考YashanDB软件包清单获取YashanDB客户端安装包。

[root@worker2 redo]# cd yasdb-driver-c/
[root@worker2 yasdb-driver-c]# ls
yashandb-odbc-23.3.1.100-linux-x86_64  yashandb-odbc-23.3.1.100-linux-x86_64.tar.gz
[root@worker2 yasdb-driver-c]# ls
yashandb-jdbc-1.8.0.jar  yashandb-odbc-23.3.1.100-linux-x86_64  yashandb-odbc-23.3.1.100-linux-x86_64.tar.gz
[root@worker2 yasdb-driver-c]# pwd
/redo/yasdb-driver-c

9.3：安装ODBC驱动
参考YashanDB软件包清单获取YashanDB ODBC驱动安装包。

将ODBC驱动安装包下载并解压到本地路径，例如/home/yashandb_odbc/。

安装ODBC驱动（so路径仅为示例，请使用实际的libyas_odbc.so路径）。

[root@worker2 yashandb-odbc-23.3.1.100-linux-x86_64]# vim /etc/odbcinst.ini
 
[YashanDB]
Description     = ODBC for YashanDB
Driver          = /redo/yasdb-driver-c/yashandb-odbc-23.3.1.100-linux-x86_64/libyas_odbc.so
Setup           = /redo/yasdb-driver-c/yashandb-odbc-23.3.1.100-linux-x86_64/libyas_odbc.so
Driver64        = /redo/yasdb-driver-c/yashandb-odbc-23.3.1.100-linux-x86_64/libyas_odbc.so
Setup64         = /redo/yasdb-driver-c/yashandb-odbc-23.3.1.100-linux-x86_64/libyas_odbc.so
FileUsage       = 1

9.4：配置数据源

[root@worker2 yashandb-odbc-23.3.1.100-linux-x86_64]# vim /etc/odbc.ini
 
[YASTEST]
Description  = YashanTest
Driver       = YashanDB
SERVER       = 172.10.1.122
PORT         = 1688
USER         = sys
PWD          = ******

9.5 执行如下命令添加驱动：

[root@worker2 yasdb-driver-c]# ls
yashandb-jdbc-1.8.0.jar  yashandb-odbc-23.3.1.100-linux-x86_64  yashandb-odbc-23.3.1.100-linux-x86_64.tar.gz
[root@worker2 yasdb-driver-c]# pwd
/redo/yasdb-driver-c
[root@worker2 yasdb-driver-c]# cp yashandb-jdbc-1.8.0.jar /redo/tpc-c/benchmarksql-5.0/lib/yashandb/
[root@worker2 yasdb-driver-c]#

10、修改runDatabaseBuild.sh文件

执行如下命令，在vi编辑器中打开runDatabaseBuild.sh文件：
$ vi /home/yashan/tpc-c/benchmarksql-5.0/run/runDatabaseBuild.sh
Copied!
在文件中查找下图内容：按i进入编辑模式，将该部分内容修改为如下内容：

AFTER_LOAD="indexCreates foreignKeys buildFinish"

修改完成后，按Esc，输入:wq保存并退出文件编辑哦~

三、TPC-C测试运行

1、部署YashanDB数据库

在进行TPC-C测试之前，需要确保YashanDB单机数据库已经正确部署，并且具备稳定的运行环境。这包括安装必要的软件、配置数据库参数以及进行初步的性能调优等工作。部署YashanDB数据库参考：https://blog.csdn.net/Zhiyilang/article/details/146083961?sharetype=blogdetail&sharerId=146083961&sharerefer=PC&sharesource=Zhiyilang&spm=1011.2480.3001.8118https://blog.csdn.net/Zhiyilang/article/details/146083961?sharetype=blogdetail&sharerId=146083961&sharerefer=PC&sharesource=Zhiyilang&spm=1011.2480.3001.8118

2、数据库性能调优

最佳性能数据会因为测试环境的CPU、内存、IO、网络条件差异而不同，为了让YashanDB在测试环境上达到最佳的TPC-C性能表现，需要根据测试环境的配置进行性能调优，数据库性能调优的详细信息请查阅YashanDB性能调优文档。

在进行TPC-C测试之前，需要对YashanDB数据库进行性能调优。这包括调整数据缓存区大小、分区数、VM缓冲区大小等关键参数，以及优化数据库建库配置等。通过合理的性能调优，可以充分发挥YashanDB数据库的性能潜力，提高测试结果的准确性和可靠性。

在TPC-C测试场景下主要关注缓存大小与分区、IO参数等性能参数的配置。

以1000仓、256并发的测试场景为例，推荐配置以下性能调优参数：

# Data buffer用于数据块的缓存，其大小会影响数据访问的缓存命中率。建议将规划内存的80%配置为数据缓存区，如果缓存区的大小大于总数据大小可取得最佳性能。
DATA_BUFFER_SIZE=200G   
# Data buffer的分区数，在大并发的测试场景下，将Data buffer分区可以降低缓存区的锁冲突。
_DATA_BUFFER_PARTS=8         
# VM Buffer用于保存例如order/group by等数据运算的中间结果，当VM空间不足时会产生内存与SWAP表空间的换入，影响数据库性能表现。
# 因此需要配置合理的VM Buffer大小以避免换入的产生。通过视图V$VM中的SWAPPED_OUT_BLOCKS字段可以获取SWAP的次数，当为0时可以取到最佳性能。
VM_BUFFER_SIZE=25G     
# VM Buffer的分区数，在大并发的测试场景下，将VM buffer可以降低缓存区的锁冲突。
VM_BUFFER_PARTS=8
# 全局大页内存区大小，在大并发的测试场景下，需要提高配置以避免资源不足。
LARGE_POOL_SIZE=1G
# 全局执行内存区大小，在大并发的测试场景下，需要提高配置以避免资源不足。
WORK_AREA_POOL_SIZE=2G
# undo数据的保留时间，用于一致性读或者数据闪回。对于类似TPC-C小事务的场景下，降低undo数据的保留时间可以提高undo分配效率，提升数据库性能。
UNDO_RETENTION=15
# 会话级CURSOR的数量，在大并发的测试场景下提高配置可以消除全局CURSOR的竞争。
_SESSION_RESERVED_CURSORS=64
# 增量Checkpoint的时间间隔，后台脏块刷盘会与redo刷盘产生IO争用，在DATA和redo同盘部署的场景下，降低Checkpoint频率可以提升数据库性能。
CHECKPOINT_TIMEOUT=900
# 指定触发checkpoint的从恢复点到当前redo日志刷盘点的redo大小间隔，通常配置为redo文件总大小的一半。
CHECKPOINT_INTERVAL=10G
# 共享内存池的大小，提高配置以避免SQL缓存或者元数据缓存的频繁失效。
SHARE_POOL_SIZE=2G

数据库配置参数的详细说明请查阅官方文档配置参数。

3、数据库建库配置调优

安装部署后，YashanDB将默认创建一个初始数据库，可根据实际需求删除初始数据库（DROP DATABASE）后自定义创建数据库（不适用于标准版或企业版的分布式部署）。
创建数据库时主要关注以下方面：

redo文件的大小：redo文件配置太小，在压测场景下容易出现redo追尾的情况，严重影响数据库性能。通过V$SYSTEM_EVENT视图中的“checkpoint completed”的等待事件判断是否出现redo追尾的情况。
DATA文件的大小：预占数据空间可以避免数据库运行过程中空间动态扩展对性能的影响，因此为了最佳性能表现，需要初始化足够大的表空间。
在实际使用过程中，也应及时调整redo文件、DATA文件等相关配置，具体可查阅文件管理。

如果存储条件允许，请将redo文件与数据文件分盘部署，以减少两者间的IO争用，以1000仓、256并发的测试场景为例，推荐的建库语句如下：

CREATE DATABASE tpcc LOGFILE(’/data1/redo1’ size 5G BLOCKSIZE 512,’/data1/redo2’ size 5G BLOCKSIZE 512,’/data1/redo3’ size 5G BLOCKSIZE 512,’/data1/redo4’ size 5G BLOCKSIZE 512,’/data1/redo5’ size 5G BLOCKSIZE 512,’/data1/redo6’ size 5G BLOCKSIZE 512,’/data1/redo7’ size 5G BLOCKSIZE 512,’/data1/redo8’ size 5G BLOCKSIZE 512,’/data1/redo9’ size 5G BLOCKSIZE 512,’/data1/redo10’ size 5G BLOCKSIZE 512)UNDO TABLESPACE DATAFILE ‘/redo/data2/undo’ size 10G SWAP TABLESPACE TEMPFILE ‘/redo/data2/swap’ size 10G SYSTEM TABLESPACE DATAFILE ‘/redo/data2/system’ size 5G SYSAUX TABLESPACE DATAFILE ‘/redo/data2/sysaux’ size 5G DEFAULT TABLESPACE DATAFILE ‘/redo/data2/users’ size 100G;

数据库配置参数和建库配置调优的详细介绍请查阅数据库配置调优。

4、清理TPC-C数据

在正式进行TPC-C测试之前，需要清理数据库中与TPC-C测试相关的旧数据。这可以通过执行BenchmarkSQL提供的清理脚本来实现。清理数据的目的是为了确保测试环境的一致性，避免旧数据对测试结果产生干扰。
在/home/yashan/tpc-c/benchmarksql-5.0/run目录中，执行如下命令进行数据清理：

[root@worker2 run]# ./runDatabaseDestroy.sh props.yashandb
# ------------------------------------------------------------
# Loading SQL file ./sql.common/tableDrops.sql
# ------------------------------------------------------------
drop table bmsql_config;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_new_order;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_order_line;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_oorder;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_history;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_customer;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_stock;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_item;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_district;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop table bmsql_warehouse;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 12] YAS-02012 table or view does not exist
[line: 1 column: 12] YAS-02012 table or view does not exist
drop sequence bmsql_hist_id_seq;
Dec 09, 2024 5:28:14 PM com.yashandb.log.JDKLoggerAdapter error
SEVERE: [line: 1 column: 15] YAS-02012 sequence does not exist
[line: 1 column: 15] YAS-02012 sequence does not exist
[root@worker2 run]#

5、TPC-C数据装载

在清理完旧数据之后，需要向数据库中装载TPC-C测试所需的新数据。这可以通过执行BenchmarkSQL提供的数据装载脚本来实现。数据装载的过程包括创建必要的表结构、插入初始数据等步骤。确保数据装载的正确性和完整性对于测试结果的准确性至关重要。

目录中执行如下命令进行数据导入：

[root@worker2 run]# ./runDatabaseBuild.sh props.yashandb
# ------------------------------------------------------------
# Loading SQL file ./sql.common/tableCreates.sql
# ------------------------------------------------------------
create table bmsql_config (
cfg_name    varchar(30) primary key,
cfg_value   varchar(50)
);
create table bmsql_warehouse (
w_id        integer   not null,
w_ytd       decimal(12,2),
w_tax       decimal(4,4),
w_name      varchar(10),
w_street_1  varchar(20),
w_street_2  varchar(20),
w_city      varchar(20),
w_state     char(2),
w_zip       char(9)
);
create table bmsql_district (
d_w_id       integer       not null,
d_id         integer       not null,
d_ytd        decimal(12,2),
d_tax        decimal(4,4),
d_next_o_id  integer,
d_name       varchar(10),
d_street_1   varchar(20),
d_street_2   varchar(20),
d_city       varchar(20),
d_state      char(2),
d_zip        char(9)
);
create table bmsql_customer (
c_w_id         integer        not null,
c_d_id         integer        not null,
c_id           integer        not null,
c_discount     decimal(4,4),
c_credit       char(2),
c_last         varchar(16),
c_first        varchar(16),
c_credit_lim   decimal(12,2),
c_balance      decimal(12,2),
c_ytd_payment  decimal(12,2),
c_payment_cnt  integer,
c_delivery_cnt integer,
c_street_1     varchar(20),
c_street_2     varchar(20),
c_city         varchar(20),
c_state        char(2),
c_zip          char(9),
c_phone        char(16),
c_since        timestamp,
c_middle       char(2),
c_data         varchar(500)
);
create sequence bmsql_hist_id_seq;
create table bmsql_history (
hist_id  integer,
h_c_id   integer,
h_c_d_id integer,
h_c_w_id integer,
h_d_id   integer,
h_w_id   integer,
h_date   timestamp,
h_amount decimal(6,2),
h_data   varchar(24)
);
create table bmsql_new_order (
no_w_id  integer   not null,
no_d_id  integer   not null,
no_o_id  integer   not null
);
create table bmsql_oorder (
o_w_id       integer      not null,
o_d_id       integer      not null,
o_id         integer      not null,
o_c_id       integer,
o_carrier_id integer,
o_ol_cnt     integer,
o_all_local  integer,
o_entry_d    timestamp
);
create table bmsql_order_line (
ol_w_id         integer   not null,
ol_d_id         integer   not null,
ol_o_id         integer   not null,
ol_number       integer   not null,
ol_i_id         integer   not null,
ol_delivery_d   timestamp,
ol_amount       decimal(6,2),
ol_supply_w_id  integer,
ol_quantity     integer,
ol_dist_info    char(24)
);
create table bmsql_item (
i_id     integer      not null,
i_name   varchar(24),
i_price  decimal(5,2),
i_data   varchar(50),
i_im_id  integer
);
create table bmsql_stock (
s_w_id       integer       not null,
s_i_id       integer       not null,
s_quantity   integer,
s_ytd        integer,
s_order_cnt  integer,
s_remote_cnt integer,
s_data       varchar(50),
s_dist_01    char(24),
s_dist_02    char(24),
s_dist_03    char(24),
s_dist_04    char(24),
s_dist_05    char(24),
s_dist_06    char(24),
s_dist_07    char(24),
s_dist_08    char(24),
s_dist_09    char(24),
s_dist_10    char(24)
);
Starting BenchmarkSQL LoadData

driver=com.yashandb.jdbc.Driver
conn=jdbc:yasdb://172.20.2.122:1688/yashandb
user=sys
password=***********
warehouses=10
loadWorkers=2
fileLocation (not defined)
csvNullValue (not defined - using default 'NULL')

Worker 000: Loading ITEM
Worker 001: Loading Warehouse      1
Worker 000: Loading ITEM done
Worker 000: Loading Warehouse      2
Worker 001: Loading Warehouse      1 done
Worker 001: Loading Warehouse      3
Worker 000: Loading Warehouse      2 done
Worker 000: Loading Warehouse      4
Worker 001: Loading Warehouse      3 done
Worker 001: Loading Warehouse      5
Worker 000: Loading Warehouse      4 done
Worker 000: Loading Warehouse      6
Worker 001: Loading Warehouse      5 done
Worker 001: Loading Warehouse      7
Worker 000: Loading Warehouse      6 done
Worker 000: Loading Warehouse      8
Worker 001: Loading Warehouse      7 done
Worker 001: Loading Warehouse      9
Worker 000: Loading Warehouse      8 done
Worker 000: Loading Warehouse     10
Worker 001: Loading Warehouse      9 done
Worker 000: Loading Warehouse     10 done
# ------------------------------------------------------------
# Loading SQL file ./sql.common/indexCreates.sql
# ------------------------------------------------------------
alter table bmsql_warehouse add constraint bmsql_warehouse_pkey
primary key (w_id);
alter table bmsql_district add constraint bmsql_district_pkey
primary key (d_w_id, d_id);
alter table bmsql_customer add constraint bmsql_customer_pkey
primary key (c_w_id, c_d_id, c_id);
create index bmsql_customer_idx1
on  bmsql_customer (c_w_id, c_d_id, c_last, c_first);
alter table bmsql_oorder add constraint bmsql_oorder_pkey
primary key (o_w_id, o_d_id, o_id);
create unique index bmsql_oorder_idx1
on  bmsql_oorder (o_w_id, o_d_id, o_carrier_id, o_id);
alter table bmsql_new_order add constraint bmsql_new_order_pkey
primary key (no_w_id, no_d_id, no_o_id);
alter table bmsql_order_line add constraint bmsql_order_line_pkey
primary key (ol_w_id, ol_d_id, ol_o_id, ol_number);
alter table bmsql_stock add constraint bmsql_stock_pkey
primary key (s_w_id, s_i_id);
alter table bmsql_item add constraint bmsql_item_pkey
primary key (i_id);
# ------------------------------------------------------------
# Loading SQL file ./sql.common/foreignKeys.sql
# ------------------------------------------------------------
alter table bmsql_district add constraint d_warehouse_fkey
foreign key (d_w_id)
references bmsql_warehouse (w_id);
alter table bmsql_customer add constraint c_district_fkey
foreign key (c_w_id, c_d_id)
references bmsql_district (d_w_id, d_id);
alter table bmsql_history add constraint h_customer_fkey
foreign key (h_c_w_id, h_c_d_id, h_c_id)
references bmsql_customer (c_w_id, c_d_id, c_id);
alter table bmsql_history add constraint h_district_fkey
foreign key (h_w_id, h_d_id)
references bmsql_district (d_w_id, d_id);
alter table bmsql_new_order add constraint no_order_fkey
foreign key (no_w_id, no_d_id, no_o_id)
references bmsql_oorder (o_w_id, o_d_id, o_id);
alter table bmsql_oorder add constraint o_customer_fkey
foreign key (o_w_id, o_d_id, o_c_id)
references bmsql_customer (c_w_id, c_d_id, c_id);
alter table bmsql_order_line add constraint ol_order_fkey
foreign key (ol_w_id, ol_d_id, ol_o_id)
references bmsql_oorder (o_w_id, o_d_id, o_id);
alter table bmsql_order_line add constraint ol_stock_fkey
foreign key (ol_supply_w_id, ol_i_id)
references bmsql_stock (s_w_id, s_i_id);
alter table bmsql_stock add constraint s_warehouse_fkey
foreign key (s_w_id)
references bmsql_warehouse (w_id);
alter table bmsql_stock add constraint s_item_fkey
foreign key (s_i_id)
references bmsql_item (i_id);
# ------------------------------------------------------------
# Loading SQL file ./sql.common/buildFinish.sql
# ------------------------------------------------------------
-- ----
-- Extra commands to run after the tables are created, loaded,
-- indexes built and extra's created.
-- ----
[root@worker2 run]#

6、运行TPC-C测试

在完成上述准备工作之后，可以开始运行TPC-C测试。通过执行BenchmarkSQL提供的测试脚本，可以模拟出实际的业务场景，对YashanDB数据库进行压力测试。测试过程中，可以实时监控数据库的性能指标，如吞吐量、响应时间等，以便及时发现并解决问题。
数据库连接信息：
数据库名称 (db)：yashandb
JDBC驱动 (driver)：com.yashandb.jdbc.Driver
连接字符串 (conn)：jdbc:yasdb://172.10.1.122:1688/yashandb
用户名 (user)：sys
测试参数
仓库数量 (warehouses)：10
终端数量 (terminals)：10
运行时间 (runMins)：5 分钟
每分钟交易限制 (limitTxnsPerMin)：无限制（设置为 0）
是否固定每个终端到特定的仓库 (terminalWarehouseFixed)：是
交易权重分布
新订单 (newOrderWeight)：45%
支付 (paymentWeight)：43%
订单状态查询 (orderStatusWeight)：4%
配送 (deliveryWeight)：4%
库存水平检查 (stockLevelWeight)：4%
执行如下语句进行TPC-C测试：

[root@worker2 run]# ./runBenchmark.sh props.yashandb
17:33:40,149 [main] INFO   jTPCC : Term-00, 
17:33:40,152 [main] INFO   jTPCC : Term-00, +-------------------------------------------------------------+
17:33:40,152 [main] INFO   jTPCC : Term-00,      BenchmarkSQL v5.0
17:33:40,152 [main] INFO   jTPCC : Term-00, +-------------------------------------------------------------+
17:33:40,152 [main] INFO   jTPCC : Term-00,  (c) 2003, Raul Barbosa
17:33:40,152 [main] INFO   jTPCC : Term-00,  (c) 2004-2016, Denis Lussier
17:33:40,154 [main] INFO   jTPCC : Term-00,  (c) 2016, Jan Wieck
17:33:40,154 [main] INFO   jTPCC : Term-00, +-------------------------------------------------------------+
17:33:40,154 [main] INFO   jTPCC : Term-00, 
17:33:40,154 [main] INFO   jTPCC : Term-00, db=yashandb
17:33:40,154 [main] INFO   jTPCC : Term-00, driver=com.yashandb.jdbc.Driver
17:33:40,154 [main] INFO   jTPCC : Term-00, conn=jdbc:yasdb://172.10.1.122:1688/yashandb
17:33:40,154 [main] INFO   jTPCC : Term-00, user=sys
17:33:40,155 [main] INFO   jTPCC : Term-00, 
17:33:40,155 [main] INFO   jTPCC : Term-00, warehouses=10
17:33:40,155 [main] INFO   jTPCC : Term-00, terminals=10
17:33:40,156 [main] INFO   jTPCC : Term-00, runMins=5
17:33:40,156 [main] INFO   jTPCC : Term-00, limitTxnsPerMin=0
17:33:40,156 [main] INFO   jTPCC : Term-00, terminalWarehouseFixed=true
17:33:40,156 [main] INFO   jTPCC : Term-00, 
17:33:40,157 [main] INFO   jTPCC : Term-00, newOrderWeight=45
17:33:40,157 [main] INFO   jTPCC : Term-00, paymentWeight=43
17:33:40,157 [main] INFO   jTPCC : Term-00, orderStatusWeight=4
17:33:40,157 [main] INFO   jTPCC : Term-00, deliveryWeight=4
17:33:40,157 [main] INFO   jTPCC : Term-00, stockLevelWeight=4
17:33:40,157 [main] INFO   jTPCC : Term-00, 
17:33:40,157 [main] INFO   jTPCC : Term-00, resultDirectory=my_result_%tY-%tm-%td_%tH%tM%tS
17:33:40,157 [main] INFO   jTPCC : Term-00, osCollectorScript=./misc/os_collector_linux.py
17:33:40,157 [main] INFO   jTPCC : Term-00, 
17:33:40,169 [main] INFO   jTPCC : Term-00, copied props.yashandb to my_result_2024-12-09_173340/run.properties
17:33:40,169 [main] INFO   jTPCC : Term-00, created my_result_2024-12-09_173340/data/runInfo.csv for runID 3
17:33:40,170 [main] INFO   jTPCC : Term-00, writing per transaction results to my_result_2024-12-09_173340/data/result.csv
17:33:40,171 [main] INFO   jTPCC : Term-00, osCollectorScript=./misc/os_collector_linux.py
17:33:40,171 [main] INFO   jTPCC : Term-00, osCollectorInterval=1
17:33:40,171 [main] INFO   jTPCC : Term-00, osCollectorSSHAddr=null
17:33:40,171 [main] INFO   jTPCC : Term-00, osCollectorDevices=null
17:33:40,236 [main] INFO   jTPCC : Term-00,
17:33:40,376 [main] INFO   jTPCC : Term-00, C value for C_LAST during loadTerm-00, Running Average tpmTOTAL: 156325.47    Cur17:38:40,455 [Thread-9] INFO   jTPCC : Term-00, 11MB                                                                         17:38:40,455 [Thread-9] INFO   jTPCC : Term-00,                                                                              17:38:40,455 [Thread-9] INFO   jTPCC : Term-00, Measured tpmC (NewOrders) = 70509.35                        
17:38:40,455 [Thread-9] INFO   jTPCC : Term-00, Measured tpmTOTAL = 156324.15
17:38:40,455 [Thread-9] INFO   jTPCC : Term-00, Session Start     = 2024-12-09 17:33:40
17:38:40,455 [Thread-9] INFO   jTPCC : Term-00, Session End       = 2024-12-09 17:38:40
17:38:40,455 [Thread-9] INFO   jTPCC : Term-00, Transaction Count = 781638
[root@worker2 run]#

7、测试结果分析

测试完成后，需要对测试结果进行详细的分析。通过对比不同测试场景下的性能指标，可以评估YashanDB数据库在不同压力下的处理能力。同时，还可以根据测试结果对数据库进行进一步的优化和改进，以提高其整体性能。

7.1 测试时间：

测试从2024-12-09 17:33:40开始，到2024-12-09 17:38:40结束，持续时间为5分钟。

7.2 性能指标：

Running Average tpmTOTAL：在测试过程中，总的平均事务处理速率（Transactions Per Minute, TPM）为156,325.47。这个数值表示在测试期间，YashanDB平均每分钟能够处理约156,325个事务。然而，请注意这个数值是测试过程中的平均值，可能会受到测试初期和末期性能波动的影响。
Measured tpmC (NewOrders)：新订单交易事务的处理速率为70,509.35 TPM。在TPC-C测试中，新订单事务是一个关键的性能指标，因为它涉及到多个数据库操作的组合，包括插入、更新和选择。
Measured tpmTOTAL：测试结束时测得的总事务处理速率为156,324.15 TPM。这个数值与运行平均值相近，表明测试期间性能相对稳定。

7.3 内存使用：

程序使用了大约 11MB 的内存，也可能是指某个时刻的内存使用量，或者是某个线程的内存使用量。不过，考虑到测试持续时间和事务处理量，这个数值相对较低，表明YashanDB在测试期间内存使用效率较高。

7.4 事务数量：

在5分钟的测试期间，总共处理了781,638笔交易事务。这个数值与测得的事务处理速率相符，进一步验证了测试结果的准确性。

综上所述，jTPCC对YashanDB单机数据库的测试结果表明，在5分钟的测试期间完成了781,638笔交易，YashanDB表现出了较高的性能水平，平均每分钟能够处理约156,325个事务，其中新订单事务的处理速率为70,509.35 TPM。并且在测试期间也对操作系统的性能进行了监控，这些结果可以为数据库的性能调优、容量规划和架构设计提供有价值的参考。

四、总结与展望

我是小支同学经过这一番折腾，友友们我们终于把 YashanDB 单机数据库用 BenchmarkSQL 跑了个 TPC-C 测试，收获可不小呢！测试只是第一步，接下来我们还会继续深挖 YashanDB 的性能优化，说不定还能发现更多隐藏的宝藏功能。国产数据库发展得这么快，我觉得未来肯定大有可为，小支同学也希望能在这个领域多做点贡献！

总之，这次测试只是个开始，未来还有更多好玩的等着我们呢！大家一起加油吧！