TABLE_STORAGE visualizzazione

La vista INFORMATION_SCHEMA.TABLE_STORAGE fornisce uno snapshot attuale dell'utilizzo dello spazio di archiviazione per le tabelle e le viste materializzate. Quando esegui una query sulla vista INFORMATION_SCHEMA.TABLE_STORAGE, i risultati della query contengono una riga per ogni tabella o vista materializzata del progetto corrente. I dati nella vista INFORMATION_SCHEMA.TABLE_STORAGE non vengono conservati in tempo reale e, in genere, gli aggiornamenti sono ritardati da qualche secondo a qualche minuto. Potrebbero essere necessari fino a un giorno prima che le modifiche allo spazio di archiviazione siano causate dalla sola scadenza della partizione o della tabella, o da modifiche alla finestra di spostamento cronologico del set di dati, prima che siano visibili nella vista INFORMATION_SCHEMA.TABLE_STORAGE.

Le viste dell'archiviazione della tabella offrono un modo pratico per osservare l'attuale consumo di archiviazione e, inoltre, forniscono dettagli sull'utilizzo da parte dello spazio di archiviazione di byte logici non compressi, byte fisici compressi o byte di viaggio nel tempo. Queste informazioni possono aiutarti con attività come la pianificazione della crescita futura e la comprensione dei pattern di aggiornamento per le tabelle.

Dati inclusi in *_BYTES colonne

Le colonne *_BYTES nelle visualizzazioni di archiviazione della tabella includono informazioni sull'utilizzo dei byte di archiviazione. Queste informazioni vengono determinate esaminando l'utilizzo dello spazio di archiviazione per le viste materializzate e i seguenti tipi di tabelle:

• Tabelle permanenti create tramite uno dei metodi descritti in Creare e utilizzare le tabelle.
• Tabelle temporanee create in sessioni. Queste tabelle vengono inserite in set di dati con nomi generati come "_c018003e063d09570001ef33ae401fad6ab92a6a".
• Tabelle temporanee create in query a più istruzioni ("script"). Queste tabelle vengono inserite in set di dati con nomi generati come "_script72280c173c88442c3a7200183a50eeeaa4073719".

I dati archiviati nella cache dei risultati delle query non ti vengono fatturati, quindi non sono inclusi nei valori della colonna *_BYTES.

Cloni e snapshot mostrano i valori delle colonne *_BYTES come se fossero tabelle complete, anziché mostrare il delta rispetto allo spazio di archiviazione utilizzato dalla tabella di base, perciò si tratta di una sovrastima. La tua fattura tiene conto correttamente di questo delta nell'utilizzo dello spazio di archiviazione. Per ulteriori informazioni sui byte delta archiviati e fatturati per cloni e snapshot, consulta la vista TABLE_STORAGE_USAGE_TIMELINE.

Fatturazione per l'archiviazione delle previsioni

Per prevedere la fatturazione mensile dello spazio di archiviazione per un set di dati, puoi utilizzare le colonne logical o physical *_BYTES in questa vista, a seconda del modello di fatturazione dell'archiviazione del set di dati utilizzato dal set di dati. Tieni presente che questa è solo una previsione approssimativa e che gli importi di fatturazione precisi vengono calcolati in base all'utilizzo da parte dell'infrastruttura di fatturazione dello spazio di archiviazione di BigQuery e sono visibili in Fatturazione Cloud.

Per i set di dati che utilizzano un modello di fatturazione logico, puoi prevedere i costi di archiviazione mensili come segue:

((Valore ACTIVE_LOGICAL_BYTES / POW(1024, 3)) * Prezzi dei byte logici attivi) + ((LONG_TERM_LOGICAL_BYTESvalore / POW(1024, 3)) * Prezzi dei byte logici a lungo termine)

Il valore ACTIVE_LOGICAL_BYTES per una tabella riflette i byte attivi attualmente utilizzati dalla tabella.

Per i set di dati che utilizzano un modello di fatturazione fisico, puoi prevedere i costi di archiviazione come segue:

((ACTIVE_PHYSICAL_BYTES + FAIL_SAFE_PHYSICAL_BYTES valore / POW(1024, 3)) * prezzo byte fisici attivi) + ((LONG_TERM_PHYSICAL_BYTES valore / POW(1024, 3)) * prezzo byte fisici a lungo termine)

Il valore ACTIVE_PHYSICAL_BYTES per una tabella riflette i byte attivi attualmente utilizzati da quella tabella più i byte utilizzati per il viaggio nel tempo per quella tabella.

Per vedere i byte attivi della sola tabella, sottrai il valore TIME_TRAVEL_PHYSICAL_BYTES dal valore di ACTIVE_PHYSICAL_BYTES.

Per maggiori informazioni, vedi Prezzi dell'archiviazione.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per eseguire query sulla vista INFORMATION_SCHEMA.TABLE_STORAGE, chiedi all'amministratore di concederti il ruolo IAM Visualizzatore metadati BigQuery (roles/bigquery.metadataViewer) per il progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Questo ruolo predefinito contiene le autorizzazioni necessarie per eseguire query sulla vista INFORMATION_SCHEMA.TABLE_STORAGE. Per visualizzare le autorizzazioni esatte necessarie, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per eseguire query sulla vista INFORMATION_SCHEMA.TABLE_STORAGE sono necessarie le seguenti autorizzazioni:

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

Potresti anche essere in grado di ottenere queste autorizzazioni con i ruoli personalizzati o altri ruoli predefiniti.

Schema

La vista INFORMATION_SCHEMA.TABLE_STORAGE ha il seguente schema:

Nome colonna	Tipo di dati	Valore
PROJECT_ID	STRING	L'ID del progetto che contiene il set di dati
TABLE_CATALOG	STRING	L'ID del progetto che contiene il set di dati
PROJECT_NUMBER	INT64	Il numero del progetto che contiene il set di dati
TABLE_SCHEMA	STRING	Il nome del set di dati che contiene la tabella o la vista materializzata, denominata anche datasetId
TABLE_NAME	STRING	Il nome della tabella o della vista materializzata, denominata anche tableId
CREATION_TIME	TIMESTAMP	L'ora di creazione della tabella
DELETED	BOOLEAN	Indica se la tabella è stata eliminata o meno
STORAGE_LAST_MODIFIED_TIME	TIMESTAMP	L'ultima volta in cui i dati sono stati scritti nella tabella.
TOTAL_ROWS	INT64	Il numero totale di righe nella tabella o nella vista materializzata
TOTAL_PARTITIONS	INT64	Il numero di partizioni presenti nella tabella o nella vista materializzata. Le tabelle non partizionate restituiscono 0.
TOTAL_LOGICAL_BYTES	INT64	Numero totale di byte logici (non compressi) nella tabella o nella vista materializzata
ACTIVE_LOGICAL_BYTES	INT64	Numero di byte logici (non compressi) risalenti a meno di 90 giorni fa
LONG_TERM_LOGICAL_BYTES	INT64	Numero di byte logici (non compressi) risalenti a più di 90 giorni
TOTAL_PHYSICAL_BYTES	INT64	Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi byte attivi, a lungo termine e relativi al tempo di percorrenza (dati eliminati o modificati)
ACTIVE_PHYSICAL_BYTES	INT64	Numero di byte fisici (compressi) risalenti a meno di 90 giorni fa, inclusi i byte relativi ai viaggi nel tempo (dati eliminati o modificati)
LONG_TERM_PHYSICAL_BYTES	INT64	Numero di byte fisici (compressi) vecchi di 90 giorni
TIME_TRAVEL_PHYSICAL_BYTES	INT64	Numero di byte fisici (compressi) utilizzati dall'archiviazione dei viaggi nel tempo (dati eliminati o modificati)
FAIL_SAFE_PHYSICAL_BYTES	INT64	Numero di byte fisici (compressi) utilizzati dall'archiviazione a prova di errore (dati eliminati o modificati)
TABLE_TYPE	STRING	Il tipo di tabella. Ad esempio, "EXTERNAL" o "BASE TABLE"

Ambito e sintassi

Le query in questa vista devono includere un qualificatore regione. La tabella seguente spiega l'ambito della regione per questa visualizzazione:

Nome vista	Ambito risorsa	Ambito regione
[`PROJECT_ID`.]`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE[_BY_PROJECT]	A livello di progetto	REGION

Sostituisci quanto segue:

• (Facoltativo) PROJECT_ID: l'ID del tuo progetto Google Cloud. Se non specificato, viene utilizzato il progetto predefinito.
• REGION: qualsiasi nome della regione del set di dati. Ad esempio: region-us.

Nota: devi specificare la località per eseguire una query sulle viste INFORMATION_SCHEMA e la località di esecuzione della query deve corrispondere alla regione della vista INFORMATION_SCHEMA.

L'esempio seguente mostra come restituire informazioni di archiviazione per le tabelle in un progetto specificato:

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

L'esempio seguente mostra come restituire informazioni di archiviazione per le tabelle in una regione specificata:

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

Esempi

Esempio 1:

L'esempio seguente mostra i byte logici totali fatturati per il progetto attuale.

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

Il risultato è simile al seguente:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+

Esempio 2:

L'esempio seguente mostra come prevedere la differenza di prezzo per set di dati tra i modelli di fatturazione logico e fisico per i 30 giorni successivi. Questo esempio presuppone che l'utilizzo dello spazio di archiviazione futuro sia costante per i 30 giorni successivi dal momento dell'esecuzione della query. Tieni presente che la previsione è limitata alle tabelle di base ed esclude tutti gli altri tipi di tabelle all'interno di un set di dati.

I prezzi utilizzati nelle variabili di prezzo per questa query si riferiscono alla regione us-central1. Se vuoi eseguire questa query per una regione diversa, aggiorna le variabili di prezzo in modo appropriato. Per informazioni sui prezzi, vedi Prezzi dell'archiviazione.

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Inserisci la seguente query GoogleSQL nella casella Editor query. INFORMATION_SCHEMA richiede la sintassi GoogleSQL. GoogleSQL è la sintassi predefinita nella console 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 > 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;
   

   Nota: INFORMATION_SCHEMA i nomi delle visualizzazioni sono sensibili alle maiuscole.

3. Fai clic su Esegui.

Il risultato è simile al seguente:

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