Todos os produtos
Search
Central de documentação

PolarDB:Limitação de SQL

Última atualização: Jun 28, 2026

e oferecem um recurso de limitação de SQL. Esse recurso permite configurar regras de limitação para endpoints específicos, evitando que tráfego anormal afete seus serviços. Este tópico descreve como utilizar o recurso de limitação de SQL.

Introdução

O recurso de limitação de SQL possibilita a configuração de regras de limitação para endpoints específicos. Utilize um modelo de SQL para corresponder às instruções SQL executadas no endpoint atual e limitar sua concorrência máxima ou consultas por segundo (QPS). Este recurso é adequado para os seguintes cenários:

  • Um cluster PolarDB apresenta alta carga no banco de dados devido a uma consulta SQL lenta, o que impacta as operações normais do negócio.

  • Necessidade de limitar os recursos disponíveis para tipos específicos de consultas SQL de risco ou bloquear totalmente sua execução.

Procedimento

Nota

Para ativar o recurso de limitação de SQL, entre em contato conosco.

  1. Faça login no console do PolarDB. No painel de navegação à esquerda, clique em Clusters. Selecione a região onde o cluster está localizado e clique no ID do cluster para abrir a página de detalhes do cluster.

  2. No painel de navegação à esquerda, clique em Configuration and Management > Security Management.

  3. Na aba SQL throttling, clique em Add para criar uma nova regra de limitação de SQL.

  4. Na caixa de diálogo Create SQL Throttling Rule, defina os parâmetros a seguir e clique em OK.

    Categoria

    Parâmetro

    Descrição

    Basic Information

    Rule Name

    Nome da regra de limitação. O nome deve atender aos seguintes requisitos:

    • Ter no máximo 30 caracteres.

    • Conter apenas letras maiúsculas, letras minúsculas e dígitos.

    Description

    Opcional. Descrição da regra de limitação para facilitar o gerenciamento. Deve ter no máximo 64 caracteres.

    EndpointId

    Selecione o endpoint ao qual a regra de limitação se aplica.

    Nota
    • É possível configurar regras de limitação apenas para um endpoint de cluster ou um endpoint personalizado (leitura/escrita ou somente leitura) que utilize balanceamento de carga baseado em solicitações ativas. A limitação de SQL não é suportada para endpoints primários ou para endpoints somente leitura que utilizam balanceamento de carga baseado em conexão.

    • As regras são específicas por endpoint. Uma regra configurada para um endpoint afeta apenas as conexões feitas a esse endpoint.

    Configurations

    Rule Type

    Selecione um tipo de regra. Há suporte para Throttle Active Concurrent Statements e Throttle QPS per Connection.

    Nota

    Throttle QPS per Connection limita o número de solicitações por segundo para uma única conexão. Este tipo é indicado para cenários em que se utiliza pool de conexões ou conexão persistente. Para conexões de curta duração, utilize Throttle Active Concurrent Statements.

    Current Mode

    Selecione um modo de correspondência para o modelo de SQL. Há suporte para Template Match e Full-text Match. Para mais informações sobre as diferenças entre os dois modos, consulte Correspondência por modelo versus correspondência por texto completo.

    Database Account Name

    Especifique as contas às quais a regra se aplica. É possível especificar até 10 contas, separadas por vírgulas. Se deixado em branco, a regra se aplica a todas as contas.

    Database Name

    Especifique os bancos de dados aos quais a regra se aplica. É possível especificar até 10 bancos de dados, separados por vírgulas. Se deixado em branco, a regra se aplica a todos os bancos de dados.

    SQL Template

    Configure o modelo de SQL. Para mais informações, consulte Modelos de SQL e modos de correspondência.

    Maximum Waiting Queue Length

    Comprimento máximo da fila de espera. O valor pode variar de 0 a 1024. Quando a concorrência ou QPS das consultas SQL correspondentes atinge o limite da regra, o proxy adiciona as consultas a uma fila de espera para nova tentativa. Se o número de consultas na fila exceder esse limite, novas solicitações falharão e um erro será retornado. Definir corretamente este parâmetro evita que a fila de espera cresça indefinidamente e cause um erro de falta de memória (OOM) no proxy do banco de dados quando muitas consultas SQL forem limitadas.

    Maximum Active Concurrent Statements

    Número máximo de instruções concorrentes ativas.

    Nota

    Este parâmetro é obrigatório apenas quando Throttle Active Concurrent Statements estiver definido como Throttle Active Concurrent Statements.

    Maximum QPS per Connection

    QPS máximo para cada conexão.

    Nota

    Este parâmetro é obrigatório apenas quando Throttle QPS per Connection estiver definido como Throttle QPS per Connection.

Como funciona

A limitação de SQL é implementada no nível do proxy do banco de dados. Configure regras de limitação no proxy do banco de dados para controlar a concorrência ou QPS de instruções SQL encaminhadas específicas. Esse processo não adiciona sobrecarga aos nós de leitura/escrita ou somente leitura do cluster de banco de dados. Consequentemente, é possível configurar regras apenas para endpoints de cluster e personalizados, que roteiam o tráfego através do proxy.

Modelos de SQL e modos de correspondência

Correspondência por modelo versus correspondência por texto completo

Um modelo de SQL pode ser qualquer instrução SQL que siga a sintaxe padrão de um cluster ou . O proxy do banco de dados pré-processa o modelo de forma diferente com base no modo de correspondência selecionado.

  • Suponha que você configure uma regra de limitação com o seguinte modelo de SQL:

    SELECT * FROM tbl WHERE id < 1;
    • Se você selecionar Template Match, o modelo de SQL será normalizado. Espaços extras e comentários são removidos, e constantes como strings entre aspas simples e números são substituídos por um curinga. O resultado é:

      -- Templated result
      SELECT * FROM tbl WHERE id < ?
    • Se você selecionar Full-text Match, o modelo de SQL também será normalizado, mas as constantes não serão substituídas. O resultado é:

      -- Normalized result only
      SELECT * FROM tbl WHERE id < 1

    Em seguida, o proxy do banco de dados gera um identificador exclusivo para o SQL processado para correspondência posterior.

  • Após a ativação da regra de limitação, o proxy do banco de dados pré-processa cada instrução SQL recebida de maneira similar. Por exemplo, considere a seguinte instrução SQL recebida:

    SELECT * FROM tbl WHERE id < 100;

    Dois tipos de SQL normalizado são gerados e seus identificadores exclusivos são calculados para corresponder à regra de limitação:

    -- Templated result
    SELECT * FROM tbl WHERE id < ?
    -- Normalized result only
    SELECT * FROM tbl WHERE id < 100

Após a ativação de uma regra de limitação de SQL, o proxy do banco de dados avalia a instrução em relação às regras configuradas antes de encaminhar a instrução SQL. Se a regra estiver configurada para Template Match, ela usa o resultado modelado para correspondência. Se a regra estiver configurada para Full-text Match, o resultado apenas normalizado é usado. Uma vez encontrada uma correspondência, sua concorrência ou QPS é calculado e o proxy executa a ação de limitação correspondente.

Portanto, para a instrução SQL e o modelo de SQL no exemplo anterior, uma correspondência é encontrada apenas quando a regra está configurada para Template Match.

Consultas parametrizadas

Os modelos de SQL suportam consultas parametrizadas que usam a sintaxe padrão de vinculação de parâmetros do PostgreSQL:

SELECT * FROM tbl WHERE id < $1 AND name = $2 LIMIT 1;

Nos modos Template Match e Full-text Match, as partes parametrizadas são formatadas como curingas:

-- Templated result
SELECT * FROM tbl WHERE id < ? AND name = ? limit ?
-- Normalized result only
SELECT * FROM tbl WHERE id < ? AND name = ? limit 1

Portanto, para a seguinte instrução SQL:

SELECT * FROM tbl WHERE id < $1 AND name = 2 LIMIT 100;

Uma correspondência é encontrada se o Current Mode estiver definido como Template Match. Nenhuma correspondência é encontrada se o Current Mode estiver definido como Full-text Match.

Nota

Não é possível usar o caractere ? como marcador de parâmetro em um modelo de SQL:

-- Invalid SQL template. This does not conform to standard PostgreSQL syntax and will not match any SQL.
SELECT ?, ?, ?;
-- Valid SQL template
SELECT $1, $2, $3;

Instruções preparadas

Quando sua aplicação usa uma instrução preparada, a própria instrução PREPARE não aciona a limitação. Apenas a instrução EXECUTE aciona a limitação. Para uma instrução EXECUTE, a parte SQL da instrução PREPARE correspondente é formatada ou modelada para corresponder às regras.

Nota

Para mais informações sobre instruções preparadas, consulte PREPARE.

Exemplo

Configure uma regra de limitação com o seguinte modelo de SQL e selecione Template Match para o modo de correspondência:

SELECT * FROM tbl WHERE id < $1 AND name > $2;

Para a seguinte instrução SQL:

-- The PREPARE statement does not trigger throttling.
PREPARE s1 AS SELECT * FROM tbl WHERE id < $1 AND name > 100;
-- The EXECUTE statement uses the SQL part from its corresponding PREPARE statement to match the throttling rule.
EXECUTE s1;
EXECUTE s1;
EXECUTE s1;

As três instruções EXECUTE corresponderão à regra de limitação e serão limitadas.

Da mesma forma, se você usar uma instrução PREPARE no modelo de SQL de uma regra de limitação, apenas a parte SQL da instrução PREPARE será formatada ou modelada para limitação. Portanto, os dois modelos de SQL a seguir são equivalentes ao criar uma regra:

-- Template 1
PREPARE s1 AS SELECT * FROM tbl WHERE id < $1 AND name > $2;
-- Template 2
SELECT * FROM tbl WHERE id < $1 AND name > $2;

Suporte ao protocolo de consulta estendida

Semelhante a uma instrução preparada, quando um driver de aplicação usa o protocolo de consulta estendida, apenas a mensagem Execute aciona a limitação. Para cada mensagem Execute, o proxy do banco de dados encontra a mensagem Parse correspondente e usa seu SQL para corresponder às regras de limitação. Portanto, a limitação de SQL suporta o protocolo de consulta estendida, então geralmente não é necessário se preocupar com o protocolo que sua aplicação utiliza.

Nota

Para mais informações sobre o protocolo de consulta estendida, consulte a documentação da comunidade.

Limitações

Atualmente, o recurso de limitação de SQL apresenta as seguintes limitações:

  • Não há suporte para limitação em multi-instruções. Se você usar uma multi-instrução, nenhuma regra de limitação configurada será acionada.

    Uma multi-instrução refere-se a um único texto SQL que contém várias instruções SQL separadas por ponto e vírgula. A seguir, um exemplo de multi-instrução executada usando um driver JDBC:

    Statement statement = connection.createStatement();
    statement.execute("select 1; select 2; select 3");

    Uma multi-instrução pode corresponder a várias regras de limitação simultaneamente. Para evitar comportamentos inesperados, não há suporte para limitação em multi-instruções.

  • Não há suporte para limitação em algumas instruções especiais, como instruções de controle de transação e procedimentos armazenados. Limitar uma instrução de controle de transação como COMMIT impediria que as transações terminassem normalmente. Por esse motivo, elas estão isentas das regras de limitação.

  • Quando um cliente ou driver usa o modo de lote de instruções, as consultas SQL em lote acionam apenas a primeira regra de limitação correspondente. A seguir, um exemplo de lote de instruções usando um driver JDBC:

    Statement statement = connection.createStatement();
    statement.addBatch("select 1");
    statement.addBatch("select 2");
    statement.addBatch("select 3");
    int[] result = statement.executeBatch();
    statement.close();
    connection.close();

    Assim como em uma multi-instrução, ao usar lotes de instruções, o driver geralmente combina as mensagens do protocolo de consulta estendida para várias consultas SQL e as envia de uma só vez. Isso também pode resultar em uma situação em que várias regras de limitação são correspondidas simultaneamente. Nesse caso, apenas a primeira regra de limitação correspondente entra em vigor. No exemplo anterior, se regras de limitação para os três modelos de SQL a seguir estiverem configuradas no endpoint:

    -- Template 1
    SELECT 1;
    -- Template 2
    SELECT 2;
    --Template 3
    SELECT 3;

    Apenas o Modelo 1 será correspondido.

  • A caixa das palavras-chave no seu modelo deve corresponder à caixa no texto SQL que você deseja limitar.

  • Os modelos de SQL não suportam modelagem para expressões de comprimento variável, como IN ou ANY, onde o número de elementos pode variar. Por exemplo:

    -- SQL template
    SELECT * FROM tbl WHERE id IN ($1, $2, $3);
    -- SQL1, can match the template
    SELECT * FROM tbl WHERE id IN (1, 6, 8);
    -- SQL2, cannot match the template
    SELECT * FROM tbl WHERE id IN (1, 6, 8, 8);
  • Quando nenhuma regra de limitação está configurada, a primeira regra adicionada não se aplica às conexões existentes. Se alguma regra já estiver configurada no console (ativada ou desativada), adições, modificações ou exclusões subsequentes de regras entram em vigor em tempo real para todas as conexões.

    Nota
    • Se sua aplicação usa uma conexão persistente e você deseja que novas regras entrem em vigor imediatamente, recomendamos configurar e desativar uma regra arbitrária no endpoint. Assim, quaisquer regras subsequentes que você adicionar ou modificar entrarão em vigor tanto para conexões novas quanto para as existentes.

    • Se a versão do seu PolarProxy for 2.3.58 ou posterior, a adição, modificação e exclusão de regras de limitação entram em vigor em tempo real para todas as conexões.

Comportamento de limitação

A limitação de SQL usa modelos de SQL e uma fila de espera para limitar o QPS ou a concorrência ativa. Uma instrução SQL deve corresponder a uma regra de limitação antes que seu QPS ou concorrência seja contabilizado para essa regra. Quando a concorrência ou QPS excede o limite definido na regra, o proxy do banco de dados coloca a instrução SQL em uma fila de espera para ser tentada novamente após um atraso. Isso garante que a concorrência ou QPS no banco de dados permaneça dentro do limite configurado.

O tempo de atraso da fila de espera é inversamente proporcional ao QPS ou concorrência configurados na regra. O número máximo de instruções SQL que podem aguardar na fila para uma regra específica é limitado pelo parâmetro Maximum Waiting Queue Length. Se esse limite for excedido, o proxy não encaminha a instrução SQL e retorna o seguinte erro ao cliente:

SELECT 123;
Current query is being throttled and waiting queue is full.
Nota

O erro anterior não interrompe nem altera o estado da transação da conexão atual. Após receber esse erro, o cliente ainda pode optar por confirmar ou reverter a transação.

Além disso, se você definir Maximum Active Concurrent Statements ou Maximum QPS per Connection como 0 em uma regra de limitação, qualquer instrução SQL que corresponda à regra será rejeitada e não encaminhada. O cliente recebe o erro anterior diretamente. Use este método para bloquear completamente um tipo específico de instrução SQL.

Nota
  • A fila de espera possui um intervalo mínimo de nova tentativa. Se você definir um QPS máximo alto, o QPS real pode ser ligeiramente inferior ao valor definido.

  • Para alta disponibilidade, um proxy de banco de dados é normalmente implantado com dois ou mais nós, e as conexões do cliente são distribuídas aleatoriamente entre eles. Os parâmetros Maximum Active Concurrent Statements e Maximum Waiting Queue Length são configurados no nível do nó. Cada nó conta independentemente a concorrência e o comprimento da fila, portanto, a concorrência real não pode ser controlada com precisão. Suponha que o número de nós seja N, e a configuração de nó único seja C (Maximum Active Concurrent Statements) e Q (Maximum Waiting Queue Length). O intervalo de concorrência do cliente é [C+Q, N×(C+Q)], e o intervalo de concorrência ativa do banco de dados é [C, N×C].

  • Após configurar qualquer regra de limitação de SQL, o proxy precisa modelar cada instrução SQL de negócio, gerar um identificador exclusivo e tentar correspondê-la às regras, independentemente de uma correspondência ser encontrada ou não. Portanto, ativar a limitação de SQL pode causar uma diminuição de 5% a 10% no desempenho de encaminhamento. Use a limitação apenas quando uma consulta SQL lenta estiver afetando significativamente suas operações normais de negócio. Após resolver a consulta SQL lenta, você pode desativar a regra de limitação no console. Regras desativadas não entram em vigor, mas são salvas, e você pode reativá-las a qualquer momento.

Melhores práticas

Verificar uma regra de limitação

Como as regras de limitação podem ser definidas para contas e bancos de dados específicos, você pode criar uma conta de teste e configurar uma regra com concorrência ou QPS definido como 0 para verificar se a regra consegue corresponder à instrução SQL desejada.

Suponha que você queira limitar a seguinte instrução SQL:

SELECT * FROM generate_series(1, 100000);
  1. Certifique-se de que o nome da conta seja test_usr, o tipo seja high-privilege account e o status seja Available.

  2. Configure uma regra de limitação para a conta de teste e defina o máximo de instruções concorrentes ativas como 0. Para detalhes sobre como configurar uma regra de limitação, consulte Procedimento.

    Para Rule Type, selecione Throttle Active Concurrent Statements. Para Current Mode, selecione Template Match. Para Database Account Name, insira test_usr. Para SQL Template, insira select * from generate_series(1, 100000);.

  3. Verifique se a regra está efetiva. Esta regra se aplica apenas à nova conta de teste e não afeta seus serviços atuais. Após a configuração, conecte-se ao banco de dados através do endpoint selecionado na regra e execute a instrução SQL. Se o erro esperado for retornado, a regra está funcionando corretamente:

    SELECT * FROM generate_series(1, 100000);
    Current query is being throttled and waiting queue is full.

Lidar com SQL lento em produção

  1. Prepare o ambiente de teste.

    • Prepare uma instância ECS

      1. Crie uma instância ECS baseada em Linux. Para este exemplo, é usada uma instância ECS executando CentOS 7.6 64 bits. Para mais informações, consulte Criar uma instância usando o assistente.

        Nota

        A instância ECS e o cluster PolarDB devem estar na mesma zona de disponibilidade e VPC.

      2. Instale a ferramenta pgbench na instância ECS.

        sudo yum install postgresql-contrib
    • Prepare um cluster PolarDB

      1. Acesse a página de compra de cluster PolarDB e

      2. Se o cluster PolarDB e a instância ECS estiverem na mesma zona de disponibilidade, você pode usar um endpoint privado. Caso contrário, solicite um endpoint público. Adicione o endereço IP da instância ECS à lista de permissões do cluster PolarDB. Para mais informações, consulte

      3. No console,

      4. Para garantir que as regras de limitação configuradas posteriormente tenham efeito nas conexões existentes, configure uma regra de espaço reservado no console e desative-a. Para mais informações, consulte Procedimento.

        Nota

        Esta etapa não é necessária se a versão do seu PolarProxy for 2.3.58 ou posterior, pois regras de limitação novas, modificadas ou excluídas entram em vigor em tempo real para todas as conexões.

  2. Na instância ECS, use o pgbench para conectar-se ao endpoint do cluster PolarDB e inicializar os dados de benchmark.

    pgbench -h <PolarDB cluster endpoint> -p <Port of PolarDB cluster endpoint> -i -s 10 -U <PolarDB database username> <Test database name>

    Em seguida, inicie o teste de estresse. Use o modo tpcb-like integrado do pgbench para simular uma carga de trabalho normal da aplicação.

    pgbench -h <PolarDB cluster endpoint> -p <Port of PolarDB cluster endpoint> -P 1 -b tpcb-like -j 5 -c 10 -M prepared -T 6000 -U <PolarDB database username> <Test database name> 
  3. Simule um cenário de SQL lento. Crie uma nova sessão de conexão e execute a seguinte instrução no banco de dados de teste:

    WITH t AS (SELECT md5(i::text) AS id FROM generate_series(1, 10000000) i) SELECT * FROM t ORDER BY id LIMIT 1;

    Esta instrução SQL consome uma grande quantidade de recursos de computação e normalmente leva cerca de 5 segundos para retornar o seguinte resultado:

                    id                
    ----------------------------------
     0000023f507999464aa2b78875b7e5d6
    (1 row)

    Inicie o pgbench novamente. Use um script personalizado para testar a carga da instrução SQL anterior. Inicie 10 conexões para simular uma alta carga no cluster causada por consultas SQL lentas:

    echo "WITH t AS (SELECT md5(i::text) AS id FROM generate_series(1, 10000000) i) SELECT * FROM t ORDER BY id LIMIT 1;" > slow.sql
    pgbench -h <PolarDB cluster endpoint> -p <Port of PolarDB cluster endpoint> -P 1 -f slow.sql -j 5 -c 10 -M prepared -T 6000 -U <PolarDB database username> <Test database name> 

    Após o início do teste de estresse, a carga de trabalho normal original da aplicação cai drasticamente:

    progress: 11.0 s, 6324.2 tps, lat 1.581 ms stddev 0.454
    progress: 12.0 s, 6143.1 tps, lat 1.627 ms stddev 0.837
    progress: 13.0 s, 6251.8 tps, lat 1.599 ms stddev 0.464
    progress: 14.0 s, 6256.8 tps, lat 1.598 ms stddev 0.439
    progress: 15.0 s, 6201.0 tps, lat 1.612 ms stddev 0.536
    progress: 16.0 s, 6248.2 tps, lat 1.600 ms stddev 0.484
    progress: 17.0 s, 6290.0 tps, lat 1.589 ms stddev 0.439
    progress: 18.0 s, 6244.8 tps, lat 1.601 ms stddev 0.475
    progress: 19.0 s, 6195.0 tps, lat 1.613 ms stddev 0.576
    progress: 20.0 s, 6200.3 tps, lat 1.612 ms stddev 0.628
    progress: 21.0 s, 6099.7 tps, lat 1.640 ms stddev 0.666
    progress: 22.0 s, 5831.2 tps, lat 1.714 ms stddev 1.578
    progress: 23.0 s, 5122.8 tps, lat 1.952 ms stddev 3.239
    progress: 24.0 s, 5925.0 tps, lat 1.686 ms stddev 1.263
    progress: 25.0 s, 5677.0 tps, lat 1.763 ms stddev 1.606
    progress: 26.0 s, 5899.0 tps, lat 1.695 ms stddev 1.117
    progress: 27.0 s, 5832.0 tps, lat 1.714 ms stddev 2.484
    progress: 28.0 s, 6448.0 tps, lat 1.551 ms stddev 0.182
    progress: 29.0 s, 6449.0 tps, lat 1.550 ms stddev 0.187
    progress: 30.0 s, 1252.0 tps, lat 6.038 ms stddev 33.858
    progress: 31.0 s, 147.0 tps, lat 64.147 ms stddev 129.137
    progress: 32.0 s, 274.0 tps, lat 46.103 ms stddev 93.193
    progress: 33.0 s, 240.0 tps, lat 41.924 ms stddev 36.949
    progress: 34.0 s, 106.0 tps, lat 94.393 ms stddev 85.844
  4. No console, configure uma regra de limitação com o seguinte modelo de SQL e selecione Throttle Active Concurrent Statements para o tipo de regra:

    WITH t AS (SELECT md5(i::text) AS id FROM generate_series($1, $2) i) SELECT * FROM t ORDER BY id LIMIT $3;

    Para Current Mode, selecione Template Match. Para Database Account Name, insira test_usr. Para Database Name, insira test_db. Defina Maximum Waiting Queue Length como 1024.

    Limite a concorrência da consulta SQL lenta a 1. Após ativar a regra, você verá a carga de trabalho da aplicação se recuperar, o que indica que a regra de limitação está efetiva.

    progress: 56.0 s, 127.0 tps, lat 82.943 ms stddev 81.855
    progress: 57.0 s, 137.0 tps, lat 68.631 ms stddev 32.356
    progress: 58.0 s, 127.0 tps, lat 84.783 ms stddev 78.936
    progress: 59.0 s, 146.0 tps, lat 67.840 ms stddev 11.758
    progress: 60.0 s, 145.0 tps, lat 62.824 ms stddev 25.166
    progress: 61.0 s, 134.0 tps, lat 82.475 ms stddev 68.729
    progress: 62.0 s, 142.0 tps, lat 70.240 ms stddev 18.793
    progress: 63.0 s, 1994.1 tps, lat 5.134 ms stddev 14.502
    progress: 64.0 s, 3347.8 tps, lat 2.973 ms stddev 9.346
    progress: 65.0 s, 707.0 tps, lat 14.247 ms stddev 25.863
    progress: 66.0 s, 4410.0 tps, lat 2.273 ms stddev 5.326
    progress: 67.0 s, 5808.0 tps, lat 1.722 ms stddev 0.667
    progress: 68.0 s, 5436.0 tps, lat 1.840 ms stddev 3.052
    progress: 69.0 s, 6100.0 tps, lat 1.639 ms stddev 0.208
    progress: 70.0 s, 6107.0 tps, lat 1.638 ms stddev 0.204
    progress: 71.0 s, 6066.0 tps, lat 1.648 ms stddev 0.456
    progress: 72.0 s, 6086.0 tps, lat 1.643 ms stddev 0.202
  5. No console, modifique a regra de limitação. Na coluna Actions da regra alvo, clique em Modify e defina Maximum Active Concurrent Statements como 0 para bloquear completamente as consultas SQL lentas.

    Após a configuração, o teste de estresse de SQL lento retorna um erro e é interrompido. Neste ponto, a carga de trabalho da aplicação é totalmente restaurada.

    progress: 198.0 s, 0.0 tps, lat 0.000 ms stddev 0.000
    progress: 199.0 s, 0.0 tps, lat 0.000 ms stddev 0.000
    progress: 200.0 s, 0.0 tps, lat 0.000 ms stddev 0.000
    progress: 201.0 s, 2.0 tps, lat 5733.302 ms stddev 39.976
    progress: 202.0 s, 0.0 tps, lat 0.000 ms stddev 0.000
    pgbench: error: client 1 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 0 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 9 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 8 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 5 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 2 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 7 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 4 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 3 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    pgbench: error: client 6 script 0 aborted in command 0 query 0: Current query is being throttled and waiting queue is full.
    transaction type: slow.sql
    scaling factor: 1
    query mode: prepared
    number of clients: 10
    number of threads: 5
    duration: 6000 s
    number of transactions actually processed: 112