AI 助理
备案控制台
官方文档
输入文档关键字查找
首页 云原生数据库 PolarDB 云原生数据库PolarDB MySQL版 用户指南 Orca（兼容Redis协议） Orca性能白皮书

Orca性能白皮书

更新时间：
产品详情
我的收藏

本文介绍PolarDB MySQL企业版8.0.2版本的Orca性能测试结果。

测试环境

  • ECS实例和PolarDB MySQL版集群位于同一地域和专有网络VPC内。

  • PolarDB MySQL版集群配置：

    • 集群规格：集群版系列、数据库引擎版本为MySQL 8.0.2、节点规格为polar.mysql.x4.2xlarge（16核64 GB）、存储类型为PSL5。

    • 参数配置：开启Blink-tree索引加速功能（loose_innodb_polar_blink_tree=ON），以提升查询性能。

  • ECS实例配置：1台ecs.c8i.16xlarge（64核128 GB），并通过Orca私网连接地址连接，确保在专有网络VPC内实现高效、安全的数据传输和访问性能。

测试工具

测试采用Redis Labs的多线程压测工具memtier benchmark。

性能测试

测试场景

我们针对Orca功能在128并发和512并发两种场景下，分别测试了Ping-Pong和Pipeline两种网络机制的性能结果。

并发数

Value大小

线程数

每个线程的连接数

总连接数

每个连接的操作次数

Key范围

数据总量

128 并发

128 Byte

32

4

128

2,000,000

[1, 128,000,000]

约30 GB

1 KB

32

4

128

2,000,000

[1, 128,000,000]

约40 GB

4 KB

32

4

128

200,000

[1, 12,800,000]

约60 GB

16 KB

32

4

128

200,000

[1, 12,800,000]

约750 GB

512 并发

128 Byte

32

16

512

2,000,000

[1, 512,000,000]

约150 GB

1 KB

32

16

512

2,000,000

[1, 512,000,000]

约175 GB

4 KB

32

16

512

200,000

[1, 51,200,000]

约250 GB

16 KB

32

16

512

200,000

[1, 51,200,000]

约1.5 TB

表格参数说明如下：

字段

说明

并发数

表示测试中使用的总连接数，分别为128并发和512并发两种场景。

Value大小

测试中使用的数据值大小，分别为128Byte、1 KB、4 KB和16KB。

线程数

每个测试场景中使用的线程数，均为32个线程。

每个线程的连接数

每个线程创建的Client连接数，128并发场景为4个，512并发场景为16个。

总连接数

线程数×每个线程的连接数，即总并发连接数。

每个连接的操作次数

每个连接执行的写入和读取操作次数。

Key范围

写入和读取操作的Key随机生成范围。

数据总量

根据Value大小、操作次数和连接数计算得出的总数据量。

测试指标

指标

说明

QPS

每秒执行的读写操作数，单位为次/秒。

说明

QPS 是衡量系统吞吐能力的关键指标，数值越高，系统处理能力越强。

Avg Latency

读写操作的平均时延，单位为毫秒（ms）。

说明

Avg Latency反映系统的平均响应速度，数值越低，用户体验越好。

p99 Latency

99%的操作都低于该时延，单位为毫秒（ms）。

说明

p99 Latency是衡量系统性能稳定性的重要指标，数值越低，系统在高负载下的表现越稳定。

测试结果

128 并发

重要

在执行过程中，若遇到以下两种认证错误提示：

  • "error: authentication failed [-ERR wrong number of arguments for 'auth'/'hello' command.]"

  • "error: authentication failed [-WRONGPASS invalid username-password pair or user is disabled.]"

请按照说明进行修正：根据memtier_benchmark官方文档的认证参数规范，您需要将认证参数中的"-a $password"替换为完整的账号密码格式，即使用"-a username:password"的形式，其中username替换为您的实际用户名，password替换为对应的密码。

128 Byte测试命令

  1. 128并发128 Byte的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 128并发128 Byte的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 128并发128 Byte的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 128并发下128 Byte的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 128并发下128 Byte的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 128并发下128 Byte的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

1 KB测试命令

  1. 128并发1 KB的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:0

  2. 128并发1 KB的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=0:1

  3. 128并发1 KB的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:1

  4. 128并发下1 KB的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:0

  5. 128并发下1 KB的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=0:1

  6. 128并发下1 KB的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:1

4 KB测试命令

  1. 128并发下4 KB的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 128并发下4 KB的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 128并发下4 KB的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 128并发下4 KB的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 128并发下4 KB的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 128并发下4 KB的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

16 KB测试命令

  1. 128并发下16 KB的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 128并发下16 KB的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 128并发下16 KB的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 128并发下16 KB的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 128并发下16 KB的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 128并发下16 KB的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

测试结果性能对比如下：

测试场景

QPS

Avg Latency（ms）

p99 Latency（ms）

Ping-Pong 纯写测试（128 并发，128 Byte）

115,179.72

1.09

3.12

Ping-Pong 纯读测试（128 并发，128 Byte）

302,828.59

0.41

1.46

Ping-Pong 读写混合测试（128 并发，128 Byte）

200,585.95

0.63

2.14

Pipeline 纯写测试（128 并发，128 Byte）

306,757.45

13.35

62.46

Pipeline 纯读测试（128 并发，128 Byte）

1,598,605.28

2.54

13.82

Pipeline 读写混合测试（128 并发，128 Byte）

272,943.49

15.00

58.62

Ping-Pong 纯写测试（128 并发，1 KB）

91,244.76

1.40

6.46

Ping-Pong 纯读测试（128 并发，1 KB）

310,197.23

0.41

1.46

Ping-Pong 读写混合测试（128 并发，1 KB）

142,757.04

0.89

4.67

Pipeline 纯写测试（128 并发，1 KB）

195,675.57

21.03

232.45

Pipeline 纯读测试（128 并发，1 KB）

981,181.21

4.17

39.94

Pipeline 读写混合测试（128 并发，1 KB）

191,592.63

21.46

129.02

Ping-Pong 纯写测试（128 并发，4 KB）

49,899.54

2.55

18.30

Ping-Pong 纯读测试（128 并发，4 KB）

275,966.23

0.46

1.44

Ping-Pong 读写混合测试（128 并发，4 KB）

86,027.86

1.48

14.40

Pipeline 纯写测试（128 并发，4 KB）

69,978.37

58.80

352.25

Pipeline 纯读测试（128 并发，4 KB）

497,229.35

8.22

68.61

Pipeline 读写混合测试（128 并发，4 KB）

97,213.70

42.25

352.25

Ping-Pong 纯写测试（128 并发，16 KB）

6,225.02

20.82

84.99

Ping-Pong 纯读测试（128 并发，16 KB）

166,434.33

0.78

1.44

Ping-Pong 读写混合测试（128 并发，16 KB）

12,868.24

10.03

70.14

Pipeline 纯写测试（128 并发，16 KB）

6,542.18

627.00

2,981.89

Pipeline 纯读测试（128 并发，16 KB）

215,512.81

19.09

45.57

Pipeline 读写混合测试（128 并发，16 KB）

12,600.41

325.68

1,581.06

512 并发

重要

在执行过程中，若遇到以下两种认证错误提示：

  • "error: authentication failed [-ERR wrong number of arguments for 'auth'/'hello' command.]"

  • "error: authentication failed [-WRONGPASS invalid username-password pair or user is disabled.]"

请按照说明进行修正：根据memtier_benchmark官方文档的认证参数规范，您需要将认证参数中的"-a $password"替换为完整的账号密码格式，即使用"-a username:password"的形式，其中username替换为您的实际用户名，password替换为对应的密码。

128 Byte测试命令

  1. 512并发下128 Byte的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 512并发下128 Byte的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 512并发下128 Byte的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 512并发下128 Byte的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 512并发下128 Byte的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 512并发下128 Byte的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 2000000  --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

1 KB测试命令

  1. 512并发下1 KB的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 512并发下1 KB的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 512并发下1 KB的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 512并发下1 KB的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 512并发下1 KB的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 512并发下1 KB的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

4 KB测试命令

  1. 512并发下4 KB的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 512并发下4 KB的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 512并发下4 KB的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 512并发下4 KB的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 512并发下4 KB的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 512并发下4 KB的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

16 KB测试命令

  1. 512并发下16 KB的Ping-Pong纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  2. 512并发下16 KB的Ping-Pong纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  3. 512并发下16 KB的Ping-Pong读写混合测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

  4. 512并发下16 KB的Pipeline纯写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0

  5. 512并发下16 KB的Pipeline纯读测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1

  6. 512并发下16 KB的Pipeline读写测试。

    memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000  --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1

测试结果性能对比如下：

测试场景

QPS

Avg Latency（ms）

p99 Latency（ms）

Ping-Pong 纯写测试（512 并发，128 Byte）

85,516.58

5.98

60.16

Ping-Pong 纯读测试（512 并发，128 Byte）

320,063.10

1.60

14.72

Ping-Pong 读写混合测试（512 并发，128 Byte）

208,489.07

2.46

22.53

Pipeline 纯写测试（512 并发，128 Byte）

116,795.27

140.16

2,834.43

Pipeline 纯读测试（512 并发，128 Byte）

323,316.82

50.77

436.22

Pipeline 读写混合测试（512 并发，128 Byte）

205,215.89

79.93

2,719.74

Ping-Pong 纯写测试（512 并发，1 KB）

95,896.76

5.36

36.86

Ping-Pong 纯读测试（512 并发，1 KB）

498,535.49

1.04

5.02

Ping-Pong 读写混合测试（512 并发，1 KB）

187,732.88

2.75

19.20

Pipeline 纯写测试（512 并发，1 KB）

149,738.66

109.44

1,024.00

Pipeline 纯读测试（512 并发，1 KB）

929,717.39

17.73

137.22

Pipeline 读写混合测试（512 并发，1 KB）

208,624.31

78.35

1,277.95

Ping-Pong 纯写测试（512 并发，4 KB）

38,969.61

13.17

111.61

Ping-Pong 纯读测试（512 并发，4 KB）

408,631.46

1.28

4.67

Ping-Pong 读写混合测试（512 并发，4 KB）

78,955.68

6.50

71.68

Pipeline 纯写测试（512 并发，4 KB）

48,330.42

339.82

3,948.54

Pipeline 纯读测试（512 并发，4 KB）

494,936.80

33.53

243.71

Pipeline 读写混合测试（512 并发，4 KB）

83,907.15

195.16

3,112.96

Ping-Pong 纯写测试（512 并发，16 KB）

6,439.60

79.68

245.76

Ping-Pong 纯读测试（512 并发，16 KB）

211,629.97

2.44

15.17

Ping-Pong 读写混合测试（512 并发，16 KB）

12,453.06

41.15

216.06

Pipeline 纯写测试（512 并发，16 KB）

6,586.62

2,503.77

40,894.46

Pipeline 纯读测试（512 并发，16 KB）

208,420.70

79.56

708.61

Pipeline 读写混合测试（512 并发，16 KB）

13,054.47

1,260.14

15,269.89

总结

  • PolarDB Orca功能沿用了PolarDB MySQL版所采用的分布式存储架构，并实施了三副本冗余机制，以确保数据无丢失风险。

  • 在Pipeline场景中，PolarDB Orca功能通过大量的聚合优化操作，显著提升了系统吞吐性能。建议您根据实际业务需求，灵活选用Pipeline模式。

上一篇：全球数据库网络（GDN）集群使用Orca下一篇：PolarStore