Todos os produtos
Search
Central de documentação

Hologres:Gerenciar consultas

Última atualização: Jun 28, 2026

Diagnostique e gerencie consultas em execução em uma instância do Hologres.

Visão geral

O Hologres é compatível com PostgreSQL. Use a visualização hg_stat_activity (pg_stat_activity) para monitorar o tempo de execução das consultas em uma instância. Este tópico aborda as seguintes operações:

Nota

O Hologres não oferece suporte a limites de memória ou CPU por consulta. Para controlar recursos de consulta, use uma fila de consultas para gerenciar e agendar recursos de carga de trabalho.

Visualizar consultas ativas usando SQL

Use as seguintes instruções SQL para visualizar consultas ativas:

  1. Visualize consultas ativas, seus estágios de execução e o consumo de recursos.

    Nota

    Superusuários podem visualizar informações de tempo de execução de todos os usuários. Outros usuários visualizam apenas as próprias informações.

    -- For Hologres V2.0 and later
    SELECT query,state,query_id,transaction_id,running_info, extend_info 
    FROM hg_stat_activity 
    WHERE state = 'active' 
    AND     backend_type = 'client backend'
    AND     application_name != 'hologres'
    
    -- For Hologres V1.3 and earlier
    SELECT query,state,pid
    FROM pg_stat_activity 
    WHERE state = 'active' 
    AND     backend_type = 'client backend'
    AND     application_name != 'hologres'

    Exemplo de resultado:

    -------------------------------------------------------------------------------
    query          | insert into test_hg_stat_activity select i, (i % 7) :: text, (i % 1007) from generate_series(1, 10000000)i;
    state          | active
    query_id       | 100713xxxx
    transaction_id | 100713xxxx
    running_info   | {"current_stage" : {"stage_duration_ms" :5994,
                                          "stage_name" :"EXECUTE" },
                       "engine_type" :"{HQE,PQE}",
                       "fe_id" :1,
                       "warehouse_id" :0 }
    extend_info    | {"affected_rows" :9510912,
                      "scanned_rows" :9527296 }
  2. Ordene consultas em execução pelo consumo de CPU.

    -- For Hologres V2.0 and later
    SELECT query,((extend_info::json)->'total_cpu_max_time_ms')::text::bigint AS cpu_cost,state,query_id,transaction_id 
    FROM hg_stat_activity WHERE state = 'active' ORDER BY 2 DESC;

    Exemplo de resultado:

    ---------------------------------------------------------------------------------
    query          | select xxxxx
    cpu_cost       | 523461
    state          | active
    query_id       | 10053xxxx
    transaction_id | 10053xxxx
    ---------------------------------------------------------------------------------
    query          | insert xxxx
    cpu_cost       | 4817
    state          | active
    query_id       | 1008305xxx
    transaction_id | 1008305xxx
  3. Ordene consultas em execução pelo consumo de memória.

    -- For Hologres V2.0 and later
    SELECT query,((extend_info::json)->'total_mem_max_bytes')::text::bigint AS mem_max_cost,state,query_id,transaction_id 
    FROM hg_stat_activity WHERE state = 'active' ORDER BY 2 DESC;

    Exemplo de resultado:

    ---------------------------------------------------------------------------------
    query          | update xxxx;
    mem_max_cost   | 5727634542
    state          | active
    query_id       | 10053302784827629
    transaction_id | 10053302784827629
    ---------------------------------------------------------------------------------
    query          | select xxxx;
    mem_max_cost   | 19535640
    state          | active
    query_id       | 10083259096119559
    transaction_id | 10083259096119559
  4. Visualize consultas de longa duração na instância atual.

    -- For Hologres V2.0 and later
    SELECT current_timestamp - query_start AS runtime, datname::text, usename, query, query_id
        FROM hg_stat_activity
        WHERE state != 'idle'
        AND backend_type = 'client backend'
        AND application_name != 'hologres'
        ORDER BY 1 DESC;
    
    -- For Hologres V1.3 and earlier
    SELECT current_timestamp - query_start AS runtime, datname::text, usename, query, pid
        FROM pg_stat_activity
        WHERE state != 'idle'
        AND backend_type = 'client backend'
        AND application_name != 'hologres'
        ORDER BY 1 DESC;

    Exemplo de resultado:

    runtime          |  datname  | usename  | query_id    |      current_query
    -----------------+----------------+----------+------------------------------------
     00:00:24.258388 | holotest  | 123xxx   | 1267xx | UPDATE xxx;
     00:00:1.186394  | testdb    | 156xx    | 1783xx | select xxxx;

    A instrução UPDATE está em execução há 24 segundos sem ser concluída.

Gerenciar consultas ativas no HoloWeb

Visualize e gerencie consultas ativas no console do HoloWeb.

  1. Faça login no console do HoloWeb. Consulte Conectar ao HoloWeb e executar consultas.

  2. Na barra de navegação superior, clique em Diagnostics and Optimization.

  3. No painel de navegação à esquerda, escolha Management for Information About Active Queries > Active Query Tasks.

  4. Na página Active Query Tasks, clique em Search para visualizar e gerenciar consultas ativas da instância atual.

    Os resultados incluem os seguintes campos:

    Parâmetro

    Descrição

    Query start

    Momento em que a consulta foi iniciada.

    Runtime

    Duração da execução.

    PID

    ID do processo do backend que trata a consulta.

    Query

    Instrução SQL em execução.

    State

    Estado da conexão. Valores comuns:

    • active: a consulta está em execução.

    • idle: a conexão está ociosa.

    • idle in transaction: ocioso dentro de uma transação.

    • idle in transaction (Aborted): ocioso dentro de uma transação com falha.

    • \N: estado nulo, geralmente um processo em segundo plano do sistema. Pode ser ignorado.

    User name

    Nome de usuário da conexão atual.

    Application

    Aplicação que iniciou a consulta.

    Client address

    Endereço IP do cliente.

    Para encerrar uma consulta de longa duração, clique em Cancel na coluna Actions correspondente. Você também pode selecionar várias consultas e clicar em Batch Cancel.

  5. (Opcional) Clique em Details na coluna Actions para visualizar detalhes da consulta.

    Na página Details, você pode:

    • Copy: copie a instrução SQL.

    • Format: formate a instrução SQL.

Solucionar problemas de bloqueios

Verifique as consultas ativas para determinar se uma instrução SQL mantém um lock ou está bloqueada por ele. Consulte Locks e solução de problemas de bloqueio.

Encerrar uma consulta

Encerre consultas com baixo desempenho usando os seguintes comandos.

  • Encerre uma única consulta:

    SELECT pg_cancel_backend(<pid>);
  • Encerre múltiplas consultas em lote:

    SELECT pg_cancel_backend(pid)
            ,query
            ,datname
            ,usename
            ,application_name
            ,client_addr
            ,client_port
            ,backend_start
            ,state
    FROM    pg_stat_activity
    WHERE   length(query) > 0
    AND     pid != pg_backend_pid()
    AND     backend_type = 'client backend'
    AND     application_name != 'hologres'

Modificar o tempo limite de consulta ativa

Modifique o tempo limite de execução para consultas ativas.

  • Sintaxe

    SET statement_timeout = <time>;
  • Descrição do parâmetro

    time: valor do tempo limite. Intervalo: 0 a 2147483647. Unidade padrão: milissegundos. Para usar uma unidade diferente, coloque o valor e a unidade entre aspas simples. Padrão: 10 horas. Esta configuração é específica da sessão.

    Nota

    Para aplicar o tempo limite, execute a instrução SET statement_timeout = <time> no mesmo lote da instrução SQL alvo.

  • Exemplos de uso

    • Defina o tempo limite para 5.000 minutos. Como uma unidade é especificada, coloque o valor entre aspas simples.

      SET statement_timeout = '5000min' ; 
      SELECT * FROM tablename;
    • Defina o tempo limite para 5.000 ms.

      SET statement_timeout = 5000 ; 
      SELECT * FROM tablename;

Modificar o tempo limite de consulta ociosa

O parâmetro idle_in_transaction_session_timeout controla quando transações ociosas são encerradas. Sem essa configuração, transações ociosas nunca expiram, o que pode causar deadlocks.

  • Casos de uso

    Configure este tempo limite para evitar deadlocks causados por vazamento de transações. Por exemplo, a transação abaixo nunca é confirmada porque falta a instrução COMMIT, causando um vazamento de transação que pode levar a um deadlock no nível do banco de dados.

    BEGIN; 
    SELECT * FROM t;

    Para resolver isso, defina idle_in_transaction_session_timeout. Se uma transação aberta não for confirmada ou revertida dentro do tempo especificado por idle_in_transaction_session_timeout, o sistema reverte automaticamente a transação e fecha a conexão.

  • Sintaxe

    -- Modify the idle transaction timeout at the session level.
    SET idle_in_transaction_session_timeout=<time>;
    
    -- Modify the idle transaction timeout at the database level.
    ALTER database db_name SET idle_in_transaction_session_timeout=<time>;
  • Descrição do parâmetro

    time: valor do tempo limite. Intervalo: 0 a 2147483647. Unidade padrão: milissegundos. Para usar uma unidade diferente, coloque o valor e a unidade entre aspas simples. Padrão: 0 (sem encerramento automático) no Hologres V0.10 e anteriores; 10 minutos no Hologres V1.1 e posteriores. Transações ociosas por mais de 10 minutos são revertidas.

    Nota

    Não defina um tempo limite excessivamente curto. O sistema pode reverter transações que ainda estão em uso.

  • Exemplos de uso

    Defina o tempo limite para 300.000 ms.

    -- Modify the idle transaction timeout at the session level.
    SET idle_in_transaction_session_timeout=300000;
    
    -- Modify the idle transaction timeout at the database level.
    ALTER database db_name SET idle_in_transaction_session_timeout=300000;

Consultar logs de consultas lentas

O Hologres V0.10 e versões posteriores oferecem suporte a logs de consultas lentas. Consulte Visualizar e analisar logs de consultas lentas.

Perguntas frequentes

  • Sintoma

    A execução de uma instrução SQL retorna o seguinte erro: ERROR: canceling statement due to statement timeout.

  • Causas e soluções

    • Causa 1: um tempo limite está configurado no cliente ou na instância do Hologres. Configurações comuns de tempo limite:

      • APIs do Data Service possuem um tempo limite fixo de 10s que não pode ser modificado. Otimize suas instruções SQL para reduzir o tempo de execução.

      • O módulo SQL do Hologres no HoloWeb ou DataWorks possui um tempo limite de consulta fixo de 1h. Otimize seu SQL para reduzir o tempo de execução.

      • Um tempo limite está definido no nível da instância. Execute o seguinte SQL para verificá-lo. Se o tempo limite da instância causar o erro, ajuste-o conforme necessário.

        SHOW statement_timeout;
      • Um tempo limite está definido no cliente ou na aplicação. Verifique e ajuste as configurações de tempo limite do cliente conforme necessário.

    • Causa 2: uma operação DROP ou TRUNCATE foi executada na tabela enquanto uma instrução DML estava em execução.

      A operação TRUNCATE equivale a drop+create. Uma instrução DML em execução mantém um lock de linha ou de tabela (consulte Locks e solução de problemas de bloqueio). Uma operação DROP ou TRUNCATE simultânea na mesma tabela compete por esse lock, fazendo com que o sistema cancele a instrução DML com o erro statement timeout.

      Solução: verifique no log de consultas lentas se há operações DROP ou TRUNCATE simultâneas na tabela e evite-as.

      -- Example: Query the logs for drop/truncate operations on a specific table over the past day.
      SELECT * FROM hologres.hg_query_log 
      WHERE command_tag IN ('DROP TABLE','TRUNCATE TABLE') 
      AND query LIKE '%xxx%' AND query_start >= now() - interval '1 day';