Visualização TABLE_STORAGE

A visualização INFORMATION_SCHEMA.TABLE_STORAGE fornece um snapshot atual do uso do armazenamento das tabelas e visualizações materializadas. Quando você consulta a visualização INFORMATION_SCHEMA.TABLE_STORAGE, os resultados da consulta contêm uma linha para cada tabela ou visualização materializada do projeto atual. Os dados na visualização INFORMATION_SCHEMA.TABLE_STORAGE não são mantidos em tempo real, e as atualizações normalmente têm um atraso de alguns segundos ou minutos. As alterações de armazenamento causadas apenas pela expiração da partição ou da tabela ou por modificações na janela de viagem no tempo do conjunto de dados podem levar até um dia para serem refletidas na visualização INFORMATION_SCHEMA.TABLE_STORAGE.

As visualizações de armazenamento de tabela oferecem uma maneira conveniente de observar o consumo de armazenamento atual, além de fornecer detalhes sobre o uso, pelo armazenamento, de bytes lógicos não compactados, bytes físicos compactados ou bytes de viagem no tempo. Essas informações podem ajudar você em tarefas como o planejamento para crescimento futuro e a compreensão dos padrões de atualização das tabelas.

Dados incluídos nas colunas *_BYTES

As colunas *_BYTES nas visualizações de armazenamento da tabela incluem informações sobre o uso de bytes de armazenamento. Essas informações são determinadas analisando o uso do armazenamento para visualizações materializadas e os seguintes tipos de tabelas:

  • tabelas permanentes criadas por meio de qualquer um dos métodos descritos em Criar e usar tabelas.
  • Tabelas temporárias criadas em sessões. Essas tabelas são colocadas em conjuntos de dados com nomes gerados, como "_c018003e063d09570001ef33ae401fad6ab92a6a".
  • Tabelas temporárias criadas em consultas de várias instruções ("scripts"). Essas tabelas são colocadas em conjuntos de dados com nomes gerados, como "_script72280c173c88442c3a7200183a50eeeaa4073719".

Os dados armazenados no cache de resultados da consulta não são faturados, portanto, não são incluídos nos valores de coluna *_BYTES.

Clones e snapshots mostram valores de coluna *_BYTES como se fossem tabelas completas, em vez de mostrar o delta do armazenamento usado pela tabela base. Portanto, eles são uma estimativa superestimada. Sua fatura considera esse delta corretamente no uso do armazenamento. Para mais informações sobre os bytes delta armazenados e faturados por clones e snapshots, consulte a visualização TABLE_STORAGE_USAGE_TIMELINE.

Prever faturamento de armazenamento

Para prever o faturamento mensal de armazenamento de um conjunto de dados, use as colunas logical ou physical *_BYTES nessa visualização, dependendo do modelo de faturamento de armazenamento usado pelo conjunto de dados. Observação: essa é apenas uma previsão aproximada, e os valores exatos de faturamento são calculados com base no uso da infraestrutura de faturamento de armazenamento do BigQuery e visíveis no Cloud Billing.

Para conjuntos de dados que usam um modelo de faturamento lógico, preveja os custos mensais de armazenamento desta maneira:

((ACTIVE_LOGICAL_BYTES valor / POW(1024, 3)) * preço de bytes lógicos ativos) + ((LONG_TERM_LOGICAL_BYTES valor / POW(1024, 3)) * preço de bytes lógicos de longo prazo)

O valor ACTIVE_LOGICAL_BYTES de uma tabela reflete os bytes ativos usados atualmente por ela.

Para conjuntos de dados que usam um modelo de faturamento físico, preveja os custos de armazenamento desta maneira:

((ACTIVE_PHYSICAL_BYTES + FAIL_SAFE_PHYSICAL_BYTES valor / POW(1024, 3)) * preço de bytes físicos ativos) + ((LONG_TERM_PHYSICAL_BYTES valor / POW(1024, 3)) *preço dos bytes físicos de longo prazo)

O valor ACTIVE_PHYSICAL_BYTES de uma tabela reflete os bytes ativos usados atualmente por essa tabela, além dos bytes utilizados para o deslocamento no tempo dela.

Para ver os bytes ativos apenas da tabela, subtraia o valor TIME_TRAVEL_PHYSICAL_BYTES do valor ACTIVE_PHYSICAL_BYTES.

Para mais informações, consulte preços de armazenamento.

Funções exigidas

Para receber as permissões necessárias para consultar a visualização INFORMATION_SCHEMA.TABLE_STORAGE, peça ao administrador para conceder a você o papel Visualizador de metadados do BigQuery (roles/bigquery.metadataViewer) do IAM no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para consultar a visualização INFORMATION_SCHEMA.TABLE_STORAGE. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para consultar a visualização INFORMATION_SCHEMA.TABLE_STORAGE:

  • bigquery.tables.get
  • bigquery.tables.list

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Esquema

A visualização INFORMATION_SCHEMA.TABLE_STORAGE tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
PROJECT_ID STRING O ID do projeto que contém o conjunto de dados.
PROJECT_NUMBER INT64 O número do projeto que contém o conjunto de dados.
TABLE_CATALOG STRING O ID do projeto que contém o conjunto de dados.
TABLE_SCHEMA STRING O nome do conjunto de dados que contém a tabela ou a visualização materializada, também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou visualização materializada, também conhecido como tableId.
CREATION_TIME TIMESTAMP A hora de criação da tabela.
TOTAL_ROWS INT64 O número total de linhas na tabela ou visualização materializada.
TOTAL_PARTITIONS INT64 O número de partições presentes na tabela ou na visualização materializada. Tabelas não particionadas retornam 0.
TOTAL_LOGICAL_BYTES INT64 Número total de bytes (não compactados) lógicos na tabela ou visualização materializada.
ACTIVE_LOGICAL_BYTES INT64 Número de bytes lógicos (não compactados) com menos de 90 dias.
LONG_TERM_LOGICAL_BYTES INT64 Número de bytes lógicos (não compactados) com mais de 90 dias.
CURRENT_PHYSICAL_BYTES INT64 Número total de bytes físicos para o armazenamento atual da tabela em todas as partições.
TOTAL_PHYSICAL_BYTES INT64 Número total de bytes físicos (compactados) usados para armazenamento, incluindo bytes ativos, de longo prazo e de viagem no tempo (dados excluídos ou alterados) Segurança contra falhas (dados excluídos ou alterados retidos após a viagem no tempo window) bytes não são incluídos.
ACTIVE_PHYSICAL_BYTES INT64 Número de bytes físicos (compactados) com menos de 90 dias, incluindo bytes de viagem no tempo (dados excluídos ou alterados).
LONG_TERM_PHYSICAL_BYTES INT64 Número de bytes físicos (compactados) com mais de 90 dias.
TIME_TRAVEL_PHYSICAL_BYTES INT64 Número de bytes (não compactados) físicos usados pelo armazenamento de viagem no tempo (dados excluídos ou alterados)
STORAGE_LAST_MODIFIED_TIME TIMESTAMP O horário mais recente em que os dados foram gravados na tabela.
DELETED BOOLEAN Indica se a tabela foi excluída.
TABLE_TYPE STRING O tipo de tabela. Por exemplo, EXTERNAL ou BASE TABLE.
FAIL_SAFE_PHYSICAL_BYTES INT64 Número de bytes físicos (compactados) usados pelo armazenamento seguro contra falhas (dados excluídos ou alterados).
LAST_METADATA_INDEX_REFRESH_TIME TIMESTAMP O horário da última atualização do índice de metadados da tabela.

Escopo e sintaxe

As consultas nessa visualização precisam incluir um qualificador de região. A tabela a seguir explica o escopo da região dessa visualização:

Nome da visualização Escopo do recurso Escopo da região
[`PROJECT_ID`.]`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE[_BY_PROJECT] Nível do projeto REGION
Substitua:

  • Opcional: PROJECT_ID: o ID do seu projeto do Google Cloud. Se não for especificado, o projeto padrão será usado.
+ REGION: qualquer nome da região do conjunto de dados. Por exemplo, region-us.

O exemplo a seguir mostra como retornar informações de armazenamento para tabelas em um projeto especificado:

SELECT * FROM `myProject`.`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

O exemplo a seguir mostra como retornar informações de armazenamento para tabelas em uma região especificada:

SELECT * FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT;

Exemplos

Exemplo 1:

O exemplo a seguir mostra o total de bytes lógicos faturados pelo projeto atual.

SELECT
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

O resultado será semelhante ao seguinte:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Exemplo 2:

O exemplo a seguir mostra como prever a diferença de preço por conjunto de dados entre modelos de faturamento lógico e físico nos próximos 30 dias. Neste exemplo, pressupomos que o uso futuro do armazenamento seja constante nos próximos 30 dias a partir do momento em que a consulta foi executada. A previsão é limitada a tabelas de base e exclui todos os outros tipos de tabelas dentro de um conjunto de dados.

Os preços usados nas variáveis de preço desta consulta são para a região us-central1. Se você quiser executar essa consulta para uma região diferente, atualize as variáveis de preço adequadamente. Consulte Preços de armazenamento para ver informações sobre preços.

  1. Abra a página do BigQuery no console do Google Cloud.

    Acesse a página do BigQuery

  2. Insira a seguinte consulta do GoogleSQL na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe do GoogleSQL. O GoogleSQL é a sintaxe padrão no Console do Google Cloud.

    DECLARE active_logical_gib_price FLOAT64 DEFAULT 0.02;
DECLARE long_term_logical_gib_price FLOAT64 DEFAULT 0.01;
DECLARE active_physical_gib_price FLOAT64 DEFAULT 0.04;
DECLARE long_term_physical_gib_price FLOAT64 DEFAULT 0.02;

WITH
 storage_sizes AS (
   SELECT
     table_schema AS dataset_name,
     -- Logical
     SUM(IF(deleted=false, active_logical_bytes, 0)) / power(1024, 3) AS active_logical_gib,
     SUM(IF(deleted=false, long_term_logical_bytes, 0)) / power(1024, 3) AS long_term_logical_gib,
     -- Physical
     SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
     SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
     SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
     -- Restorable previously deleted physical
     SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
     SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib,
   FROM
     `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT
   WHERE total_physical_bytes + fail_safe_physical_bytes > 0
     -- Base the forecast on base tables only for highest precision results
     AND table_type  = 'BASE TABLE'
     GROUP BY 1
 )
SELECT
  dataset_name,
  -- Logical
  ROUND(active_logical_gib, 2) AS active_logical_gib,
  ROUND(long_term_logical_gib, 2) AS long_term_logical_gib,
  -- Physical
  ROUND(active_physical_gib, 2) AS active_physical_gib,
  ROUND(long_term_physical_gib, 2) AS long_term_physical_gib,
  ROUND(time_travel_physical_gib, 2) AS time_travel_physical_gib,
  ROUND(fail_safe_physical_gib, 2) AS fail_safe_physical_gib,
  -- Compression ratio
  ROUND(SAFE_DIVIDE(active_logical_gib, active_no_tt_physical_gib), 2) AS active_compression_ratio,
  ROUND(SAFE_DIVIDE(long_term_logical_gib, long_term_physical_gib), 2) AS long_term_compression_ratio,
  -- Forecast costs logical
  ROUND(active_logical_gib * active_logical_gib_price, 2) AS forecast_active_logical_cost,
  ROUND(long_term_logical_gib * long_term_logical_gib_price, 2) AS forecast_long_term_logical_cost,
  -- Forecast costs physical
  ROUND((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price, 2) AS forecast_active_physical_cost,
  ROUND(long_term_physical_gib * long_term_physical_gib_price, 2) AS forecast_long_term_physical_cost,
  -- Forecast costs total
  ROUND(((active_logical_gib * active_logical_gib_price) + (long_term_logical_gib * long_term_logical_gib_price)) -
     (((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price) + (long_term_physical_gib * long_term_physical_gib_price)), 2) AS forecast_total_cost_difference
FROM
  storage_sizes
ORDER BY
  (forecast_active_logical_cost + forecast_active_physical_cost) DESC;

  3. Clique em Executar.

O resultado é semelhante a este:

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset_name | active_logical_gib | long_term_logical_gib | active_physical_gib | long_term_physical_gib | active_compression_ratio | long_term_compression_ratio | forecast_active_logical_cost | forecaset_long_term_logical_cost | forecast_active_physical_cost | forecast_long_term_physical_cost | forecast_total_cost_difference |
+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset1     |               10.0 |                  10.0 |                 1.0 |                    1.0 |                     10.0 |                        10.0 |                          0.2 |                              0.1 |                          0.04 |                             0.02 |                           0.24 |