Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Vista TABLE_STORAGE

La vista INFORMATION_SCHEMA.TABLE_STORAGE fornisce un'istantanea attuale dell'utilizzo dello spazio di archiviazione per tabelle e 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 gli aggiornamenti vengono in genere ritardati di alcuni secondi o minuti. Le modifiche allo spazio di archiviazione causate solo dalla scadenza di partizioni o tabelle o da modifiche alla finestra di tempo di viaggio del set di dati potrebbero richiedere fino a un giorno per essere applicate alla vista INFORMATION_SCHEMA.TABLE_STORAGE. In caso di eliminazione di un set di dati contenente più di 1000 tabelle, questa vista non rifletterà la modifica finché non sarà trascorso il periodo di tempo per i viaggi nel tempo per il set di dati eliminato.

Le visualizzazioni dello spazio di archiviazione delle tabelle ti consentono di osservare comodamente il consumo attuale dello spazio di archiviazione e forniscono dettagli sull'utilizzo di byte logici non compressi, byte fisici compressi o byte di viaggio nel tempo. Queste informazioni possono aiutarti in attività come la pianificazione della crescita futura e la comprensione dei pattern di aggiornamento delle tabelle.

Dati inclusi nelle colonne `*_BYTES`

Le colonne *_BYTES nelle visualizzazioni di archiviazione delle tabelle 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 Crea e utilizza le tabelle.
Tabelle temporanee create nelle sessioni. Queste tabelle vengono inserite in set di dati con nomi generati come "_c018003e063d09570001ef33ae401fad6ab92a6a".
Tabelle temporanee create in query con 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 addebitati e pertanto non sono inclusi nei valori della colonna *_BYTES.

I cloni e gli snapshot mostrano i valori della colonna *_BYTES come se fossero tabelle complete, anziché mostrare la differenza rispetto allo spazio di archiviazione utilizzato dalla tabella di base, quindi si tratta di una sovrastima. La fattura tiene conto correttamente di questa differenza nell'utilizzo dello spazio di archiviazione. Per saperne di più sui byte delta archiviati e fatturati da cloni e snapshot, consulta la vista TABLE_STORAGE_USAGE_TIMELINE.

Previsione della fatturazione dello spazio di archiviazione

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 dello spazio di archiviazione del set di dati utilizzato dal set di dati. Tieni presente che si tratta solo di 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 nella fatturazione Cloud.

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

((valore ACTIVE_LOGICAL_BYTES / POW(1024, 3)) * prezzo dei byte logici attivi) + ((valore LONG_TERM_LOGICAL_BYTES / POW(1024, 3)) * prezzo dei byte logici a lungo termine)

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

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

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

Il valore ACTIVE_PHYSICAL_BYTES di una tabella riflette i byte attivi attualmente utilizzati dalla tabella più i byte utilizzati per il viaggio nel tempo per la tabella.

Per visualizzare solo i byte attivi della tabella, sottrai il valore TIME_TRAVEL_PHYSICAL_BYTES dal valore ACTIVE_PHYSICAL_BYTES.

Per saperne di più, consulta Prezzi di archiviazione.

Informazioni sui valori dei byte rispetto alle unità di fatturazione

Le colonne *_BYTES nelle visualizzazioni INFORMATION_SCHEMA.TABLE_STORAGE forniscono un'istantanea del consumo attuale di spazio di archiviazione in byte. In questo modo puoi vedere quanti dati stai archiviando in quel momento.

Tuttavia, la fatturazione dello spazio di archiviazione di BigQuery, come mostrato nei report sulla fatturazione Cloud, non si basa solo su questa dimensione istantanea. La fatturazione viene invece calcolata in base alla quantità di dati archiviati nel tempo. Le unità di fatturazione standard sono GiB/mese o TiB/mese.

Ad esempio, l'archiviazione di 1 GiB per un mese di calendario completo comporta un utilizzo di 1 GiB al mese, indipendentemente dal fatto che il mese abbia da 28 a 31 giorni. Analogamente, l'archiviazione dei dati per una parte del mese viene calcolata in modo proporzionale. L'archiviazione di 31 GiB per un singolo giorno in un mese di 31 giorni equivale a circa 1 GiB-mese, così come l'archiviazione di 28 GiB per un singolo giorno in un mese di 28 giorni equivale a circa 1 GiB-mese.

Sebbene i valori dei byte in INFORMATION_SCHEMA.TABLE_STORAGE siano input essenziali per stimare i costi potenziali, la fattura effettiva riflette il calcolo continuo di (bytes stored * duration stored). I valori di questa visualizzazione non devono corrispondere direttamente alle voci del report sulla fatturazione, che vengono aggregate nel periodo di fatturazione.

Per informazioni dettagliate su come vengono calcolati i costi di archiviazione, consulta la pagina Prezzi di 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) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per eseguire query sulla vista INFORMATION_SCHEMA.TABLE_STORAGE. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

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

bigquery.tables.get
bigquery.tables.list

Potresti anche ottenere queste autorizzazioni con 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 progetto del progetto che contiene il set di dati.
`project_number`	`INT64`	Il numero di progetto del progetto che contiene il set di dati.
`table_catalog`	`STRING`	L'ID progetto 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, noto anche come `datasetId`.
`table_name`	`STRING`	Il nome della tabella o della vista materializzata, indicata anche come `tableId`.
`creation_time`	`TIMESTAMP`	L'ora di creazione della 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 fa.
`current_physical_bytes`	`INT64`	Numero totale di byte fisici per l'archiviazione corrente della tabella in tutte le partizioni.
`total_physical_bytes`	`INT64`	Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi i byte attivi, a lungo termine e di cronologia (dati eliminati o modificati). I byte di sicurezza (dati eliminati o modificati conservati dopo la finestra di spostamento cronologico) non sono inclusi.
`active_physical_bytes`	`INT64`	Numero di byte fisici (compressi) più recenti di 90 giorni, inclusi i byte con spostamento cronologico (dati eliminati o modificati).
`long_term_physical_bytes`	`INT64`	Numero di byte fisici (compressi) risalenti a più di 90 giorni fa.
`time_travel_physical_bytes`	`INT64`	Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione di viaggio nel tempo (dati eliminati o modificati).
`storage_last_modified_time`	`TIMESTAMP`	L'ora più recente in cui i dati sono stati scritti nella tabella. Restituisce `NULL` se non esistono dati.
`deleted`	`BOOLEAN`	Indica se la tabella è stata eliminata o meno.
`table_type`	`STRING`	Il tipo di tabella. Ad esempio, `BASE TABLE`.
`managed_table_type`	`STRING`	Questa colonna è in anteprima. Il tipo gestito della tabella. Ad esempio, `NATIVE` o `BIGLAKE`.
`fail_safe_physical_bytes`	`INT64`	Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione con protezione dai guasti (dati eliminati o modificati).
`last_metadata_index_refresh_time`	`TIMESTAMP`	L'ora dell'ultimo aggiornamento dell'indice dei metadati della tabella.
`table_deletion_reason`	`STRING`	Motivo dell'eliminazione della tabella se il campo `deleted` è true. I valori possibili sono: Tabella `TABLE_EXPIRATION:` eliminata dopo la scadenza impostata Dataset `DATASET_DELETION:` eliminato dall'utente La tabella `USER_DELETED:` è stata eliminata dall'utente
`table_deletion_time`	`TIMESTAMP`	L'ora di eliminazione della tabella.

Per garantire la stabilità, ti consigliamo di elencare esplicitamente le colonne nelle query dello schema di informazioni anziché utilizzare un carattere jolly (SELECT *). L'elenco esplicito delle colonne impedisce l'interruzione delle query se lo schema sottostante cambia.

Ambito e sintassi

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

Nome vista	Ambito risorsa	Ambito della regione
[`PROJECT_ID`.]`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE[_BY_PROJECT]	Livello 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 utilizzare un qualificatore di regione per eseguire query sulle visualizzazioni INFORMATION_SCHEMA. La località di esecuzione della query deve corrispondere alla regione della vista INFORMATION_SCHEMA.

L'esempio seguente mostra come restituire le informazioni di archiviazione per le tabelle in un progetto e una regione specificati:

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

L'esempio seguente mostra come restituire le informazioni di archiviazione per le tabelle nel progetto corrente 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 corrente.

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 diversi byte di archiviazione in GiB a livello di set di dati per il progetto corrente.

SELECT
  table_schema AS dataset_name,
  -- Logical
  SUM(total_logical_bytes) / power(1024, 3) AS total_logical_gib,
  SUM(active_logical_bytes) / power(1024, 3) AS active_logical_gib,
  SUM(long_term_logical_bytes) / power(1024, 3) AS long_term_logical_gib,
  -- Physical
  SUM(total_physical_bytes) / power(1024, 3) AS total_physical_gib,
  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,
  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
WHERE
  table_type ='BASE TABLE'
GROUP BY
  table_schema
ORDER BY
  dataset_name

Esempio 3:

L'esempio seguente mostra come prevedere la differenza di prezzo per set di dati tra i modelli di fatturazione logica e fisica per i prossimi 30 giorni. Questo esempio presuppone che l'utilizzo dello spazio di archiviazione futuro sia costante nei successivi 30 giorni dal momento in cui è stata eseguita la 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 dei prezzi in modo appropriato. Per informazioni sui prezzi, consulta Prezzi di Storage.

Apri la pagina BigQuery nella console Google Cloud .

Vai alla pagina BigQuery

Inserisci la seguente query GoogleSQL nella casella Editor di 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 + 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;

Fai clic su Esegui.