Todos os produtos
Search

Este produto

    PolarDB:Whitepapers de desempenho

    Central de documentação

    PolarDB:Whitepapers de desempenho

    Última atualização: Aug 26, 2026

    O PostgreSQL inclui o pgbench, uma ferramenta leve de teste de estresse para execução de benchmarks no PolarDB for PostgreSQL (Compatible with Oracle). Essa ferramenta executa repetidamente os mesmos comandos SQL em sessões simultâneas de banco de dados. Este tópico descreve como usar o pgbench para testar o desempenho máximo de um cluster PolarDB for PostgreSQL (Compatible with Oracle).

    Ambiente de testes

    • Todos os testes foram executados na região China (Qingdao). O cluster PolarDB e a instância ECS estavam na mesma zona.

    • Tipo de instância ECS: ecs.g5.16xlarge (64 núcleos, 256 GiB).

    • Especificações de armazenamento da ECS: disco local SSD de 200 GiB.

    • Tipo de rede: Virtual Private Cloud (VPC). O cluster PolarDB e a instância ECS estavam na mesma VPC.

    • Sistema operacional: CentOS 7.6 x64.

    • Nós do cluster PolarDB: um nó primário e um nó somente leitura.

    Nota

    O CentOS 6 não oferece suporte ao PostgreSQL 11.

    Métricas de teste

    • Consultas por segundo (QPS) somente leitura

      Número de instruções SQL somente leitura (apenas SELECT) executadas por segundo.

    • QPS de leitura e gravação

      Número de instruções SQL de leitura e gravação (INSERT, SELECT e UPDATE) executadas por segundo.

    Preparações

    • Instale a ferramenta de teste

      Execute os comandos a seguir para instalar o PostgreSQL 11 na instância ECS.

      sudo yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm
sudo yum install -y postgresql11

    • Modifique os parâmetros do cluster

      Os parâmetros do cluster

      PolarDB

      devem ser modificados da seguinte forma:

      log_statement = 'none'
enable_hashjoin=off
enable_mergejoin=off
enable_bitmapscan=off
      Nota

      Atualmente, apenas o parâmetro

      log_statement

      pode ser modificado no console. Para obter mais informações sobre como definir parâmetros de cluster, consulte

      Set cluster parameters

      .

      Após modificar os parâmetros de configuração, reinicie o cluster para que as alterações entrem em vigor.

    Método de teste

    1. Execute os comandos a seguir para configurar as variáveis de ambiente:

      export PGHOST=<Private endpoint of the PolarDB cluster>
export PGPORT=<Private port of the PolarDB cluster>
export PGDATABASE=postgres
export PGUSER=<Username for the PolarDB database>
export PGPASSWORD=<Password for the PolarDB user>
      Nota

      Para obter mais informações sobre como visualizar o endpoint de um cluster

      PolarDB for PostgreSQL (Compatible with Oracle)

      , consulte

      View endpoints and ports

      .

    2. Inicialize os dados de teste conforme o tamanho do banco de dados de destino. Utilize os seguintes comandos:

      • Inicialize 1 bilhão de entradas de dados:

        /usr/pgsql-11/bin/pgbench -i -s 10000

      • Inicialize 500 milhões de entradas de dados:

        /usr/pgsql-11/bin/pgbench -i -s 5000

      • Inicialize 100 milhões de entradas de dados:

        /usr/pgsql-11/bin/pgbench -i -s 1000

    3. Crie scripts de teste somente leitura e de leitura/gravação.

      • Crie o script somente leitura ro.sql:

        1. Execute o comando vim ro.sql.

        2. Pressione a tecla I para entrar no modo de edição.

        3. Insira o seguinte conteúdo:

          \set aid random_gaussian(1, :range, 10.0)
SELECT abalance FROM pgbench_accounts WHERE aid = :aid;

        4. Pressione a tecla Esc para sair do modo de edição e insira :wq para salvar e sair.

      • Crie o script de leitura/gravação rw.sql:

        1. Execute o comando vim rw.sql.

        2. Pressione a tecla I para entrar no modo de edição.

        3. Insira o seguinte conteúdo:

          \set aid random_gaussian(1, :range, 10.0)
\set bid random(1, 1 * :scale)
\set tid random(1, 10 * :scale)
\set delta random(-5000, 5000)
BEGIN;
UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
END;

        4. Pressione a tecla Esc para sair do modo de edição e insira :wq para salvar e sair.

    4. Execute os comandos a seguir para realizar os testes:

      • Teste somente leitura:

        88-core 710 GB (polar.o.x8.12xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 256 -j 128 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 256 -j 128 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 256 -j 128 -T 120 -D scale=10000 -D range=1000000000

64-core 512 GB (polar.o.x8.8xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 256 -j 128 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 256 -j 128 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 256 -j 128 -T 120 -D scale=10000 -D range=1000000000

32-core 256 GB (polar.o.x8.4xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 128 -j 128 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 128 -j 128 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 128 -j 128 -T 120 -D scale=10000 -D range=1000000000

16-core 128 GB (polar.o.x8.2xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=1000000000

8-core 64 GB (polar.o.x8.xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 64 -j 32 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 64 -j 32 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 64 -j 32 -T 120 -D scale=10000 -D range=1000000000

8-core 32 GB (polar.o.x4.xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 64 -j 32 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 64 -j 32 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 64 -j 32 -T 120 -D scale=10000 -D range=1000000000

4-core 16 GB (polar.o.x4.large)
Total data volume: 500 million, Hot data: 50 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 32 -j 32 -T 120 -D scale=5000 -D range=50000000
Total data volume: 500 million, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 32 -j 32 -T 120 -D scale=5000 -D range=100000000

2-core 4 GB (polar.o.x4.medium)
Total data volume: 100 million, Hot data: 50 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./ro.sql -c 16 -j 32 -T 120 -D scale=1000 -D range=50000000
Total data volume: 100 million, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./ro.sql -c 16 -j 32 -T 120 -D scale=1000 -D range=100000000

      • Teste de leitura/gravação:

        88-core 710 GB (polar.o.x8.12xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 256 -j 256 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 256 -j 256 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 256 -j 256 -T 120 -D scale=10000 -D range=1000000000

64-core 512 GB (polar.o.x8.8xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 256 -j 256 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 256 -j 256 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 256 -j 256 -T 120 -D scale=10000 -D range=1000000000

32-core 256 GB (polar.o.x8.4xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 128 -j 128 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 128 -j 128 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 128 -j 128 -T 120 -D scale=10000 -D range=1000000000

16-core 128 GB (polar.o.x8.2xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=1000000000

8-core 64 GB (polar.o.x8.xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 64 -j 64 -T 120 -D scale=10000 -D range=1000000000

8-core 32 GB (polar.o.x4.xlarge)
Total data volume: 1 billion, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 32 -j 32 -T 120 -D scale=10000 -D range=100000000
Total data volume: 1 billion, Hot data: 500 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 32 -j 32 -T 120 -D scale=10000 -D range=500000000
Total data volume: 1 billion, Hot data: 1 billion
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 32 -j 32 -T 120 -D scale=10000 -D range=1000000000

4-core 16 GB (polar.o.x4.large)
Total data volume: 500 million, Hot data: 50 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 16 -j 16 -T 120 -D scale=5000 -D range=50000000
Total data volume: 500 million, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 16 -j 16 -T 120 -D scale=5000 -D range=100000000

2-core 8 GB (polar.o.x4.medium)
Total data volume: 100 million, Hot data: 50 million
/usr/pgsql-11/bin/pgbench -M prepared -v -r -P 1 -f ./rw.sql -c 8 -j 8 -T 120 -D scale=1000 -D range=50000000
Total data volume: 100 million, Hot data: 100 million
/usr/pgsql-11/bin/pgbench -M prepared -n -r -P 1 -f ./rw.sql -c 8 -j 8 -T 120 -D scale=1000 -D range=100000000
      Nota

      • scale: valor multiplicado por 100.000 para representar o volume de dados de teste.

      • range: volume de dados ativos.

      • -c: número de conexões de teste simultâneas. Esse valor não representa o limite máximo de conexões do tipo de instância. Para obter mais informações sobre o limite de conexões, consulte Compute node specifications.

    Resultados dos testes

    EspecificaçõesVolume de dados de testeVolume de dados quentes (ativos)QPS somente leituraQPS de leitura/gravação

    polar.o.x8.12xlarge

    88 núcleos, 710 GB

    		1 bilhão100 milhões630650,40263746,37
    500 milhões601262,24247352,76
    1 bilhão589405,79218788,92

    polar.o.x8.8xlarge

    64 núcleos, 512 GB

    		1 bilhão100 milhões592064,65227352,23
    500 milhões554777,11213343,13
    1 bilhão508404,07203331,35

    polar.o.x8.4xlarge

    32 núcleos, 256 GB

    		1 bilhão100 milhões522182,92213212,34
    500 milhões509372,85203322,34
    1 bilhão489349,72198531,37

    polar.o.x8.2xlarge

    16 núcleos, 128 GB

    		1 bilhão100 milhões263893,72152863,27
    500 milhões250221,62129238,26
    1 bilhão239832,62106212,82

    polar.o.x8.xlarge

    8 núcleos, 64 GB

    		1 bilhão100 milhões142836,5669725,29
    500 milhões133931,6955927,65
    1 bilhão124151,0250786,21

    polar.o.x4.xlarge

    8 núcleos, 32 GB

    		1 bilhão100 milhões126748,0759738,33
    500 milhões113432,3248372,25
    1 bilhão104232,8449763,64

    polar.o.x4.large

    4 núcleos, 16 GB

    		500 milhões50 milhões76238,8947388,27
    100 milhões69892,8343638,85

    polar.o.x4.medium

    2 núcleos, 8 GB

    		100 milhões50 milhões28320,7018152,63
    100 milhões30792,1919111,15
    Nota

    • Especificações: código do tipo de instância do PolarDB for PostgreSQL (Compatible with Oracle).

    • Volume de dados de teste: número de registros nesta rodada de testes.

    • Volume de dados quentes (ativos): número de registros utilizados pelas instruções SQL de consulta e atualização nesta rodada de testes.

    • QPS somente leitura: número de consultas somente leitura executadas por segundo.

    • QPS de leitura/gravação: número de consultas de leitura e gravação executadas por segundo.

    2c8g

    4c16g

    8c32g

    8c64g

    16c128g

    32c256g

    64c512g

    88c710g