Vista EMPREGOS

A visualização de propriedade INFORMATION_SCHEMA.JOBS contém metadados quase em tempo real sobre todas as tarefas do BigQuery no projeto atual.

Função necessária

Para receber a autorização de que precisa para consultar a visualização de propriedade INFORMATION_SCHEMA.JOBS, peça ao seu administrador para lhe conceder a função de visualizador de recursos do BigQuery (roles/bigquery.resourceViewer) do IAM no seu projeto. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Esta função predefinida contém a autorização bigquery.jobs.listAll , que é necessária para consultar a vista INFORMATION_SCHEMA.JOBS.

Também pode obter esta autorização com funções personalizadas ou outras funções predefinidas.

Para mais informações sobre as autorizações do BigQuery, consulte o artigo Controlo de acesso com a IAM.

Esquema

Os dados subjacentes são particionados pela coluna creation_time e agrupados por project_id e user_email. A coluna query_info contém informações adicionais sobre as tarefas de consulta.

A vista INFORMATION_SCHEMA.JOBS tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
bi_engine_statistics RECORD Se o projeto estiver configurado para usar o BI Engine, este campo contém BiEngineStatistics. Caso contrário, NULL.
cache_hit BOOLEAN Se os resultados da consulta deste trabalho foram provenientes de uma cache. Se tiver um trabalho de declaração de várias consultas, cache_hit o ID da consulta principal é NULL.
creation_time TIMESTAMP (Coluna de partição) Hora da criação desta tarefa. A partição baseia-se na data/hora UTC desta data/hora.
destination_table RECORD Tabela de destino para resultados, se existir.
end_time TIMESTAMP A hora de fim desta tarefa, em milissegundos desde a época. Este campo representa a hora em que a tarefa entra no estado DONE.
error_result RECORD Detalhes de quaisquer erros como objetos ErrorProto.
job_creation_reason.code STRING Especifica o motivo geral pelo qual foi criado um trabalho.
Os valores possíveis são:
  • REQUESTED: foi pedida a criação de uma tarefa.
  • LONG_RUNNING: o pedido de consulta foi executado para além de um tempo limite definido pelo sistema especificado pelo campo timeoutMs no QueryRequest. Como tal, foi considerada uma operação de execução prolongada para a qual foi criado um trabalho.
  • LARGE_RESULTS: os resultados da consulta não cabem na resposta inline.
  • OTHER: o sistema determinou que a consulta tem de ser executada como uma tarefa.
job_id STRING O ID da tarefa, se tiver sido criada uma tarefa. Caso contrário, o ID da consulta de uma consulta que usa o modo de criação de tarefas opcional. Por exemplo, bquxjob_1234.
job_stages RECORD Fases da consulta da tarefa.

Nota: os valores desta coluna estão vazios para consultas que leem a partir de tabelas com políticas de acesso ao nível da linha. Para mais informações, consulte as práticas recomendadas para a segurança ao nível da linha no BigQuery.

job_type STRING O tipo de trabalho. Pode ser QUERY, LOAD, EXTRACT, COPY ou NULL. Um valor NULL indica uma tarefa em segundo plano.
labels RECORD Matriz de etiquetas aplicadas à tarefa como pares de chave-valor.
parent_job_id STRING ID da tarefa principal, se existir.
priority STRING A prioridade desta tarefa. Os valores válidos incluem INTERACTIVE e BATCH.
project_id STRING (Coluna de agrupamento) O ID do projeto.
project_number INTEGER O número do projeto.
query STRING Texto da consulta SQL. Apenas a vista JOBS_BY_PROJECT tem a coluna de consulta.
referenced_tables RECORD Matriz de tabelas referenciadas pela tarefa. Preenchido apenas para tarefas de consulta que não são resultados da cache.
reservation_id STRING Nome da reserva principal atribuída a esta tarefa, no formato RESERVATION_ADMIN_PROJECT:RESERVATION_LOCATION.RESERVATION_NAME.
Nesta saída:
  • RESERVATION_ADMIN_PROJECT: o nome do projeto do Google Cloud que administra a reserva
  • RESERVATION_LOCATION: a localização da reserva
  • RESERVATION_NAME: o nome da reserva
edition STRING A edição associada à reserva atribuída a esta tarefa. Para mais informações sobre as edições, consulte o artigo Introdução às edições do BigQuery.
session_info RECORD Detalhes sobre a sessão em que esta tarefa foi executada, se aplicável.
start_time TIMESTAMP A hora de início desta tarefa, em milissegundos desde a época. Este campo representa a hora em que a tarefa passa do estado PENDING para RUNNING ou DONE.
state STRING Estado de execução da tarefa. Os estados válidos incluem PENDING, RUNNING e DONE.
statement_type STRING O tipo de declaração de consulta. Por exemplo, DELETE, INSERT, SCRIPT, SELECT ou UPDATE. Consulte QueryStatementType para ver a lista de valores válidos.
timeline RECORD Linha cronológica da consulta da tarefa. Contém instantâneos da execução de consultas.
total_bytes_billed INTEGER Se o projeto estiver configurado para usar preços a pedido, este campo contém o total de bytes faturados para a tarefa. Se o projeto estiver configurado para usar preços de taxa fixa, não lhe é faturado o número de bytes, e este campo é apenas informativo.

Nota: os valores desta coluna estão vazios para consultas que leem a partir de tabelas com políticas de acesso ao nível da linha. Para mais informações, consulte as práticas recomendadas para a segurança ao nível da linha no BigQuery.

total_bytes_processed INTEGER

Total de bytes processados pela tarefa.

Nota: os valores desta coluna estão vazios para consultas que leem a partir de tabelas com políticas de acesso ao nível da linha. Para mais informações, consulte as práticas recomendadas para a segurança ao nível da linha no BigQuery.

total_modified_partitions INTEGER O número total de partições que a tarefa modificou. Este campo é preenchido para trabalhos de LOAD e QUERY.
total_slot_ms INTEGER Slot milliseconds for the job over its entire duration in the RUNNING state, including retries.
transaction_id STRING ID da transação em que esta tarefa foi executada, se existir. (Pré-visualizar)
user_email STRING (Coluna de agrupamento) Endereço de email ou conta de serviço do utilizador que executou a tarefa.
query_info.resource_warning STRING A mensagem de aviso que é apresentada se a utilização de recursos durante o processamento de consultas estiver acima do limite interno do sistema.
Um trabalho de consulta bem-sucedido pode ter o campo resource_warning preenchido. Com o resource_warning, recebe pontos de dados adicionais para otimizar as suas consultas e configurar a monitorização das tendências de desempenho de um conjunto equivalente de consultas através do query_hashes.
query_info.query_hashes.normalized_literals STRING Contém o valor hash da consulta. normalized_literals é um hash hexadecimal STRING que ignora comentários, valores de parâmetros, funções definidas pelo utilizador e literais. O valor hash difere quando as vistas subjacentes mudam ou se a consulta faz referência implícita a colunas, como SELECT *, e o esquema da tabela muda.
Este campo é apresentado para consultas GoogleSQL bem-sucedidas que não são resultados da cache.
query_info.performance_insights RECORD Estatísticas de desempenho para a tarefa.
query_info.optimization_details STRUCT As otimizações baseadas no histórico para a tarefa.
transferred_bytes INTEGER Total de bytes transferidos para consultas entre nuvens, como tarefas de transferência entre nuvens do BigQuery Omni.
materialized_view_statistics RECORD Estatísticas das vistas materializadas consideradas numa tarefa de consulta. (Pré-visualizar)
metadata_cache_statistics RECORD Estatísticas de utilização do índice da coluna de metadados para tabelas referenciadas numa tarefa de consulta.
search_statistics RECORD Estatísticas de uma consulta de pesquisa.
query_dialect STRING Este campo vai estar disponível em maio de 2025. O dialeto de consulta usado para a tarefa. Os valores válidos incluem:
  • GOOGLE_SQL: o trabalho foi pedido para usar o GoogleSQL.
  • LEGACY_SQL: foi pedido que a tarefa usasse SQL antigo.
  • DEFAULT_LEGACY_SQL: não foi especificado nenhum dialeto de consulta no pedido de tarefa. O BigQuery usou o valor predefinido do SQL antigo.
  • DEFAULT_GOOGLE_SQL: não foi especificado nenhum dialeto de consulta no pedido de tarefa. O BigQuery usou o valor predefinido do GoogleSQL.

Este campo só é preenchido para tarefas de consulta. A seleção predefinida do dialeto de consulta pode ser controlada pelas definições de configuração.
continuous BOOLEAN Se o trabalho é uma consulta contínua.
continuous_query_info.output_watermark TIMESTAMP Representa o ponto até ao qual a consulta contínua processou dados com êxito.
vector_search_statistics RECORD Estatísticas para uma consulta de pesquisa vetorial.

Quando consulta INFORMATION_SCHEMA.JOBS para encontrar um custo de resumo dos trabalhos de consulta, exclua o tipo de declaração SCRIPT. Caso contrário, alguns valores podem ser contabilizados duas vezes. A linha SCRIPT inclui valores de resumo para todas as tarefas secundárias que foram executadas como parte desta tarefa.

Tarefas de consulta com várias declarações

Uma tarefa de consulta com várias declarações é uma tarefa de consulta que usa a linguagem procedimental. As tarefas de consulta com várias declarações definem frequentemente variáveis com DECLARE ou têm declarações de fluxo de controlo, como IF ou WHILE. Quando consulta INFORMATION_SCHEMA.JOBS, pode ter de reconhecer a diferença entre uma tarefa de consulta com várias declarações e outras tarefas. Uma tarefa de consulta com várias declarações tem as seguintes caraterísticas:

  • statement_type = SCRIPT
  • reservation_id = NULL

Empregos para crianças

Cada um dos trabalhos secundários de um trabalho de consulta com várias declarações tem um parent_job_id que aponta para o próprio trabalho de consulta com várias declarações. Isto inclui valores de resumo para todas as tarefas secundárias que foram executadas como parte desta tarefa.

Se consultar INFORMATION_SCHEMA.JOBS para encontrar um custo resumido das tarefas de consulta, deve excluir o tipo de declaração SCRIPT. Caso contrário, alguns valores, como total_slot_ms, podem ser contabilizados duas vezes.

Retenção de dados

Esta vista contém tarefas em execução e o histórico de tarefas dos últimos 180 dias.

Âmbito e sintaxe

As consultas nesta vista têm de incluir um qualificador de região. A tabela seguinte explica o âmbito da região para esta vista:

Nome da visualização de propriedade Âmbito do recurso Âmbito da região
[PROJECT_ID.]`region-REGION`.INFORMATION_SCHEMA.JOBS[_BY_PROJECT] Nível do projeto REGION
Substitua o seguinte:
  • Opcional: PROJECT_ID: o ID do seu projeto do Google Cloud Google Cloud. Se não for especificado, é usado o projeto predefinido.
  • REGION: qualquer nome da região do conjunto de dados. Por exemplo, `region-us`.

Exemplos

Para executar a consulta num projeto que não seja o seu projeto predefinido, adicione o ID do projeto no seguinte formato: 

`PROJECT_ID`.`region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 Substitua o seguinte:

  • PROJECT_ID: o ID do projeto.
  • REGION_NAME: a região do seu projeto.

Por exemplo, `myproject`.`region-us-central1`.INFORMATION_SCHEMA.JOBS.

Compare a utilização de tarefas a pedido com os dados de faturação

Para projetos que usam preços a pedido, pode usar a vista INFORMATION_SCHEMA.JOBS para rever os custos de computação durante um determinado período.

Para projetos que usam a preços baseados na capacidade (slots), pode usar o INFORMATION_SCHEMA.RESERVATIONS_TIMELINE para rever os encargos de computação durante um determinado período.

A consulta seguinte produz dados agregados diários estimados dos TiB faturados e os custos resultantes. A secção Limitações explica quando estas estimativas podem não corresponder à sua fatura.

Apenas para este exemplo, têm de ser definidas as seguintes variáveis adicionais. Podem ser editados aqui para facilitar a utilização.

  • START_DATE: a data mais antiga para agregar (inclusive).
  • END_DATE: a data mais recente para agregar (inclusive).
  • PRICE_PER_TIB: o preço a pedido por TiB usado para estimativas de faturas.
CREATE TEMP FUNCTION isBillable(error_result ANY TYPE)
AS (
  -- You aren't charged for queries that return an error.
  error_result IS NULL
  -- However, canceling a running query might incur charges.
  OR error_result.reason = 'stopped'
);

-- BigQuery hides the number of bytes billed on all queries against tables with
-- row-level security.
CREATE TEMP FUNCTION isMaybeUsingRowLevelSecurity(
  job_type STRING, tib_billed FLOAT64, error_result ANY TYPE)
AS (
  job_type = 'QUERY'
  AND tib_billed IS NULL
  AND isBillable(error_result)
);

WITH
  query_params AS (
    SELECT
      date 'START_DATE' AS start_date,  -- inclusive
      date 'END_DATE' AS end_date,  -- inclusive
  ),
  usage_with_multiplier AS (
    SELECT
      job_type,
      error_result,
      creation_time,
      -- Jobs are billed by end_time in PST8PDT timezone, regardless of where
      -- the job ran.
      EXTRACT(date FROM end_time AT TIME ZONE 'PST8PDT') billing_date,
      total_bytes_billed / 1024 / 1024 / 1024 / 1024 total_tib_billed,
      CASE statement_type
        WHEN 'SCRIPT' THEN 0
        WHEN 'CREATE_MODEL' THEN 50 * PRICE_PER_TIB
        ELSE PRICE_PER_TIB
        END AS multiplier,
    FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
    WHERE statement_type <> 'SCRIPT'
  )
SELECT
  billing_date,
  sum(total_tib_billed * multiplier) estimated_charge,
  sum(total_tib_billed) estimated_usage_in_tib,
  countif(isMaybeUsingRowLevelSecurity(job_type, total_tib_billed, error_result))
    AS jobs_using_row_level_security,
FROM usage_with_multiplier, query_params
WHERE
  1 = 1
  -- Filter by creation_time for partition pruning.
  AND date(creation_time) BETWEEN date_sub(start_date, INTERVAL 2 day) AND date_add(end_date, INTERVAL 1 day)
  AND billing_date BETWEEN start_date AND end_date
  AND isBillable(error_result)
GROUP BY billing_date
ORDER BY billing_date;

Limitações

Calcule a utilização média de espaços

O exemplo seguinte calcula a utilização média de slots para todas as consultas nos últimos 7 dias para um determinado projeto. Tenha em atenção que este cálculo é mais preciso para projetos que têm uma utilização consistente de horários ao longo da semana. Se o seu projeto não tiver uma utilização consistente de espaços, este número pode ser inferior ao esperado.

Para executar a consulta:

SELECT
  SUM(total_slot_ms) / (1000 * 60 * 60 * 24 * 7) AS avg_slots
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  -- Filter by the partition column first to limit the amount of data scanned.
  -- Eight days allows for jobs created before the 7 day end_time filter.
  creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
  AND job_type = 'QUERY'
  AND statement_type != 'SCRIPT'
  AND end_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY) AND CURRENT_TIMESTAMP();

O resultado é semelhante ao seguinte:

+------------+
| avg_slots  |
+------------+
| 3879.1534  |
+------------+

Pode verificar a utilização de uma reserva específica com WHERE reservation_id = "…". Isto pode ser útil para determinar a percentagem de utilização de uma reserva ao longo de um período. Para tarefas de scripts, a tarefa principal também comunica a utilização total de espaços das respetivas tarefas secundárias. Para evitar a contagem dupla, use WHERE statement_type != "SCRIPT" para excluir a tarefa principal.

Se, em alternativa, quiser verificar a utilização média de vagas para tarefas individuais, use total_slot_ms / TIMESTAMP_DIFF(end_time, start_time, MILLISECOND).

Contagem de consultas ativas recentes por prioridade da consulta

O exemplo seguinte apresenta o número de consultas, agrupadas por prioridade (interativa ou em lote), que foram iniciadas nas últimas 7 horas:

SELECT
  priority,
  COUNT(*) active_jobs
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 hour)
  AND job_type = 'QUERY'
GROUP BY priority;

O resultado é semelhante ao seguinte:

+-------------+-------------+
| priority    | active_jobs |
+-------------+-------------+
| INTERACTIVE |           2 |
| BATCH       |           3 |
+-------------+-------------+

O campo priority indica se uma consulta é INTERACTIVE ou BATCH.

Veja o histórico de tarefas de carregamento

O exemplo seguinte apresenta todos os utilizadores ou contas de serviço que enviaram uma tarefa de carregamento em lote para um determinado projeto. Uma vez que não é especificado nenhum limite de tempo, esta consulta analisa todo o histórico disponível.

SELECT
  user_email AS user,
  COUNT(*) num_jobs
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  job_type = 'LOAD'
GROUP BY
  user_email;

O resultado é semelhante ao seguinte: 

+--------------+
| user         |
+--------------+
| abc@xyz.com  |
| xyz@xyz.com  |
| bob@xyz.com  |
+--------------+

Obtenha o número de tarefas de carregamento para determinar a quota de tarefas diárias usada

O exemplo seguinte devolve o número de tarefas por dia, conjunto de dados e tabela para que possa determinar a quantidade da quota de tarefas diária usada.

SELECT
    DATE(creation_time) as day,
    destination_table.project_id as project_id,
    destination_table.dataset_id as dataset_id,
    destination_table.table_id as table_id,
    COUNT(job_id) AS load_job_count
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
    creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
    AND job_type = "LOAD"
GROUP BY
    day,
    project_id,
    dataset_id,
    table_id
ORDER BY
    day DESC;
 Nota: os nomes das vistas `INFORMATION_SCHEMA` são sensíveis a maiúsculas e minúsculas. O resultado é semelhante ao seguinte: 
+-------------+------------+-------------+----------+-----------------+
|day          | project_id | dataset_id  | table_id | load_job_count  |
+-------------+------------+-------------+----------+-----------------+
| 2020-10-10  | my_project | dataset1    | orders   | 58              |
| 2020-10-10  | my_project | dataset1    | product  | 20              |
| 2020-10-10  | my_project | dataset1    | sales    | 11              |
+-------------+------------+-------------+----------+-----------------+

Obtenha as últimas tarefas com falha

O exemplo seguinte mostra as últimas três tarefas com falhas:

SELECT
   job_id,
  creation_time,
  user_email,
   error_result
 FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
  error_result.reason != "Null"
ORDER BY
  creation_time DESC
LIMIT 3;

Os resultados devem ter um aspeto semelhante ao seguinte: 

+------------+--------------------------+------------------+-------------------------------------+
| job_id     | creation_time            | user_email       | error_result                        |
+------------+--------------------------+------------------+-------------------------------------+
| bquxjob_1  | 2020-10-10 00:00:00 UTC  | abc@example.com  | Column 'col1' has mismatched type...|
| bquxjob_2  | 2020-10-11 00:00:00 UTC  | xyz@example.com  | Column 'col1' has mismatched type...|
| bquxjob_3  | 2020-10-11 00:00:00 UTC  | bob@example.com  | Column 'col1' has mismatched type...|
+------------+--------------------------+------------------+-------------------------------------+

Consultar a lista de trabalhos de execução prolongada

O exemplo seguinte mostra a lista de tarefas de longa duração que se encontram no estado RUNNING ou PENDING há mais de 30 minutos:

SELECT
  job_id,
  job_type,
  state,
  creation_time,
  start_time,
  user_email
 FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
  state!="DONE" AND
  creation_time <= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 MINUTE)
ORDER BY
  creation_time ASC;

O resultado é semelhante ao seguinte:

+-----------+----------+---------+--------------------------------+--------------------------------+------------------+
| job_id    | job_type | state   | creation_time                  | start_time                     | user_email       |
+-----------+----------+---------+--------------------------------+--------------------------------+------------------+
| bquxjob_1 | QUERY    | RUNNING | 2023-05-03 05:07:22.818000 UTC | 2023-05-03 05:07:22.905000 UTC | abc@example.com  |
| bquxjob_2 | QUERY    | PENDING | 2023-05-01 02:05:47.925000 UTC | 2023-05-01 02:05:47.998000 UTC | xyz@example.com  |
| bquxjob_3 | QUERY    | PENDING | 2023-05-01 02:05:47.925000 UTC | 2023-05-01 02:05:47.998000 UTC | abc@example.com  |
+-----------+----------+---------+--------------------------------+--------------------------------+------------------+

Consultas que usam o modo de criação de tarefas opcional

O exemplo seguinte mostra uma lista de consultas que foram executadas no modo de criação de tarefas opcional para as quais o BigQuery não criou tarefas.

SELECT
 job_id,
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 TIMESTAMP_TRUNC(creation_time, DAY) = '2024-06-12'
 AND job_creation_reason.code IS NULL
LIMIT 3;

Os resultados devem ter o seguinte aspeto: 

+-----------+
| job_id    |                                          |
+-----------+
| bquxjob_1 |
| bquxjob_2 |
| bquxjob_3 |
+-----------+

O exemplo seguinte mostra informações sobre uma consulta que foi executada no modo de criação de tarefas opcional para o qual o BigQuery não criou uma tarefa.

SELECT
 job_id,
 statement_type,
 priority,
 cache_hit,
 job_creation_reason.code AS job_creation_reason_code,
 total_bytes_billed,
 total_bytes_processed,
 total_slot_ms,
 state,
 error_result.message AS error_result_message,
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 TIMESTAMP_TRUNC(creation_time, DAY) = '2024-06-12'
 AND job_id = '2Lm09bHxDEsoVK8zwzWJomLHU_Ud%1910479b151' -- queryId

Nota: o campo job_id contém o queryId da consulta quando não foi criada uma tarefa para esta consulta.

Os resultados devem ter o seguinte aspeto:

+-----------+----------------+-------------+-----------+--------------------------+--------------------+---------------------+---------------+-------+----------------------+
| job_id    | statement_type | priority    | cache_hit | job_creation_reason_code | total_bytes_billed | total_bytes_processed | total_slot_ms | state | error_result_message |
+-----------+----------------+-------------+-----------+--------------------------+--------------------+---------------------+---------------+-------+----------------------+
| bquxjob_1 | SELECT         | INTERACTIVE | false     | null                     | 161480704          | 161164718             | 3106          | DONE  | null                 |
+-----------+----------------+-------------+-----------+--------------------------+--------------------+---------------------+---------------+-------+----------------------+

O exemplo seguinte mostra uma lista de consultas que foram executadas no modo de criação de tarefas opcional para as quais o BigQuery criou tarefas.

SELECT
 job_id,
 job_creation_reason.code AS job_creation_reason_code
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 TIMESTAMP_TRUNC(creation_time, DAY) = '2024-06-12'
 AND job_creation_reason.code IS NOT NULL
 AND job_creation_reason.code != 'REQUESTED'
LIMIT 3

Os resultados devem ter o seguinte aspeto:

+-----------+--------------------------+
| job_id    | job_creation_reason_code |
+-----------+--------------------------+
| bquxjob_1 | LARGE_RESULTS            |
| bquxjob_2 | LARGE_RESULTS            |
| bquxjob_3 | LARGE_RESULTS            |
+-----------+--------------------------+

Bytes processados por identidade do utilizador

O exemplo seguinte mostra o total de bytes faturados para tarefas de consulta por utilizador:

SELECT
  user_email,
  SUM(total_bytes_billed) AS bytes_billed
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  job_type = 'QUERY'
  AND statement_type != 'SCRIPT'
GROUP BY
  user_email;

Nota: consulte a ressalva para a coluna total_bytes_billed na documentação do esquema para as vistas JOBS.

Os resultados devem ter o seguinte aspeto:

+---------------------+--------------+
| user_email          | bytes_billed |
+---------------------+--------------+
| bob@example.com     | 2847932416   |
| alice@example.com   | 1184890880   |
| charles@example.com | 10485760     |
+---------------------+--------------+

Análise detalhada por hora dos bytes processados

O exemplo seguinte mostra o total de bytes faturados para tarefas de consulta, em intervalos de horas:

SELECT
  TIMESTAMP_TRUNC(end_time, HOUR) AS time_window,
  SUM(total_bytes_billed) AS bytes_billed
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  job_type = 'QUERY'
  AND statement_type != 'SCRIPT'
GROUP BY
  time_window
ORDER BY
  time_window DESC;

O resultado é semelhante ao seguinte:

+-------------------------+--------------+
| time_window             | bytes_billed |
+-------------------------+--------------+
| 2022-05-17 20:00:00 UTC | 1967128576   |
| 2022-05-10 21:00:00 UTC | 0            |
| 2022-04-15 17:00:00 UTC | 41943040     |
+-------------------------+--------------+

Consultar tarefas por tabela

O exemplo seguinte mostra quantas vezes cada tabela consultada em my_project foi referenciada por uma tarefa de consulta:

SELECT
  t.project_id,
  t.dataset_id,
  t.table_id,
  COUNT(*) AS num_references
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS, UNNEST(referenced_tables) AS t
GROUP BY
  t.project_id,
  t.dataset_id,
  t.table_id
ORDER BY
  num_references DESC;

O resultado é semelhante ao seguinte:

+------------+------------+----------+----------------+
| project_id | dataset_id | table_id | num_references |
+------------+------------+----------+----------------+
| my_project | dataset1   | orders   | 58             |
| my_project | dataset1   | products | 40             |
| other_proj | dataset1   | accounts | 12             |
+------------+------------+----------+----------------+

Número de tarefas de consulta SQL antigo por projeto

O campo "query_dialect" no INFORMATION_SCHEMA vai estar disponível em maio de 2025. O exemplo seguinte mostra quantos trabalhos de consulta SQL antigos são executados por projetos.

SELECT
  project_id,
  -- Implicitly defaulted to LegacySQL since the query dialect was not specified
  -- in the request.
  COUNTIF(query_dialect = 'DEFAULT_LEGACY_SQL') AS default_legacysql_query_jobs,
  -- Explicitly requested LegacySQL.
  COUNTIF(query_dialect = 'LEGACY_SQL') AS legacysql_query_jobs,
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  query_dialect = 'DEFAULT_LEGACY_SQL'
  OR query_dialect = 'LEGACY_SQL'
GROUP BY
  project_id
ORDER BY
  default_legacysql_query_jobs DESC,
  legacysql_query_jobs DESC;

Número de partições modificadas por consultas e tarefas de carregamento por tabela

O exemplo seguinte mostra o número de partições modificadas por consultas com declarações DML e tarefas de carregamento, por tabela. Tenha em atenção que esta consulta não mostra o total_modified_partitions para tarefas de cópia.

SELECT
  destination_table.table_id,
  SUM(total_modified_partitions) AS total_modified_partitions
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  DATE(creation_time, "America/Los_Angeles") = CURRENT_DATE()
GROUP BY
  table_id
ORDER BY
  total_modified_partitions DESC

Número médio de espaços por milissegundo usados por uma tarefa

O exemplo seguinte mostra como calcular o número médio de espaços usados por uma tarefa durante a execução. Isto pode ser útil na resolução de problemas de consultas lentas e na comparação de uma execução lenta de uma consulta com uma execução mais rápida da mesma consulta. A comparação deste valor com o tamanho total da reserva e o número médio de tarefas executadas em simultâneo no projeto ou na reserva pode ajudar a compreender se várias consultas estavam a competir por vagas ao mesmo tempo durante a execução.

Um número médio de espaços mais elevado significa que são atribuídos mais recursos à tarefa, o que geralmente resulta numa execução mais rápida.

SELECT ROUND(SAFE_DIVIDE(total_slot_ms,TIMESTAMP_DIFF(end_time, start_time, MILLISECOND)), 1) as avg_slots_per_ms
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE job_id = 'JOB_ID'

Substitua JOB_ID pelo job_id que está a investigar.

INFORMATION_SCHEMA

O resultado será semelhante ao seguinte:

+------------------+
| avg_slots_per_ms |
+------------------+
|             17.0 |
+------------------+

Consultas mais caras por projeto

O exemplo seguinte apresenta as consultas mais caras em my_project por tempo de utilização de slots:

SELECT
 job_id,
 query,
 user_email,
 total_slot_ms
FROM `my_project`.`region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE EXTRACT(DATE FROM  creation_time) = current_date()
ORDER BY total_slot_ms DESC
LIMIT 3

Também pode listar as consultas mais caras por dados processados com o seguinte exemplo:

SELECT
 job_id,
 query,
 user_email,
 total_bytes_processed
FROM `my_project`.`region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE EXTRACT(DATE FROM  creation_time) = current_date()
ORDER BY total_bytes_processed DESC
LIMIT 3

O resultado de qualquer um dos exemplos é semelhante ao seguinte: 

+-----------+---------------------------------+-----------------------+---------------+
| job_id    | query                           | user_email            | total_slot_ms |
+-----------+---------------------------------+--------------------------+------------+
| bquxjob_1 | SELECT ... FROM dataset.table1  | bob@example.com       | 80,000        |
| bquxjob_2 | SELECT ... FROM dataset.table2  | alice@example.com     | 78,000        |
| bquxjob_3 | SELECT ... FROM dataset.table3  | charles@example.com   | 75,000        |
+-----------+---------------------------------+-----------------------+---------------+

Veja detalhes sobre um aviso de recurso

Se receber a mensagem de erro Recursos excedidos, pode consultar as consultas num período:

SELECT
  query,
  query_info.resource_warning
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 creation_time BETWEEN TIMESTAMP("2022-12-01")
 AND TIMESTAMP("2022-12-08")
 AND query_info.resource_warning IS NOT NULL
LIMIT 3;

Monitorize os avisos de recursos agrupados por data

Se receber a mensagem de erro Recursos excedidos, pode monitorizar o número total de avisos de recursos agrupados por data para saber se existem alterações à carga de trabalho:

WITH resource_warnings AS (
  SELECT
    EXTRACT(DATE FROM creation_time) AS creation_date
  FROM
    `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
  WHERE
    creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 14 DAY)
    AND query_info.resource_warning IS NOT NULL
)
SELECT
  creation_date,
  COUNT(1) AS warning_counts
FROM
  resource_warnings
GROUP BY creation_date
ORDER BY creation_date DESC;

Estime a utilização de ranhuras e o custo das consultas

O exemplo seguinte calcula o número médio de vagas e o número máximo de vagas para cada tarefa através de estimated_runnable_units.

O ícone reservation_id é NULL se não tiver reservas.

SELECT
  project_id,
  job_id,
  reservation_id,
  EXTRACT(DATE FROM creation_time) AS creation_date,
  TIMESTAMP_DIFF(end_time, start_time, SECOND) AS job_duration_seconds,
  job_type,
  user_email,
  total_bytes_billed,

  -- Average slot utilization per job is calculated by dividing total_slot_ms by the millisecond duration of the job

  SAFE_DIVIDE(job.total_slot_ms,(TIMESTAMP_DIFF(job.end_time, job.start_time, MILLISECOND))) AS job_avg_slots,
  query,

  -- Determine the max number of slots used at ANY stage in the query.
  -- The average slots might be 55. But a single stage might spike to 2000 slots.
  -- This is important to know when estimating number of slots to purchase.

  MAX(SAFE_DIVIDE(unnest_job_stages.slot_ms,unnest_job_stages.end_ms - unnest_job_stages.start_ms)) AS jobstage_max_slots,

  -- Check if there's a job that requests more units of works (slots). If so you need more slots.
  -- estimated_runnable_units = Units of work that can be scheduled immediately.
  -- Providing additional slots for these units of work accelerates the query,
  -- if no other query in the reservation needs additional slots.

  MAX(unnest_timeline.estimated_runnable_units) AS estimated_runnable_units
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS AS job
  CROSS JOIN UNNEST(job_stages) as unnest_job_stages
  CROSS JOIN UNNEST(timeline) AS unnest_timeline
WHERE
  DATE(creation_time) BETWEEN DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY) AND CURRENT_DATE()
  AND project_id = 'my_project'
  AND (statement_type != 'SCRIPT' OR statement_type IS NULL)
GROUP BY 1,2,3,4,5,6,7,8,9,10
ORDER BY job_id;

O resultado, por exemplo, é semelhante ao seguinte: 

+-----------+-----------+----------------+---------------+----------------------+----------+-----------------+--------------------+--------------+--------------------------------+--------------------+--------------------------+
|project_id | job_id    | reservation_id | creation_date | job_duration_seconds | job_type | user_email      | total_bytes_billed | job_avg_slots| query                          | jobstage_max_slots | estimated_runnable_units |
+-----------+-----------+----------------+---------------+----------------------+----------+-----------------+--------------------+--------------+--------------------------------+--------------------+--------------------------+
| project1  | bquxjob1  | reservation1   | 2020-10-10    | 160                  | LOAD     | abc@example.com | 161480704          | 2890         | SELECT ... FROM dataset.table1 | 2779.1534          | 1000                     |
| project1  | bquxjob2  | reservation2   | 2020-12-10    | 120                  | LOAD     | abc@example.com | 161480704          | 2890         | SELECT ... FROM dataset.table1 | 2779.1534          | 1000                     |
| project1  | bquxjob3  | reservation1   | 2020-12-10    | 120                  | LOAD     | abc@example.com | 161480704          | 2890         | SELECT ... FROM dataset.table1 | 1279.1534          | 998                     |
+-----------+-----------+----------------+---------------+----------------------+----------+-----------------+--------------------+--------------+--------------------------------+--------------------+--------------------------+

Veja estatísticas de desempenho para consultas

O exemplo seguinte devolve todas as tarefas de consulta que têm estatísticas de desempenho do seu projeto nos últimos 30 dias, juntamente com um URL que tem um link para o gráfico de execução da consulta na Google Cloud consola.

SELECT
  `bigquery-public-data`.persistent_udfs.job_url(
    project_id || ':us.' || job_id) AS job_url,
  query_info.performance_insights
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
  DATE(creation_time) >= CURRENT_DATE - 30 -- scan 30 days of query history
  AND job_type = 'QUERY'
  AND state = 'DONE'
  AND error_result IS NULL
  AND statement_type != 'SCRIPT'
  AND EXISTS ( -- Only include queries which had performance insights
    SELECT 1
    FROM UNNEST(
      query_info.performance_insights.stage_performance_standalone_insights
    )
    WHERE slot_contention OR insufficient_shuffle_quota
    UNION ALL
    SELECT 1
    FROM UNNEST(
      query_info.performance_insights.stage_performance_change_insights
    )
    WHERE input_data_change.records_read_diff_percentage IS NOT NULL
  );

Veja tarefas de atualização de metadados

O exemplo seguinte apresenta as tarefas de atualização de metadados nas últimas seis horas:

SELECT
 *
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
 job_id LIKE '%metadata_cache_refresh%'
 AND creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 6 HOUR)
ORDER BY start_time desc
LIMIT 10;

Substitua REGION_NAME pela sua região.

Analise o desempenho ao longo do tempo para consultas idênticas

O exemplo seguinte devolve os 10 trabalhos mais lentos nos últimos 7 dias que executaram a mesma consulta:

DECLARE querytext STRING DEFAULT(
  SELECT query
  FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
  WHERE job_id = 'JOB_ID'
  LIMIT 1
);

SELECT
  start_time,
  end_time,
  project_id,
  job_id,
  TIMESTAMP_DIFF(end_time, start_time, SECOND) AS run_secs,
  total_bytes_processed / POW(1024, 3) AS total_gigabytes_processed,
  query
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  query = querytext
  AND total_bytes_processed > 0
  AND creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
ORDER BY 5 DESC
LIMIT 3;

Substitua JOB_ID por qualquer job_id que tenha executado a consulta que está a analisar.

Os 5 trabalhos que analisaram mais bytes hoje

O exemplo seguinte demonstra como encontrar os cinco trabalhos que analisaram o maior número de bytes numa organização no dia atual. Pode filtrar ainda mais em statement_type para consultar informações adicionais, como carregamentos, exportações e consultas.

SELECT
  job_id,
  user_email,
  total_bytes_billed
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_ORGANIZATION
WHERE
  EXTRACT(DATE FROM  creation_time) = current_date()
ORDER BY
  total_bytes_billed DESC
LIMIT 3;

O resultado é semelhante ao seguinte:

+--------------+--------------+---------------------------+
| job_id       |  user_email  |  total_bytes_billed       |
+--------------+--------------+---------------------------+
| bquxjob_1    |  abc@xyz.com |    999999                 |
| bquxjob_2    |  def@xyz.com |    888888                 |
| bquxjob_3    |  ghi@xyz.com |    777777                 |
+--------------+--------------+---------------------------+

Veja tarefas pendentes ou em execução

SELECT
  job_id,
  creation_time,
  query
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_USER
WHERE
  state != 'DONE';

O resultado é semelhante ao seguinte:

+--------------+---------------------------+---------------------------------+
| job_id       |  creation_time            |  query                          |
+--------------+---------------------------+---------------------------------+
| bquxjob_1    |  2019-10-10 00:00:00 UTC  |  SELECT ... FROM dataset.table1 |
| bquxjob_2    |  2019-10-10 00:00:01 UTC  |  SELECT ... FROM dataset.table2 |
| bquxjob_3    |  2019-10-10 00:00:02 UTC  |  SELECT ... FROM dataset.table3 |
+--------------+---------------------------+---------------------------------+

Veja trabalhos com estatísticas de conflitos de slots

Para ver os trabalhos com as respetivas estatísticas de conflitos de posições, execute a seguinte consulta:

SELECT
  job_id,
  creation_time,
  query_info.performance_insights,
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS j,
  UNNEST(query_info.performance_insights.stage_performance_standalone_insights) i
WHERE
  (j.statement_type != "SCRIPT" OR j.statement_type IS NULL)
  AND i IS NOT NULL
  AND i.slot_contention

O resultado mostra diferentes estatísticas de desempenho sobre trabalhos, incluindo a contenção de slots:

+------------+-------------------------+-------------------------------------------------+----------------------------------------------------------------------------+
| job_id     | creation_time           | performance_insights.avg_previous_execution_ms  | performance_insightsstage_performance_standalone_insights.slot_contention  |
+------------+-------------------------+-------------------------------------------------+----------------------------------------------------------------------------+
| bquxjob_1  | 2025-08-08 00:00:00 UTC | null                                            | true                                                                       |
| bquxjob_2  | 2025-08-08 00:00:00 UTC | 42689                                           | true                                                                       |
| bquxjob_3  | 2025-08-08 00:00:00 UTC | 42896                                           | true                                                                       |
+------------+-------------------------+-------------------------------------------------+----------------------------------------------------------------------------+

Veja a média de tarefas em simultâneo em execução juntamente com uma tarefa específica no mesmo projeto

O exemplo seguinte demonstra como calcular o número médio de tarefas em execução ao mesmo tempo que uma tarefa de consulta específica no mesmo projeto.

Este cálculo ajuda a determinar se um número aumentado de tarefas simultâneas no mesmo projeto causou problemas de concorrência de slots. Recolha estes dados quando resolver problemas de consultas lentas ou comparar execuções de consultas lentas e rápidas.

Se estiverem a ser executadas muito mais consultas em simultâneo do que o esperado, verifique se foram iniciadas mais tarefas, se os dados consultados foram alterados ou ambos.

WITH job_metadata AS (
 SELECT creation_time, end_time, job_type
 FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
 WHERE job_id = 'JOB_ID'
-- If you know the date the job was created, add the following line to speed up the query by providing the date in UTC:
-- AND DATE(creation_time) = 'YYYY-MM-DD'
),
intervals AS (
 SELECT TIMESTAMP_ADD(creation_time, INTERVAL (seconds_offset) SECOND) AS ts,
 job_type
 FROM job_metadata,
 UNNEST (GENERATE_ARRAY(0, IF(TIMESTAMP_DIFF(end_time, creation_time, SECOND) > 0, TIMESTAMP_DIFF(end_time, creation_time, SECOND), 1))) as seconds_offset
),
concurrent_jobs AS (
 SELECT int.ts, COUNT(*) as concurrent_jobs_count
 FROM intervals int JOIN
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT j
 ON int.ts BETWEEN j.creation_time and j.end_time
 WHERE job_id != 'JOB_ID'
 AND j.job_type = int.job_type
 GROUP BY int.ts)

SELECT ROUND(AVG(concurrent_jobs_count),1) as average_concurrent_jobs FROM concurrent_jobs

Substitua o seguinte:

  • JOB_ID: o ID da tarefa da consulta que está a analisar

  • REGION_NAME: a região do seu projeto

O resultado é semelhante ao seguinte: 

+-------------------------+
| average_concurrent_jobs |
+-------------------------+
|                     2.8 |
+-------------------------+

Obtenha bytes processados por tarefas de exportação

O exemplo seguinte calcula o valor de total_bytes_processed para os tipos de tarefas EXTRACT. Para obter informações sobre as quotas para tarefas de exportação, consulte o artigo Política de quotas para tarefas de exportação. O total de bytes processados pode ser usado para monitorizar a utilização agregada e verificar se as tarefas de exportação permanecem abaixo do limite de 50 TB por dia:

SELECT
    DATE(creation_time) as day,
    project_id as source_project_id,
    SUM(total_bytes_processed) AS total_bytes_processed
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
    creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
    AND job_type = "EXTRACT"
GROUP BY
    day,
    source_project_id
ORDER BY
    day DESC;

Obtenha a utilização de tarefas de cópia

Para mais informações sobre tarefas de cópia, consulte o artigo Copiar uma tabela. O exemplo seguinte mostra a utilização de tarefas de cópia:

SELECT
    DATE(creation_time) as day,
    project_id as source_project_id,
CONCAT(destination_table.project_id,":",destination_table.dataset_id,".",destination_table.table_id) as destination_table,
    COUNT(job_id) AS copy_job_count
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
    creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
    AND job_type = "COPY"
GROUP BY
    day,
    source_project_id,
    destination_table
ORDER BY
    day DESC;

Obtenha a utilização de tabelas BigLake para o Apache Iceberg na otimização do armazenamento do BigQuery

O exemplo seguinte mostra a utilização da tabela Iceberg do BigLake na otimização do armazenamento do BigQuery.

SELECT
    job_id, reservation_id, edition,
    total_slot_ms, total_bytes_processed, state
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 6 HOUR)
    AND user_email = "bigquery-adminbot@system.gserviceaccount.com"
    AND query LIKE "CALL BQ.OPTIMIZE_STORAGE(%)";

Obtenha a utilização da tabela Iceberg do BigLake nos metadados da tabela BigQuery Export

O exemplo seguinte mostra a utilização do Iceberg EXPORT TABLE METADATA FROM.

SELECT
   job_id,
   user_email,
   start_time,
   end_time,
   TIMESTAMP_DIFF(end_time, start_time, SECOND) AS duration_seconds,
   total_bytes_processed,
   reservation_id,
   CASE
     WHEN reservation_id IS NULL THEN 'PAYG (On-demand)'
     WHEN reservation_id != '' THEN 'Reservation'
     ELSE 'Unknown'
   END AS compute_type,
   query
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
   job_type = 'QUERY'
   AND end_time IS NOT NULL
   -- Filter for queries containing the specified pattern (case-insensitive)
   AND REGEXP_CONTAINS(LOWER(query), r"export table metadata from")
 ORDER BY
   start_time DESC
 LIMIT 3;

Faça corresponder o comportamento de utilização de slots a partir dos gráficos de recursos administrativos

Para explorar o comportamento de utilização de slots semelhante às informações nos gráficos de recursos administrativos, consulte a vista INFORMATION_SCHEMA.JOBS_TIMELINE.