Use PTS to perform stress testing on Hologres - Performance Testing

This topic describes how to use Alibaba Cloud Performance Testing (PTS) to perform stress testing on Hologres. This helps you quickly verify the performance of Hologres.

Introduction to Hologres

Hologres is a real-time interactive analytics engine that is compatible with PostgreSQL. You can use Hologres to write, update, and analyze large amounts of data in real time. Hologres supports online analytical processing (OLAP) and ad hoc analysis for petabytes of data, and provides high-concurrency and low-latency online data services.

Hologres supports a variety of development tools. You can use HoloWeb to log on to a Hologres instance, create a database, and then execute statements in the SQL editor to create internal and foreign tables and write data to databases. For more information about HoloWeb, see HoloWeb.
Hologres allows you to synchronize data from various data sources, such as MaxCompute projects and Object Storage Service (OSS)-based data lakes. You can also import local files to Hologres by using the COPY statement, and import data from databases such as MySQL to Hologres by using DataWorks. For more information, see Overview.
When you create a Hologres internal table, you must configure appropriate indexes for the table to achieve optimal query performance. For more information about how to configure indexes in Hologres, see CREATE TABLE.

Prerequisites

A Hologres instance is purchased. For more information, see Purchase a Hologres instance.
PTS is activated. For more information, see Activate PTS.
A Resource Access Management (RAM) user named pts-test is created and granted the AliyunHologresReadOnlyAccess permission. The RAM user is authorized in HoloWeb to access the test database.

Solution overview

In this topic, PTS is used with TPC Benchmark™ H (TPC-H) to test the performance of Hologres in terms of online analytical processing (OLAP) queries, point queries of key-value pairs, and data updates. When you use PTS to perform stress testing, you do not need to prepare the basic environment for testing. However, you still need to prepare the data and test statements required for different testing scenarios.

For OLAP queries, you need to create column-oriented tables, synchronize data from the data source, and design test statements.
For point queries of key-value pairs, you need to create a row-oriented table, synchronize data from the data source, and design test statements.
For data updates, you need to design the statement for updating data.

Important

The tests described in this example are performed based on the TPC-H benchmark but do not meet all requirements of the TPC-H benchmark test. As a result, the test results in this example may not match the published results of the TPC-H benchmark test.
In this example, a MaxCompute data source is used. The TPC-H 100 GB data stored in the public MaxCompute project MAXCOMPUTE_PUBLIC_DATA is written to Hologres.

OLAP queries

In this scenario, column-oriented tables are used, and the 22 query statements for TPC-H benchmark testing are executed.

1. Configure test data in Hologres

Create foreign tables.

Sample statements

DROP FOREIGN TABLE IF EXISTS odps_customer_100g;
DROP FOREIGN TABLE IF EXISTS odps_lineitem_100g;
DROP FOREIGN TABLE IF EXISTS odps_nation_100g;
DROP FOREIGN TABLE IF EXISTS odps_orders_100g;
DROP FOREIGN TABLE IF EXISTS odps_part_100g;
DROP FOREIGN TABLE IF EXISTS odps_partsupp_100g;
DROP FOREIGN TABLE IF EXISTS odps_region_100g;
DROP FOREIGN TABLE IF EXISTS odps_supplier_100g;

IMPORT FOREIGN SCHEMA "MAXCOMPUTE_PUBLIC_DATA#default" LIMIT to
(
    odps_customer_100g,
    odps_lineitem_100g,
    odps_nation_100g,
    odps_orders_100g,
    odps_part_100g,
    odps_partsupp_100g,
    odps_region_100g,
    odps_supplier_100g
)
FROM SERVER odps_server INTO public OPTIONS(if_table_exist 'error',if_unsupported_type 'error');

Create internal tables.

To perform a performance test on OLAP queries, you must use column-oriented tables and create appropriate indexes for better query performance. By default, internal tables created in Hologres are column-oriented tables. For more information about the table properties, see CREATE TABLE.

Sample statements

DROP TABLE IF EXISTS LINEITEM;

BEGIN;
CREATE TABLE LINEITEM
(
    L_ORDERKEY      BIGINT      NOT NULL,
    L_PARTKEY       INT         NOT NULL,
    L_SUPPKEY       INT         NOT NULL,
    L_LINENUMBER    INT         NOT NULL,
    L_QUANTITY      DECIMAL(15,2) NOT NULL,
    L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL,
    L_DISCOUNT      DECIMAL(15,2) NOT NULL,
    L_TAX           DECIMAL(15,2) NOT NULL,
    L_RETURNFLAG    TEXT        NOT NULL,
    L_LINESTATUS    TEXT        NOT NULL,
    L_SHIPDATE      TIMESTAMPTZ NOT NULL,
    L_COMMITDATE    TIMESTAMPTZ NOT NULL,
    L_RECEIPTDATE   TIMESTAMPTZ NOT NULL,
    L_SHIPINSTRUCT  TEXT        NOT NULL,
    L_SHIPMODE      TEXT        NOT NULL,
    L_COMMENT       TEXT        NOT NULL,
    PRIMARY KEY (L_ORDERKEY,L_LINENUMBER)
);
CALL set_table_property('LINEITEM', 'clustering_key', 'L_SHIPDATE,L_ORDERKEY');
CALL set_table_property('LINEITEM', 'segment_key', 'L_SHIPDATE');
CALL set_table_property('LINEITEM', 'distribution_key', 'L_ORDERKEY');
CALL set_table_property('LINEITEM', 'bitmap_columns', 'L_ORDERKEY,L_PARTKEY,L_SUPPKEY,L_LINENUMBER,L_RETURNFLAG,L_LINESTATUS,L_SHIPINSTRUCT,L_SHIPMODE,L_COMMENT');
CALL set_table_property('LINEITEM', 'dictionary_encoding_columns', 'L_RETURNFLAG,L_LINESTATUS,L_SHIPINSTRUCT,L_SHIPMODE,L_COMMENT');
COMMIT;

DROP TABLE IF EXISTS ORDERS;

BEGIN;
CREATE TABLE ORDERS
(
    O_ORDERKEY      BIGINT      NOT NULL PRIMARY KEY,
    O_CUSTKEY       INT         NOT NULL,
    O_ORDERSTATUS   TEXT        NOT NULL,
    O_TOTALPRICE    DECIMAL(15,2) NOT NULL,
    O_ORDERDATE     timestamptz NOT NULL,
    O_ORDERPRIORITY TEXT        NOT NULL,
    O_CLERK         TEXT        NOT NULL,
    O_SHIPPRIORITY  INT         NOT NULL,
    O_COMMENT       TEXT        NOT NULL
);
CALL set_table_property('ORDERS', 'segment_key', 'O_ORDERDATE');
CALL set_table_property('ORDERS', 'distribution_key', 'O_ORDERKEY');
CALL set_table_property('ORDERS', 'bitmap_columns', 'O_ORDERKEY,O_CUSTKEY,O_ORDERSTATUS,O_ORDERPRIORITY,O_CLERK,O_SHIPPRIORITY,O_COMMENT');
CALL set_table_property('ORDERS', 'dictionary_encoding_columns', 'O_ORDERSTATUS,O_ORDERPRIORITY,O_CLERK,O_COMMENT');
COMMIT;

DROP TABLE IF EXISTS PARTSUPP;

BEGIN;
CREATE TABLE PARTSUPP
(
    PS_PARTKEY    INT    NOT NULL,
    PS_SUPPKEY    INT    NOT NULL,
    PS_AVAILQTY   INT    NOT NULL,
    PS_SUPPLYCOST DECIMAL(15,2) NOT NULL,
    PS_COMMENT    TEXT   NOT NULL,
    PRIMARY KEY(PS_PARTKEY,PS_SUPPKEY)
);
CALL set_table_property('PARTSUPP', 'distribution_key', 'PS_PARTKEY');
CALL set_table_property('PARTSUPP', 'bitmap_columns', 'PS_PARTKEY,PS_SUPPKEY,PS_AVAILQTY,PS_COMMENT');
CALL set_table_property('PARTSUPP', 'dictionary_encoding_columns', 'PS_COMMENT');
COMMIT;

DROP TABLE IF EXISTS PART;

BEGIN;
CREATE TABLE PART
(
    P_PARTKEY     INT    NOT NULL PRIMARY KEY,
    P_NAME        TEXT   NOT NULL,
    P_MFGR        TEXT   NOT NULL,
    P_BRAND       TEXT   NOT NULL,
    P_TYPE        TEXT   NOT NULL,
    P_SIZE        INT    NOT NULL,
    P_CONTAINER   TEXT   NOT NULL,
    P_RETAILPRICE DECIMAL(15,2) NOT NULL,
    P_COMMENT     TEXT   NOT NULL
);
CALL set_table_property('PART', 'distribution_key', 'P_PARTKEY');
CALL set_table_property('PART', 'bitmap_columns', 'P_PARTKEY,P_SIZE,P_NAME,P_MFGR,P_BRAND,P_TYPE,P_CONTAINER,P_COMMENT');
CALL set_table_property('PART', 'dictionary_encoding_columns', 'P_NAME,P_MFGR,P_BRAND,P_TYPE,P_CONTAINER,P_COMMENT');
COMMIT;

DROP TABLE IF EXISTS CUSTOMER;

BEGIN;
CREATE TABLE CUSTOMER
(
    C_CUSTKEY    INT    NOT NULL PRIMARY KEY,
    C_NAME       TEXT   NOT NULL,
    C_ADDRESS    TEXT   NOT NULL,
    C_NATIONKEY  INT    NOT NULL,
    C_PHONE      TEXT   NOT NULL,
    C_ACCTBAL    DECIMAL(15,2) NOT NULL,
    C_MKTSEGMENT TEXT   NOT NULL,
    C_COMMENT    TEXT   NOT NULL
);
CALL set_table_property('CUSTOMER', 'distribution_key', 'C_CUSTKEY');
CALL set_table_property('CUSTOMER', 'bitmap_columns', 'C_CUSTKEY,C_NATIONKEY,C_NAME,C_ADDRESS,C_PHONE,C_MKTSEGMENT,C_COMMENT');
CALL set_table_property('CUSTOMER', 'dictionary_encoding_columns', 'C_NAME,C_ADDRESS,C_PHONE,C_MKTSEGMENT,C_COMMENT');
COMMIT;

DROP TABLE IF EXISTS SUPPLIER;

BEGIN;
CREATE TABLE SUPPLIER
(
    S_SUPPKEY   INT    NOT NULL PRIMARY KEY,
    S_NAME      TEXT   NOT NULL,
    S_ADDRESS   TEXT   NOT NULL,
    S_NATIONKEY INT    NOT NULL,
    S_PHONE     TEXT   NOT NULL,
    S_ACCTBAL   DECIMAL(15,2) NOT NULL,
    S_COMMENT   TEXT   NOT NULL
);
CALL set_table_property('SUPPLIER', 'distribution_key', 'S_SUPPKEY');
CALL set_table_property('SUPPLIER', 'bitmap_columns', 'S_SUPPKEY,S_NAME,S_ADDRESS,S_NATIONKEY,S_PHONE,S_COMMENT');
CALL set_table_property('SUPPLIER', 'dictionary_encoding_columns', 'S_NAME,S_ADDRESS,S_PHONE,S_COMMENT');
COMMIT;

DROP TABLE IF EXISTS NATION;

BEGIN;
CREATE TABLE NATION(
  N_NATIONKEY INT NOT NULL PRIMARY KEY,
  N_NAME text NOT NULL,
  N_REGIONKEY INT NOT NULL,
  N_COMMENT text NOT NULL
);
CALL set_table_property('NATION', 'distribution_key', 'N_NATIONKEY');
CALL set_table_property('NATION', 'bitmap_columns', 'N_NATIONKEY,N_NAME,N_REGIONKEY,N_COMMENT');
CALL set_table_property('NATION', 'dictionary_encoding_columns', 'N_NAME,N_COMMENT');
COMMIT;

DROP TABLE IF EXISTS REGION;

BEGIN;
CREATE TABLE REGION
(
    R_REGIONKEY INT  NOT NULL PRIMARY KEY,
    R_NAME      TEXT NOT NULL,
    R_COMMENT   TEXT
);
CALL set_table_property('REGION', 'distribution_key', 'R_REGIONKEY');
CALL set_table_property('REGION', 'bitmap_columns', 'R_REGIONKEY,R_NAME,R_COMMENT');
CALL set_table_property('REGION', 'dictionary_encoding_columns', 'R_NAME,R_COMMENT');
COMMIT;

Write test data and collect statistics.

Note

Hologres V2.1.17 and later support the Serverless Computing feature. The Serverless Computing feature is suitable for scenarios in which you want to import a large amount of data offline, run large-scale extract, transform, and load (ETL) jobs, or query a large amount of data from foreign tables. You can use the Serverless Computing feature to perform the preceding operations based on additional serverless computing resources. This can eliminate the need to reserve additional computing resources for the instances. This improves instance stability and reduces the occurrences of out of memory (OOM) errors. You are charged only for the additional serverless computing resources used by tasks. For more information about the Serverless Computing feature, see Overview of Serverless Computing. For more information about how to use the Serverless Computing feature, see User guide on Serverless Computing.

Sample statements

-- Optional. We recommend that you use the Serverless Computing feature to import a large amount of data offline and run extract, transform, and load (ETL) jobs.
SET hg_computing_resource = 'serverless';

INSERT INTO public.customer SELECT * FROM public.odps_customer_100g ;
INSERT INTO public.lineitem SELECT * FROM public.odps_lineitem_100g ;
INSERT INTO public.nation SELECT * FROM public.odps_nation_100g ;
INSERT INTO public.orders SELECT * FROM public.odps_orders_100g ;
INSERT INTO public.part SELECT * FROM public.odps_part_100g ;
INSERT INTO public.partsupp SELECT * FROM public.odps_partsupp_100g ;
INSERT INTO public.region SELECT * FROM public.odps_region_100g ;
INSERT INTO public.supplier SELECT * FROM public.odps_supplier_100g ;

-- Vacuum the tables to which test data are written.
vacuum  nation;
vacuum  region;
vacuum  supplier;
vacuum  customer;
vacuum  part;
vacuum  partsupp;
vacuum  orders;
vacuum  lineitem;
-- Collect statistics on the tables.
analyze nation;
analyze region;
analyze lineitem;
analyze orders;
analyze customer;
analyze part;
analyze partsupp;
analyze supplier;
-- Collect statistics on the join keys that are not primary keys.
analyze lineitem (l_orderkey,l_partkey,l_suppkey);
analyze orders (o_custkey);
analyze partsupp(ps_partkey,ps_suppkey);

-- Reset the configurations. This ensures that serverless computing resources are not used for unnecessary SQL statements. 
RESET hg_computing_resource;

2. Configure a stress testing scenario in PTS

Log on to the PTS console, choose Performance Test > Create Scenario, and then click PTS.
Delete the default HTTP node.
Add and configure a JDBC node.
Note
In actual testing, the stress testing nodes in a business session are executed in sequence, and different business sessions are concurrently executed. In this example, you need to retain only one business session and configure the concurrency subsequently to simulate a parallelism scenario.
Parameters on the Basic Request Information tab:
- Database Type: Select PostgreSQL.
- Database URL: Set the value in the {ENDPOINT}:{PORT}/{DBNAME} format. You can view the database URL on the Instance Details tab of the database instance in the Hologres console.
- Username: Enter the AccessKey ID of the RAM user pts-test.
- Password: Enter the AccessKey secret of the RAM user pts-test.
- SQL: Enter the SQL statement to be executed. In this example, 22 TPC-H query statements are used. For more information, see the 22 TPC-H query statements section of the "Test plan" topic.
Parameters on the Connection Pool Settings tab:
- Initial Connections: the number of physical connections that are established during initialization. In this example, this parameter is set to 1.
- Max Wait Time: In this example, the default value is used.
- Max Connections: the maximum number of active connections. In this example, this parameter is set to 15 to support scenarios in which a single instance processes a single request at a time or concurrently processes multiple requests.
- Min Connections: the minimum number of idle connections in the connection pool. In this example, this parameter is set to 1.
Repeat the previous step to configure other query statements. In this scenario, the 22 query statements of the TPC-H benchmark test are used. You can use the API replication feature to create 22 JDBC nodes within the same business session and add the 22 TPC-H query statements in sequence. During stress testing, PTS executes the 22 query statements in sequence in loops.

Configure parameters in the Stress Mode Configuration section.

In this example, Alibaba Cloud VPC is selected as the source of stress. You can configure other parameters based on your business requirements. When you use TPC-H data to perform stress testing on OLAP queries, you need to focus on the execution duration of a single query. The following table describes the parameters.

Parameter	Description
Max VUs	In this example, this parameter is set to 1. This ensures that sufficient resources are available for each query.
Auto Increment Mode	In this example, Manual Adjustment is selected because the concurrency does not need to be changed in this example. You need to only keep the concurrency at 1.
Total Test Duration	In this example, this parameter is set to 60 minutes, considering that 22 query statements need to be executed.
Number of Specified IP Addresses	The number of IP addresses that are used for stress testing, which is also the number of load generators. In this example, only one IP address is specified.

3. Debug and start the stress testing

We recommend that you debug the stress testing scenario before you start stress testing. This helps check whether the configurations meet your business requirements and prevent test failures.
Click Save and Start. In the Note dialog box, select Execute Now and The test is permitted and complies with the applicable laws and regulations. and then click Start.

4. View the stress testing report

After the stress testing is completed, go to the Test Reports tab of the Edit Scenario page, find the report that is generated for this stress testing, and then click View in the Actions column.
On the Overview tab of the Report Details page, you can view whether the stress testing is successfully performed.
- If the stress testing is successfully performed, you can view information such as the success rate, average RT, TPS/VU, number of exceptions, and total number of requests. Average RT indicates the average query latency. TPS indicates the number of transactions that are processed per second, including the connection duration. In this example, TPS is equal to queries per second (QPS).
- If the stress testing fails and metrics such as the number of requests are displayed as 0, you can click View Sampling Logs, Click to view details, and then Error Information to view the error information and troubleshoot issues.
On the Report Details page, click the Details tab to view the metrics of each stress testing node. Each node corresponds to a query statement.
In this example, a single business session contains multiple stress testing nodes. You can view the metrics of each stress testing node.
If the number of virtual users (VUs) is set to 1, you need to only focus on the query duration. In this example, the sum of the execution duration of the 22 TPC-H query statements is approximately 25 seconds.
If multiple VUs are configured, you need to pay attention to both the query duration and QPS. You can also go to the Details tab and select a time range to view the test results for each VU.

For more information about how to view and analyze stress testing reports, see View a JDBC stress testing report.

Point queries of key-value pairs

In this scenario, a row-oriented table that uses the same schema as the ORDERS table is used, and point queries are executed based on the primary key.

1. Configure test data in Hologres

You can use the database created for the performance test on OLAP queries and the ORDERS table in the TPC-H dataset to perform the performance test on point queries of key-value pairs. After you log on to the Hologres instance, you can execute the following statement to create a table and write data from the ORDERS table that was created for the performance test on OLAP queries.

Create an internal table.

The performance test on point queries of key-value pairs requires a row-oriented table. Therefore, the table created for the performance test on OLAP queries cannot be directly used. You must create a row-oriented table. To perform a performance test on point queries of key-value pairs, you must use a row-oriented table and specify a primary key. You must also create appropriate indexes for better query performance. For more information about the table properties, see CREATE TABLE.

Sample statements

DROP TABLE IF EXISTS public.orders_row;

BEGIN;
CREATE TABLE public.orders_row(
    O_ORDERKEY       INT            NOT NULL PRIMARY KEY
    ,O_CUSTKEY       INT            NOT NULL
    ,O_ORDERSTATUS   TEXT           NOT NULL
    ,O_TOTALPRICE    DECIMAL(15,2)  NOT NULL
    ,O_ORDERDATE     TIMESTAMPTZ    NOT NULL
    ,O_ORDERPRIORITY TEXT           NOT NULL
    ,O_CLERK         TEXT           NOT NULL
    ,O_SHIPPRIORITY  INT            NOT NULL
    ,O_COMMENT       TEXT           NOT NULL
);
CALL SET_TABLE_PROPERTY('public.orders_row', 'orientation', 'row');
CALL SET_TABLE_PROPERTY('public.orders_row', 'clustering_key', 'o_orderkey');
CALL SET_TABLE_PROPERTY('public.orders_row', 'distribution_key', 'o_orderkey');
COMMIT;

Write data.

-- Optional. We recommend that you use the Serverless Computing feature to import a large amount of data offline and run ETL jobs.
SET hg_computing_resource = 'serverless';

INSERT INTO public.orders_row
SELECT * FROM public.orders;

-- Reset the configurations. This ensures that serverless computing resources are not used for unnecessary SQL statements. 
RESET hg_computing_resource;

2. Configure a stress testing scenario in PTS

Log on to the PTS console, choose Performance Test > Create Scenario, and then click PTS.
Delete the default HTTP node.
Add and configure a JDBC node.
Note
In actual testing, the stress testing nodes in a business session are executed in sequence, and different business sessions are concurrently executed. In this example, you need to retain only one business session and configure the concurrency subsequently to simulate a parallelism scenario.
Parameters on the Basic Request Information tab:
- Database Type: Select PostgreSQL.
- Database URL: Set the value in the {ENDPOINT}:{PORT}/{DBNAME} format. You can view the database URL on the Instance Details tab of the database instance in the Hologres console.
- Username: Enter the AccessKey ID of the RAM user pts-test.
- Password: Enter the AccessKey secret of the RAM user pts-test.
- SQL: Unlike the performance test on OLAP queries, the performance test on point queries of key-value pairs involve two types of queries, single-value point query and multi-value point query. For more information, see Test plan.
  - Single-value point query
    Sample statement
    SELECT O_ORDERKEY, O_CUSTKEY, O_ORDERSTATUS, O_TOTALPRICE, O_ORDERDATE, O_ORDERPRIORITY, O_CLERK, O_SHIPPRIORITY, O_COMMENT FROM public.orders_row WHERE o_orderkey = ?;
  - Multi-value point query: In this example, nine values are queried.
    Sample statement
    SELECT O_ORDERKEY, O_CUSTKEY, O_ORDERSTATUS, O_TOTALPRICE, O_ORDERDATE, O_ORDERPRIORITY, O_CLERK, O_SHIPPRIORITY, O_COMMENT FROM public.orders_row WHERE o_orderkey IN (?, ?, ?, ?, ?, ?, ?, ?, ?);
Parameters on the Placeholder tab:
- Type: In this example, bigint is selected. In point queries of key-value pairs, primary key values are randomly generated for queries. This can be achieved by configuring placeholders in the PTS console. Use ? as placeholders in an SQL statement and set values for ? in sequence when you configure the placeholders.
  Important
  The placeholders that you configure must be arranged in the same order as the ? symbols in the SQL statement. In this example, nine placeholders are configured.
- Value: PTS supports several system functions. In this example, the random function is used, and Value is set to ${sys.random(1,99999999)}.
Parameters on the Connection Pool Settings tab:
- Initial Connections: the number of physical connections that are established during initialization. The performance test on point queries of key-value pairs requires concurrent connections. In this case, you can set this parameter to 20. This way, 20 connections are generated for each load generator.
- Max Wait Time: Use the default value.
- Max Connections: the maximum number of active connections. In this example, 20 is used.
- Min Connections: the minimum number of idle connections in the connection pool. In this example, 20 is used.

Configure parameters in the Stress Mode Configuration section.

In this example, Alibaba Cloud VPC is selected as the source of stress. You can configure other parameters based on your business requirements. The following table describes the parameters.

Parameter	Description
Stress Mode	In this example, VU Mode is selected.
Max VUs	In this example, the performance test on point queries of key-value pairs is performed on a Hologres instance with 64 CUs of computing resources, and the concurrency is `500`. Therefore, set this parameter to `500` This is also the reason why you need to set the number of connections to `20` when you configure the connection pool earlier.
Auto Increment Mode	The concurrency does not change in this example, so you need to only keep the concurrency at `500`. Therefore, set this parameter to Manual Adjustment.
Total Test Duration	Enter the total duration based on the testing scenario. In this example, only `one` test statement is involved. Therefore, you can set the duration to `5` minutes.
Number of Specified IP Addresses	The number of IP addresses that are used for stress testing, which is also the number of load generators. In this scenario, the QPS is estimated to be `100,000`. The maximum QPS of a load generator is `4,000`. Therefore, `25` load generators are needed in this example. Note In VU mode of PTS, the maximum QPS of a load generator reaches 4,000. In practice, you must reckon with the total QPS that may be reached to determine the number of load generators, and then configure the connection pool.

3. Debug and start the stress testing

We recommend that you debug the stress testing scenario before you start stress testing. This helps check whether the configurations meet your business requirements and prevent test failures.
Click Save and Start. In the Note dialog box, select Execute Now and The test is permitted and complies with the applicable laws and regulations. and then click Start.

4. View the stress testing report

For single-value point queries in this example, the average QPS exceeds 100,000.
For multi-value point queries in this example, 30 values are queried and the average QPS is 34,819. The final QPS equals the average QPS multiplied by the number of concurrent point queries. In this example, the final QPS is calculated based on the following equation: 34819 × 30 = 1044570.

Data updates

You can test the performance of data updates based on the primary key for the OLAP engine.

In this example, the table used for the performance test on point queries of key-value pairs is also applied to the data update test.

When you configure a stress testing scenario in PTS for data updates, use the same settings as for point queries of key-value pairs, except for the SQL statement that you enter when you configure the JDBC node.

Sample statement

INSERT INTO public.orders_row (o_orderkey, o_custkey, o_orderstatus, o_totalprice, o_orderdate, o_orderpriority, o_clerk, o_shippriority, o_comment)
    VALUES (?, 1, 'demo', 1.1, '2021-01-01', 'demo', 'demo', 1, 'demo')
ON CONFLICT (o_orderkey)
    DO UPDATE SET
        (o_orderkey, o_custkey, o_orderstatus, o_totalprice, o_orderdate, o_orderpriority, o_clerk, o_shippriority, o_comment) = ROW (excluded.*);

For more information about how to start stress testing and analyze reports, see the Point queries of key-value pairs section of this topic.

Toubleshooting

During debugging, you may encounter the following exception. The possible causes include an invalid database URL and an incorrect database username or password, which result in a connection failure.

Performance Testing:Use PTS to perform stress testing on Hologres

Introduction to Hologres

Prerequisites

Solution overview

OLAP queries

1. Configure test data in Hologres

2. Configure a stress testing scenario in PTS

3. Debug and start the stress testing

4. View the stress testing report

Point queries of key-value pairs

1. Configure test data in Hologres

2. Configure a stress testing scenario in PTS

3. Debug and start the stress testing

4. View the stress testing report

Data updates

Toubleshooting

References