tencent cloud

TDSQL Boundless

Release Notes
Product Introduction
Overview
Scenarios
Product Architecture
Instance Types
Compatibility Notes
Kernel Features
Kernel Overview
Kernel Version Release Notes
Functionality Features
Performance Features
Billing
Billing Overview
Purchase Method
Pricing Details
Renewal
Overdue Payments
Refund
Getting Started
Creating an Instance
Connect to Instances
User Guide
Data Migration
Data Subscription
Instance Management
Configuration Change
Parameter Configuration
Account Management
Security Group
Backup and Restoration
Database Auditing
Tag Management
Use Cases
Technical Evolution and Usage Practices of Online DDL
Lock Mechanism Analysis and Troubleshooting Practices
Data Intelligent Scheduling and Related Practices for Performance Optimization
TDSQL Boundless Selection Guide and Practical Tutorial
Developer Guide
Developer Guide (MySQL Compatibility Mode)
Developer Guide (HBase Compatibility Mode)
Performance Tuning
Performance Tuning Overview
SQL Tuning
DDL Tuning
Performance White Paper
Performance Overview
TPC-C Test
Sysbench Test
API Documentation
History
Introduction
API Category
Making API Requests
Instance APIs
Security Group APIs
Task APIs
Backup APIs
Rollback APIs
Parameter APIs
Database APIs
Data Types
Error Codes
General Reference
System Architecture
SQL Reference
Database Parameter Description
TPC-H benchmark data model reference
Error Code Information
Security and Compliance
FAQs
Agreements
Service Level Agreement
Terms of Service
Privacy Policy
Data Processing And Security Agreement
Contact Us
Glossary
DocumentationTDSQL BoundlessPerformance White PaperTPC-C Test

TPC-C Test

PDF
Focus Mode
Font Size
Last updated: 2026-02-10 10:54:57

Test Overview

Provide the TPC-C test report of TDSQL Boundless as a performance comparison benchmark for different editions of TDSQL Boundless.
Note:
TPC-C is a common benchmark in the industry, developed and published by the TPC committee. It is used to evaluate the online transaction processing (OLTP-oriented) capabilities of databases. It primarily involves 10 tables and includes five different business transaction models: NewOrder (generation of new orders), Payment (order payment), OrderStatus (querying of recent orders), Delivery (delivery), and StockLevel (analysis of the stockout status of inventory). TPC-C uses the tpmC value (transactions per minute) to measure the system's max qualified throughput (MQTh). Transactions are determined by NewOrder, meaning that the final measurement unit is the number of new orders processed per minute.

Testing Environment

Hardware Environment

Node Type
Node Specifications
Number of Nodes
Peer node
16-Core CPU/32 GB of Memory/Enhanced SSD with 300 GB
3
Management nodes
4Core CPU/8GB Memory
3

Software Version

Node Type
Software Version
Peer node
v21.1.0
v5.0

Parameter Configuration

set persist audit_log_policy = "NONE";
set persist max_prepared_stmt_count = 1000000;
set persist temptable_max_mmap = 214748364800

Testing Plan

Preparing Stress Test Tools

Download the open-source BenchmarkSQL stress testing tool from the community, unzip it, and run tests.

Preparing Test Data

Based on 1000 warehouses for quantitative testing. On the stress testing machine, run the following command to modify the props.mysql configuration file and fill in the corresponding connection information for the instance:
cd benchmarksql/run
vi props.mysql
Among them, the configuration file props.mysql and its main parameters are as follows:
db=mysql
driver=com.mysql.jdbc.Driver 
conn=jdbc:mysql://{ip}:{port}/tpcc?useSSL=false&useServerPrepStmts=true&useConfigs=maxPerformance&rewriteBatchedStatements=true&cachePrepStmts=true&prepStmtCacheSize=1000&prepStmtCacheSqlLimit=2048
user={user}
password={password}

warehouses=1000 
loadWorkers=20   

terminals={terminals} 
runTxnsPerTerminal=0
runMins=5 
limitTxnsPerMin=0 
terminalWarehouseFixed=true

newOrderWeight=45
paymentWeight=43
orderStatusWeight=4
deliveryWeight=4
stockLevelWeight=4
Create a database:
 create database tpcc;
Start creating tables and indexes and modify the definition of the core table to a hash partitioned table. By default, 9 partitions are created.
cd benchmarksql/run/sql.common
# Modify the table structure. The core table is defined as a hash partitioned table, which has 9 partitions by default.
cp tableCreates.sql  tableCreates_tdsql.sql
vi tableCreates_tdsql.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),
   primary key(w_id)
) partition by hash(w_id) partitions 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),
   PRIMARY KEY (d_w_id, d_id)
) partition by hash(d_w_id) partitions 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),
   PRIMARY KEY (c_w_id, c_d_id, c_id)
) partition by hash(c_w_id) partitions 9;


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)
) partition by hash(h_w_id) partitions 9;

CREATE TABLE bmsql_new_order (
   no_w_id  integer   not null ,
   no_d_id  integer   not null,
   no_o_id  integer   not null,
   PRIMARY KEY (no_w_id, no_d_id, no_o_id)
) partition by hash(no_w_id) partitions 9;

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,
   PRIMARY KEY (o_w_id, o_d_id, o_id)
)  partition by hash(o_w_id) partitions 9;

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),
   PRIMARY KEY (ol_w_id, ol_d_id, ol_o_id, ol_number)
) partition by hash(ol_w_id) partitions 9;

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,
   PRIMARY KEY (i_id)
);

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),
   PRIMARY KEY (s_w_id, s_i_id)
) partition by hash(s_w_id) partitions 9;
After the database and table are created, start importing stress test data:
cd ..
nohup ./runLoader.sh props.mysql &
After the data is imported, execute the following SQL to create an index:
create index bmsql_customer_idx1 on bmsql_customer (c_w_id, c_d_id, c_last, c_first);
create unique index bmsql_oorder_idx1 on bmsql_oorder (o_w_id, o_d_id, o_carrier_id, o_id);

Executing a Test

Run the following command to run the TPC-C test:
cd benchmarksql/run
./runBenchmark.sh props.mysql

Test Results


Number of threads
tpmTOTAL
tpmC (NewOrders)
64
208,948.14
94,035.97
128
310,788.33
139,550.15
256
379,050.95
170,517.90
512
412,147.72
185,392.99
1,024
434,737.57
195,442.64
Previous Topic: Performance OverviewNext Topic: Sysbench Test

Help and Support

Was this page helpful?

Help us improve! Rate your documentation experience in 5 mins.

Feedback