Todos os produtos
Search

Este produto

    PolarDB:White paper de desempenho

    Central de documentação

    PolarDB:White paper de desempenho

    Última atualização: Jun 28, 2026

    O PostgreSQL compatível com Oracle oferece o pgbench, uma ferramenta leve para testes de estresse. Com ela, é possível executar benchmarks no PostgreSQL por meio da execução repetida de uma mesma sequência de instruções SQL em várias sessões simultâneas de banco de dados. Este tópico descreve como utilizar o pgbench para testar o desempenho máximo de clusters do PolarDB for PostgreSQL (Compatible with Oracle).

    Ambientes de teste

    • Todos os testes devem ser realizados na região China (Qingdao). O cluster PolarDB precisa estar na mesma zona da instância ECS.

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

    • Armazenamento ECS: SSDs locais de 200 GiB

    • Tipo de rede: virtual private cloud (VPC). O cluster PolarDB e a instância ECS devem pertencer à mesma VPC.

    • Sistema operacional: versão de 64 bits do CentOS 7.6

    • Quantidade de nós no 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 somente leitura por segundo (QPS)

      Quantidade de instruções SELECT executadas por segundo durante operações somente leitura no banco de dados.

    • QPS de leitura e escrita

      Quantidade de instruções SELECT, INSERT e UPDATE executadas por segundo durante operações de leitura e escrita no banco de dados.

    Antes de começar

    • Instale o PostgreSQL 11.

      Execute os comandos abaixo para instalar o PostgreSQL 11 na sua 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

    • Configure os parâmetros do seu cluster PolarDB.

      No cluster

      PolarDB

      , defina os seguintes parâmetros:

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

      Apenas o parâmetro

      log_statement

      pode ser configurado diretamente no console do PolarDB. Para mais detalhes sobre a configuração de parâmetros de cluster, consulte

      Configurar parâmetros de cluster

      .

      Após configurar os parâmetros, reinicie o cluster PolarDB para que as alterações entrem em vigor.

    Métodos de teste

    1. Defina as variáveis de ambiente com os comandos a seguir:

      export PGHOST=<The internal endpoint of your PolarDB cluster>
export PGPORT=<The internal port number of your PolarDB cluster>
export PGDATABASE=postgres
export PGUSER=<The username used to log on to your PolarDB database>
export PGPASSWORD=<The password of your PolarDB account>
      Nota

      Para saber como visualizar os endpoints de clusters

      PolarDB for PostgreSQL (Compatible with Oracle)

      , consulte

      Visualizar endpoints e portas

      .

    2. Inicialize os dados de teste conforme o tamanho do banco de dados desejado.

      • Para inicializar 1 bilhão de registros, execute:

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

      • Para inicializar 500 milhões de registros, execute:

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

      • Para inicializar 100 milhões de registros, execute:

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

    3. Crie scripts de teste para operações somente leitura e de leitura/escrita.

      • Elabore um script para testar operações somente leitura e nomeie-o como 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 no editor:

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

        4. Pressione Esc para sair do modo de edição e digite :wq para salvar o arquivo e fechar o editor.

      • Elabore um script para testar operações de leitura e escrita e nomeie-o como 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 no editor:

          \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 Esc para sair do modo de edição e digite :wq para salvar o arquivo e fechar o editor.

    4. Execute os comandos abaixo para realizar os testes:

      • Teste as operações somente leitura com os seguintes comandos:

        88C 710 GB(polar.o.x8.12xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

64C 512 GB(polar.o.x8.8xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

32C 256 GB(polar.o.x8.4xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

16cC 128 GB(polar.o.x8.2xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

8C 64 GB(polar.o.x8.xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

8C 32 GB(polar.o.x4.xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

4C 16 GB(polar.o.x4.large)
Total data volume: 500 million records, hot data: 50 million records
/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 records, hot data: 100 million records
/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

2C 4 GB(polar.o.x4.medium)
Total data volume: 100 million records, hot data: 50 million records
/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 records, hot data: 100 million records
/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 as operações de leitura e escrita com os seguintes comandos:

        88C 710 GB(polar.o.x8.12xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

64C 512 GB(polar.o.x8.8xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

32C 256 GB(polar.o.x8.4xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

16C 128 GB(polar.o.x8.2xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

8C 64 GB(polar.o.x8.xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

8C 32 GB(polar.o.x4.xlarge)
Total data volume: 1 billion records, hot data: 100 million records
/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 records, hot data: 500 million records
/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 records, hot data: 1 billion records
/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

4C 16 GB(polar.o.x4.large)
Total data volume: 500 million records, hot data: 50 million records
/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 records, hot data: 100 million records
/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

2C 8 GB(polar.o.x4.medium)
Total data volume: 100 million records, hot data: 50 million records
/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 records, hot data: 100 million records
/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: O valor de scale multiplicado por 100.000 representa a quantidade total de registros de dados de teste.

      • range: Define a quantidade de registros de dados quentes.

      • -c: Determina o número de conexões utilizadas no teste. Esse valor não corresponde necessariamente ao limite máximo de conexões suportadas pelo tipo de cluster. Para mais informações, consulte Especificações de nós de computação.

    Resultados dos testes

    Código da especificaçãoQuantidade de registros de dados de testeQuantidade de registros de dados quentes (ativos)QPS somente leituraQPS de leitura e escrita

    polar.o.x8.12xlarge

    88 núcleos, 710 GB

    		1 bilhão100 milhões630.650,40263.746,37
    500 milhões601.262,24247.352,76
    1 bilhão589.405,79218.788,92

    polar.o.x8.8xlarge

    64 núcleos, 512 GB

    		1 bilhão100 milhões592.064,65227.352,23
    500 milhões554.777,11213.343,13
    1 bilhão508.404,07203.331,35

    polar.o.x8.4xlarge

    32 núcleos, 256 GB

    		1 bilhão100 milhões522.182,92213.212,34
    500 milhões509.372,85203.322,34
    1 bilhão489.349,72198.531,37

    polar.o.x8.2xlarge

    16 núcleos, 128 GB

    		1 bilhão100 milhões263.893,72152.863,27
    500 milhões250.221,62129.238,26
    1 bilhão239.832,62106.212,82

    polar.o.x8.xlarge

    8 núcleos, 64 GB

    		1 bilhão100 milhões142.836,5669.725,29
    500 milhões133.931,6955.927,65
    1 bilhão124.151,0250.786,21

    polar.o.x4.xlarge

    8 núcleos, 32 GB

    		1 bilhão100 milhões126.748,0759.738,33
    500 milhões113.432,3248.372,25
    1 bilhão104.232,8449.763,64

    polar.o.x4.large

    4 núcleos, 16 GB

    		500 milhões50 milhões76.238,8947.388,27
    100 milhões69.892,8343.638,85

    polar.o.x4.medium

    2 núcleos, 8 GB

    		100 milhões50 milhões28.320,7018.152,63
    100 milhões30.792,1919.111,15
    Nota

    • Código da especificação: identificador das especificações do PolarDB for PostgreSQL (Compatible with Oracle).

    • Quantidade de registros de dados de teste: total de registros utilizados no teste.

    • Quantidade de registros de dados quentes (ativos): volume de registros envolvidos nas consultas e atualizações SQL durante o teste.

    • QPS somente leitura: número de requisições somente leitura processadas por segundo.

    • QPS de leitura e escrita: número de requisições de leitura e escrita processadas por segundo.

    2c8g

    4c16g

    8c32g

    8c64g

    16c128g

    32c256g

    64c512g

    88c710g