Vista TABLE_STORAGE

En la vista INFORMATION_SCHEMA.TABLE_STORAGE, se proporciona una instantánea actual del uso del almacenamiento para tablas y vistas materializadas. Cuando consultas la vista INFORMATION_SCHEMA.TABLE_STORAGE, los resultados contienen una fila por cada tabla o vista materializada del proyecto actual. Los datos en la vista INFORMATION_SCHEMA.TABLE_STORAGE no se mantienen en tiempo real y las actualizaciones suelen tardar unos segundos o unos minutos. Los cambios de almacenamiento causados por solo el vencimiento de la partición o la tabla o de las modificaciones en el período de viaje en el tiempo del conjunto de datos, pueden tardar hasta un día en reflejarse en la vista INFORMATION_SCHEMA.TABLE_STORAGE.

Las vistas de almacenamiento de tablas te brindan una manera conveniente de observar el consumo actual del almacenamiento, y también proporcionan detalles sobre si tu almacenamiento usa bytes lógicos sin comprimir, bytes comprimidos físicos o bytes de viaje en el tiempo. Esta información puede ayudarte con tareas como la planificación para el crecimiento futuro y comprender los patrones de actualización de las tablas.

Datos incluidos en las columnas *_BYTES

Las columnas *_BYTES en las vistas de almacenamiento de la tabla incluyen información sobre tu uso de bytes de almacenamiento. Esta información se determina mediante el análisis del uso de almacenamiento para las vistas materializadas y los siguientes tipos de tablas:

  • Tablas permanentes creadas a través de cualquiera de los métodos descritos en Crea y usa tablas.
  • Tablas temporales creadas en sesiones. Estas tablas se colocan en conjuntos de datos con nombres generados, como “_c018003e063d09570001ef33ae401fad6ab92a6a”.
  • Tablas temporales creadas en consultas de varias declaraciones (“secuencias de comandos”). Estas tablas se colocan en conjuntos de datos con nombres generados, como “_script72280c173c88442c3a7200183a50eeeaa4073719”.

Los datos almacenados en la caché de resultados de la consulta no se facturan a ti, por lo que no se incluyen en los valores de la columna *_BYTES.

Las clonaciones y las instantáneas muestran los valores de la columna *_BYTES como si fueran tablas completas, en lugar de mostrar el delta del almacenamiento que usa la tabla base, por lo que son una estimación excesiva. Tu factura no tiene en cuenta este delta en el uso de almacenamiento de forma correcta. Para obtener más información sobre los bytes delta almacenados y facturados por clonaciones e instantáneas, consulta la vista TABLE_STORAGE_USAGE_TIMELINE.

Facturación de almacenamiento de previsión

Para prever la facturación de almacenamiento mensual de un conjunto de datos, puedes usar las columnas logical o physical *_BYTES en esta vista, según el modelo de facturación de almacenamiento de conjunto de datos que usa el conjunto de datos. Ten en cuenta que esta es solo una previsión aproximada y que los importes de facturación precisos se calculan según el uso de la infraestructura de facturación de almacenamiento de BigQuery, que se puede ver en la Facturación de Cloud.

Para los conjuntos de datos que usan un modelo lógico de facturación, puedes prever los costos de almacenamiento mensuales de la siguiente manera:

((Valor ACTIVE_LOGICAL_BYTES/POW(1024, 3)) * precio de bytes lógicos activos + ((valor LONG_TERM_LOGICAL_BYTES/POW(1024, 3)) * precios de bytes lógicos a largo plazo).

El valor ACTIVE_LOGICAL_BYTES de una tabla refleja los bytes activos que usa esa tabla en este momento.

Para los conjuntos de datos que usan un modelo de facturación físico, puedes prever los costos de almacenamiento de la siguiente manera:

((valor ACTIVE_PHYSICAL_BYTES + FAIL_SAFE_PHYSICAL_BYTES/POW(1024, 3)) * precios de bytes físicos activos + ((valor LONG_TERM_PHYSICAL_BYTES/POW(1024, 3)) * precios de bytes físicos a largo plazo)

El valor ACTIVE_PHYSICAL_BYTES de una tabla refleja los bytes activos que usa esa tabla en este momento, además de los bytes que se usan en ese período.

Para ver solo los bytes activos de la tabla, resta el valor TIME_TRAVEL_PHYSICAL_BYTES del valor ACTIVE_PHYSICAL_BYTES.

Para obtener más información, consulta los precios de almacenamiento.

Roles obligatorios

Para obtener los permisos que necesitas para consultar la vista INFORMATION_SCHEMA.TABLE_STORAGE, pídele a tu administrador que te otorgue el rol de IAM de visualizador de metadatos de BigQuery (roles/bigquery.metadataViewer) en el proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso.

Este rol predefinido contiene los permisos necesarios para consultar la vista INFORMATION_SCHEMA.TABLE_STORAGE. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para consultar la vista INFORMATION_SCHEMA.TABLE_STORAGE:

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

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Esquema

La vista INFORMATION_SCHEMA.TABLE_STORAGE tiene el siguiente esquema:

Nombre de la columna Tipo de datos Valor
PROJECT_ID STRING El ID del proyecto que contiene el conjunto de datos.
PROJECT_NUMBER INT64 El número del proyecto que contiene el conjunto de datos
TABLE_CATALOG STRING El ID del proyecto que contiene el conjunto de datos.
TABLE_SCHEMA STRING El nombre del conjunto de datos que contiene la tabla o la vista materializada (también denominado datasetId).
TABLE_NAME STRING El nombre de la tabla o la vista materializada (también denominado tableId).
CREATION_TIME TIMESTAMP La hora de creación de la tabla.
TOTAL_ROWS INT64 La cantidad total de filas en la tabla o la vista materializada
TOTAL_PARTITIONS INT64 La cantidad de particiones presentes en la tabla o la vista materializada. Las tablas no particionadas muestran 0.
TOTAL_LOGICAL_BYTES INT64 Cantidad total de bytes lógicos (sin comprimir) en la tabla o la vista materializada.
ACTIVE_LOGICAL_BYTES INT64 Cantidad de bytes lógicos (sin comprimir) que tienen menos de 90 días.
LONG_TERM_LOGICAL_BYTES INT64 Cantidad de bytes lógicos (sin comprimir) que tienen más de 90 días.
CURRENT_PHYSICAL_BYTES INT64 Cantidad total de bytes físicos para el almacenamiento actual de la tabla en todas las particiones.
TOTAL_PHYSICAL_BYTES INT64 Cantidad total de bytes físicos (comprimidos) que se usan para el almacenamiento, incluidos los bytes activos, a largo plazo y de viaje en el tiempo (datos borrados o modificados). No se incluyen los bytes a prueba de fallas (datos borrados o modificados retenidos después del período de viaje en el tiempo).
ACTIVE_PHYSICAL_BYTES INT64 Cantidad de bytes físicos (comprimidos) con menos de 90 días, incluidos los bytes de viaje en el tiempo (datos borrados o modificados).
LONG_TERM_PHYSICAL_BYTES INT64 Cantidad de bytes físicos (comprimidos) con más de 90 días.
TIME_TRAVEL_PHYSICAL_BYTES INT64 Cantidad de bytes físicos (comprimidos) que usa el almacenamiento de viaje en el tiempo (datos borrados o modificados).
STORAGE_LAST_MODIFIED_TIME TIMESTAMP La hora más reciente en que los datos se escribieron en la tabla.
DELETED BOOLEAN Indica si la tabla se borró o no.
TABLE_TYPE STRING El tipo de tabla. Por ejemplo, EXTERNAL o BASE TABLE.
FAIL_SAFE_PHYSICAL_BYTES INT64 Cantidad de bytes físicos (comprimidos) que usa el almacenamiento seguro ante fallas (datos borrados o modificados)

Permiso y sintaxis

Las consultas realizadas a esta vista deben incluir un calificador de región. En la siguiente tabla, se explica el permiso de la región para esta vista:

Nombre de la vista Permiso del recurso Permiso de la región
[`PROJECT_ID`.]`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE[_BY_PROJECT] Nivel de proyecto REGION
Reemplaza lo siguiente:

  • Opcional: PROJECT_ID: el ID del proyecto de Google Cloud. Si no se especifica, se usa el proyecto predeterminado.
+ REGION: Cualquier nombre de región del conjunto de datos. Por ejemplo, region-us.

En el siguiente ejemplo, se demuestra cómo mostrar información de almacenamiento de las tablas en un proyecto específico:

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

En el siguiente ejemplo, se demuestra cómo mostrar información de almacenamiento de las tablas en una región específica:

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

Ejemplos

Ejemplo 1:

En el siguiente ejemplo, se muestra el total de bytes lógicos facturados para el proyecto actual.

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

El resultado es similar al siguiente:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Ejemplo 2:

En el siguiente ejemplo, se muestra cómo pronosticar la diferencia de precios por conjunto de datos entre modelos de facturación lógicos y físicos para los próximos 30 días. En este ejemplo, se supone que el uso de almacenamiento futuro es constante durante los próximos 30 días desde el momento en que se ejecutó la consulta. Ten en cuenta que la previsión se limita a las tablas base, y excluye todos los demás tipos de tablas dentro de un conjunto de datos.

Los precios que se usan en las variables de precios de esta consulta son para la región us-central1. Si quieres ejecutar esta consulta para una región diferente, actualiza las variables de precios de manera adecuada. Consulta Precios de almacenamiento para obtener información sobre los precios.

  1. Abre la página BigQuery en la consola de Google Cloud.

    Ir a la página de BigQuery

  2. Ingresa la siguiente consulta de GoogleSQL en el cuadro Editor de consultas. INFORMATION_SCHEMA requiere sintaxis de GoogleSQL. GoogleSQL es la sintaxis predeterminada en la consola de 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. Haz clic en Ejecutar.

El resultado es similar al siguiente:

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| 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 |