Creare e utilizzare le tabelle
Questo documento descrive come creare e utilizzare tabelle standard (integrate) in BigQuery. Per informazioni sulla creazione di altri tipi di tabella, consulta:
Dopo aver creato una tabella, puoi:
- Controlla l'accesso ai dati della tabella
- Ottieni informazioni sulle tabelle
- Elenco delle tabelle in un set di dati
- Recupero metadati tabella
Per ulteriori informazioni sulla gestione delle tabelle, inclusi l'aggiornamento delle proprietà delle tabelle, la copia e l'eliminazione di una tabella, consulta la sezione Gestione delle tabelle.
Prima di iniziare
Prima di creare una tabella in BigQuery:
- Configura un progetto seguendo la guida introduttiva a BigQuery.
- Crea un set di dati BigQuery.
- Facoltativamente, leggi Introduzione alle tabelle per comprendere le limitazioni, le quote e i prezzi delle tabelle.
Denominazione tabella
Quando crei una tabella in BigQuery, il nome della tabella deve essere univoco per ogni set di dati. Il nome della tabella può:
- Contenere caratteri con un totale di massimo 1024 byte UTF-8.
- Contenere caratteri Unicode nella categoria L (lettera), M (segno), N (numero), Pc (connettore, compreso il trattino basso), Pd (trattino), Zs (spazio). Per ulteriori informazioni, consulta la sezione Categoria generale.
Di seguito sono riportati tutti gli esempi di nomi di tabella validi:
table 01
, ग्राहक
, 00_お客様
, étudiant-01
.
Precisazioni:
- Per impostazione predefinita, i nomi delle tabelle sono sensibili alle maiuscole.
mytable
eMyTable
possono coesistere nello stesso set di dati, a meno che non facciano parte di un set di dati con la sensibilità alle maiuscole disattivata. - Alcuni nomi di tabelle e prefissi dei nomi di tabella sono riservati. Se ricevi un errore che indica che il nome o il prefisso della tabella è prenotato, seleziona un nome diverso e riprova.
Se includi più operatori di punti (
.
) in una sequenza, gli operatori duplicati vengono implicitamente rimossi.Ad esempio:
project_name....dataset_name..table_name
Diventa questo:
project_name.dataset_name.table_name
Creare tabelle
Puoi creare una tabella in BigQuery nei seguenti modi:
- Manualmente utilizzando la console Google Cloud o il comando a riga di comando bq
bq mk
. - In modo programmatico, chiamando il metodo API
tables.insert
. - Utilizzando le librerie client.
- Dai risultati delle query.
- Definisci una tabella che fa riferimento a un'origine dati esterna.
- Quando carichi i dati.
- Utilizzando un'istruzione
CREATE TABLE
Data Definition Language (DDL).
Autorizzazioni obbligatorie
Per creare una tabella, devi disporre delle seguenti autorizzazioni IAM:
bigquery.tables.create
bigquery.tables.updateData
bigquery.jobs.create
Inoltre, potresti richiedere l'autorizzazione bigquery.tables.getData
per accedere ai dati scritti nella tabella.
Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per creare una tabella:
roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin
(include l'autorizzazionebigquery.jobs.create
)roles/bigquery.user
(include l'autorizzazionebigquery.jobs.create
)roles/bigquery.jobUser
(include l'autorizzazionebigquery.jobs.create
)
Inoltre, se disponi dell'autorizzazione bigquery.datasets.create
, puoi
creare e aggiornare le tabelle nei set di dati che crei.
Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, consulta Autorizzazioni e ruoli predefiniti.
Crea una tabella vuota con una definizione di schema
Puoi creare una tabella vuota con una definizione di schema nei seguenti modi:
- Inserisci lo schema utilizzando la console Google Cloud.
- Fornisci lo schema incorporato utilizzando lo strumento a riga di comando bq.
- Invia un file di schema JSON utilizzando lo strumento a riga di comando bq.
- Fornisci lo schema in una risorsa di tabella quando chiami il metodo
tables.insert
dell'API.
Per saperne di più su come specificare uno schema di tabella, consulta la sezione Specifica di uno schema.
Dopo aver creato la tabella, puoi caricare i dati al suo interno o popolarla scrivendovi i risultati della query.
Per creare una tabella vuota con una definizione di schema:
Console
Nella console Google Cloud, vai alla pagina BigQuery.
- Nel riquadro Explorer, espandi il progetto, quindi seleziona un set di dati.
- Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
- Nel riquadro Crea tabella, specifica i seguenti dettagli:
- Nella sezione Origine, seleziona Tabella vuota nell'elenco Crea tabella da.
- Nella sezione Destinazione, specifica i seguenti dettagli:
- In Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
- Nel campo Tabella, inserisci il nome della tabella che vuoi creare.
- Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
- Nella sezione Schema, inserisci la definizione di schema.
Puoi inserire manualmente le informazioni dello schema utilizzando uno dei seguenti metodi:
- Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di array JSON. Quando utilizzi un array JSON, per generare lo schema segui la stessa procedura utilizzata per la creazione di un file di schema JSON.
Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo il seguente
comando:
bq show --format=prettyjson dataset.table
- Opzione 2: fai clic su Tipo e Modalità per ciascun campo. Aggiungi campo e inserisci lo schema della tabella. Specifica Nome,
- Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di array JSON. Quando utilizzi un array JSON, per generare lo schema segui la stessa procedura utilizzata per la creazione di un file di schema JSON.
Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo il seguente
comando:
- (Facoltativo) Specifica le impostazioni di partizione e cluster. Per saperne di più, consulta Creazione di tabelle partizionate e Creazione e utilizzo delle tabelle in cluster.
- (Facoltativo) Nella sezione Opzioni avanzate, se vuoi utilizzare una chiave di crittografia gestita dal cliente, seleziona l'opzione Utilizza una chiave di crittografia gestita dal cliente (CMEK). Per impostazione predefinita, BigQuery cripta i contenuti dei clienti archiviati at-rest utilizzando una chiave gestita da Google.
- Fai clic su Crea tabella.
SQL
L'esempio seguente crea una tabella denominata newtable
che scade il 1° gennaio 2023:
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'Editor query, inserisci la seguente istruzione:
CREATE TABLE mydataset.newtable ( x INT64 OPTIONS (description = 'An optional INTEGER field'), y STRUCT < a ARRAY <STRING> OPTIONS (description = 'A repeated STRING field'), b BOOL > ) OPTIONS ( expiration_timestamp = TIMESTAMP '2023-01-01 00:00:00 UTC', description = 'a table that expires in 2023', labels = [('org_unit', 'development')]);
Fai clic su
Esegui.
Per ulteriori informazioni su come eseguire le query, consulta Eseguire una query interattiva.
bq
-
Nella console Google Cloud, attiva Cloud Shell.
Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.
Utilizza il comando
bq mk
con il flag--table
o-t
. Puoi fornire le informazioni sullo schema della tabella in linea o tramite un file di schema JSON. I parametri facoltativi includono:--expiration
--description
--time_partitioning_field
--time_partitioning_type
--range_partitioning
--clustering_fields
--destination_kms_key
--label
--time_partitioning_field
,--time_partitioning_type
,--range_partitioning
,--clustering_fields
e--destination_kms_key
non sono mostrati qui. Per saperne di più su questi parametri facoltativi, fai riferimento ai seguenti link:- Per maggiori informazioni su
--time_partitioning_field
,--time_partitioning_type
e--range_partitioning
, consulta le tabelle partizionate. - Per maggiori informazioni su
--clustering_fields
, consulta le tabelle in cluster. - Per maggiori informazioni su
--destination_kms_key
, consulta Chiavi di crittografia gestite dal cliente.
Se stai creando una tabella in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato:
project_id:dataset
.Per creare una tabella vuota in un set di dati esistente con una definizione di schema, inserisci quanto segue:
bq mk \ --table \ --expiration integer \ --description description \ --label key_1:value_1 \ --label key_2:value_2 \ project_id:dataset.table \ schema
Sostituisci quanto segue:
- integer è la durata predefinita (in secondi) della tabella. Il valore minimo è 3600 secondi (un'ora). L'ora di scadenza viene valutata in base all'ora UTC attuale più il valore intero. Se imposti la data di scadenza quando crei una tabella, l'impostazione di scadenza predefinita della tabella del set di dati viene ignorata.
- description è una descrizione della tabella tra virgolette.
- key_1:value_1 e key_2:value_2 sono coppie chiave-valore che specificano le etichette.
- project_id è l'ID progetto.
- dataset è un set di dati nel tuo progetto.
- table è il nome della tabella che stai creando.
- schema è una definizione di schema integrata nel formato field:data_type,field:data_type o il percorso del file di schema JSON sulla tua macchina locale.
Quando specifichi lo schema nella riga di comando, non puoi includere un tipo
RECORD
(STRUCT
), non puoi includere una descrizione della colonna né specificare la modalità della colonna. Per impostazione predefinita, tutte le modalità sonoNULLABLE
. Per includere descrizioni, modalità e tipi diRECORD
, fornisci invece un file di schema JSON.Esempi:
Inserisci il comando seguente per creare una tabella utilizzando una definizione di schema in linea. Questo comando crea una tabella denominata
mytable
inmydataset
nel progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata suThis is my table
e l'etichetta è impostata suorganization:development
. Il comando utilizza la scorciatoia-t
anziché--table
. Lo schema è specificato in linea come:qtr:STRING,sales:FLOAT,year:STRING
.bq mk \ -t \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ mydataset.mytable \ qtr:STRING,sales:FLOAT,year:STRING
Inserisci il comando seguente per creare una tabella utilizzando un file di schema JSON. Questo comando crea una tabella denominata
mytable
inmydataset
nel tuo progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata suThis is my table
e l'etichetta è impostata suorganization:development
. Il percorso del file di schema è/tmp/myschema.json
.bq mk \ --table \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ mydataset.mytable \ /tmp/myschema.json
Inserisci il comando seguente per creare una tabella utilizzando un file di schema JSON. Questo comando crea una tabella denominata
mytable
inmydataset
inmyotherproject
. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata suThis is my table
e l'etichetta è impostata suorganization:development
. Il percorso del file di schema è/tmp/myschema.json
.bq mk \ --table \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ myotherproject:mydataset.mytable \ /tmp/myschema.json
Dopo aver creato la tabella, puoi aggiornare la scadenza, la descrizione e le etichette della tabella. Puoi anche modificare la definizione dello schema.
Terraform
Utilizza la risorsa google_bigquery_table
.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Creare una tabella
Nell'esempio seguente viene creata una tabella denominata mytable
:
Creare una tabella e concedere l'accesso
L'esempio seguente crea una tabella denominata mytable
, quindi utilizza la risorsa google_bigquery_table_iam_policy
per concederle l'accesso. Esegui questo passaggio solo se vuoi concedere l'accesso alla tabella alle entità che non hanno accesso al set di dati in cui si trova la tabella.
Creare una tabella con una chiave di crittografia gestita dal cliente
L'esempio seguente crea una tabella denominata mytable
e utilizza anche le risorse
google_kms_crypto_key
e
google_kms_key_ring
per specificare una
chiave Cloud Key Management Service per la
tabella. Prima di eseguire questo esempio devi abilitare l'API Cloud Key Management Service.
Per applicare la configurazione Terraform in un progetto Google Cloud, completa i passaggi nelle sezioni seguenti.
prepara Cloud Shell
- Avvia Cloud Shell.
-
Imposta il progetto Google Cloud predefinito a cui vuoi applicare le configurazioni Terraform.
Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
Se imposti valori espliciti nel file di configurazione Terraform, le variabili di ambiente vengono sostituite.
Prepara la directory
Ogni file di configurazione Terraform deve avere una propria directory (detta anche modulo principale).
-
In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome del file deve avere l'estensione
.tf
, ad esempiomain.tf
. In questo tutorial, il file è indicato comemain.tf
.mkdir DIRECTORY && cd DIRECTORY && touch main.tf
-
Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.
Copia il codice campione nel file
main.tf
appena creato.Se vuoi, copia il codice da GitHub. Questa opzione è consigliata se lo snippet Terraform fa parte di una soluzione end-to-end.
- Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
- Salva le modifiche.
-
Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
terraform init
Facoltativamente, per utilizzare la versione più recente del provider Google, includi l'opzione
-upgrade
:terraform init -upgrade
Applica le modifiche
-
Rivedi la configurazione e verifica che le risorse che Terraform creerà o aggiornerà corrispondano alle tue aspettative:
terraform plan
Apporta le correzioni necessarie alla configurazione.
-
Applica la configurazione Terraform eseguendo il comando seguente e inserendo
yes
al prompt:terraform apply
Attendi finché Terraform non visualizza il messaggio "Applicazione completata".
- Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.
API
Chiama il metodo tables.insert
con una risorsa di tabella definita.
C#
Prima di provare questo esempio, segui le istruzioni di configurazione di C# disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery C#.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Go
Prima di provare questo esempio, segui le istruzioni di configurazione di Go disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Go.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Node.js
Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
PHP
Prima di provare questo esempio, segui le istruzioni di configurazione di PHP disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery PHP.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni di configurazione di Python disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Ruby
Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Ruby.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Crea una tabella vuota senza una definizione di schema
Java
Prima di provare questo esempio, segui le istruzioni di configurazione di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Creare una tabella dal risultato di una query
Per creare una tabella da un risultato di query, scrivi i risultati in una tabella di destinazione.
Console
Apri la pagina BigQuery nella console Google Cloud.
Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Inserisci una query SQL valida.
Fai clic su Altro e seleziona Impostazioni query.
Seleziona l'opzione Imposta una tabella di destinazione per i risultati della query.
Nella sezione Destinazione, seleziona il Set di dati in cui creare la tabella, quindi scegli un ID tabella.
Nella sezione Preferenza di scrittura della tabella di destinazione, scegli una delle seguenti opzioni:
- Scrivi se vuota: scrive i risultati della query nella tabella solo se è vuota.
- Aggiungi alla tabella: aggiunge i risultati della query a una tabella esistente.
- Sovrascrivi tabella: sovrascrive una tabella esistente con lo stesso nome utilizzando i risultati della query.
(Facoltativo) Per Località dei dati, scegli la tua località.
Per aggiornare le impostazioni della query, fai clic su Salva.
Fai clic su Esegui. Viene creato un job di query che scrive i risultati della query nella tabella specificata.
In alternativa, se dimentichi di specificare una tabella di destinazione prima di eseguire la query, puoi copiare la tabella dei risultati memorizzata nella cache in una tabella permanente facendo clic sul pulsante Salva risultati sopra l'editor.
SQL
L'esempio seguente utilizza l'istruzione CREATE TABLE
per creare la tabella trips
dai dati nella tabella bikeshare_trips
pubblica:
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'Editor query, inserisci la seguente istruzione:
CREATE TABLE mydataset.trips AS ( SELECT bike_id, start_time, duration_minutes FROM bigquery-public-data.austin_bikeshare.bikeshare_trips );
Fai clic su
Esegui.
Per ulteriori informazioni su come eseguire le query, consulta Eseguire una query interattiva.
Per scoprire di più, consulta la pagina relativa alla creazione di una nuova tabella da una tabella esistente.
bq
-
Nella console Google Cloud, attiva Cloud Shell.
Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.
Inserisci il comando
bq query
e specifica il flag--destination_table
per creare una tabella permanente in base ai risultati della query. Specifica il flaguse_legacy_sql=false
per utilizzare la sintassi GoogleSQL. Per scrivere i risultati della query in una tabella che non si trova nel progetto predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato:project_id:dataset
.(Facoltativo) Fornisci il flag
--location
e imposta il valore sulla tua location.Per controllare la disposizione di scrittura per una tabella di destinazione esistente, specifica uno dei seguenti flag facoltativi:
--append_table
: se la tabella di destinazione esiste, i risultati della query vengono aggiunti.--replace
: se la tabella di destinazione esiste, viene sovrascritta con i risultati della query.bq --location=location query \ --destination_table project_id:dataset.table \ --use_legacy_sql=false 'query'
Sostituisci quanto segue:
location
è il nome della località utilizzata per elaborare la query. Il flag--location
è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il valore del flag suasia-northeast1
. Puoi impostare un valore predefinito per la località utilizzando il file.bigqueryrc
.project_id
è l'ID progetto.dataset
è il nome del set di dati contenente la tabella in cui stai scrivendo i risultati della query.table
è il nome della tabella in cui stai scrivendo i risultati della query.query
è una query nella sintassi di GoogleSQL.Se non viene specificato alcun flag relativo alla disposizione di scrittura, il comportamento predefinito prevede la scrittura dei risultati nella tabella solo se è vuota. Se la tabella esiste e non è vuota, viene restituito il seguente errore: "Errore BigQuery nell'operazione di query: errore di elaborazione del job
project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table
.Esempi:
Inserisci il comando seguente per scrivere i risultati della query in una tabella di destinazione denominata
mytable
inmydataset
. Il set di dati si trova nel progetto predefinito. Poiché non è specificato alcun flag relativo alla disposizione di scrittura nel comando, la tabella deve essere nuova o vuota. In caso contrario, viene restituito un erroreAlready exists
. La query recupera i dati dal set di dati pubblico USA Name Data.bq query \ --destination_table mydataset.mytable \ --use_legacy_sql=false \ 'SELECT name, number FROM `bigquery-public-data`.usa_names.usa_1910_current WHERE gender = "M" ORDER BY number DESC'
Inserisci il seguente comando per utilizzare i risultati della query per sovrascrivere una tabella di destinazione denominata
mytable
inmydataset
. Il set di dati si trova nel progetto predefinito. Il comando utilizza il flag--replace
per sovrascrivere la tabella di destinazione.bq query \ --destination_table mydataset.mytable \ --replace \ --use_legacy_sql=false \ 'SELECT name, number FROM `bigquery-public-data`.usa_names.usa_1910_current WHERE gender = "M" ORDER BY number DESC'
Inserisci il seguente comando per aggiungere i risultati della query a una tabella di destinazione denominata
mytable
inmydataset
. Il set di dati si trova inmy-other-project
, non nel progetto predefinito. Il comando utilizza il flag--append_table
per aggiungere i risultati della query alla tabella di destinazione.bq query \ --append_table \ --use_legacy_sql=false \ --destination_table my-other-project:mydataset.mytable \ 'SELECT name, number FROM `bigquery-public-data`.usa_names.usa_1910_current WHERE gender = "M" ORDER BY number DESC'
L'output di ognuno di questi esempi è simile al seguente. Per la leggibilità, alcuni output sono troncati.
Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE +---------+--------+ | name | number | +---------+--------+ | Robert | 10021 | | John | 9636 | | Robert | 9297 | | ... | +---------+--------+
API
Per salvare i risultati della query in una tabella permanente, chiama il metodo jobs.insert
, configura un job query
e includi un valore per la proprietà destinationTable
. Per controllare la disposizione di scrittura di una tabella di destinazione esistente, configura la proprietà writeDisposition
.
Per controllare la località di elaborazione del job di query, specifica la proprietà location
nella sezione jobReference
della risorsa del job.
Go
Prima di provare questo esempio, segui le istruzioni di configurazione di Go disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Go.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Per salvare i risultati della query in una tabella permanente, imposta la tabella di destinazione sul valore TableId desiderato in QueryJobConfiguration.
Node.js
Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni di configurazione di Python disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Per salvare i risultati della query in una tabella permanente, crea un oggetto QueryJobConfig e imposta la destinazione sul valore TableReference che preferisci. Passa la configurazione del job al metodo di query.Crea una tabella che fa riferimento a un'origine dati esterna
Un'origine dati esterna è un'origine dati in cui puoi eseguire query direttamente da BigQuery, anche se i dati non vengono archiviati in BigQuery. Ad esempio, potresti avere dati in un database Google Cloud diverso, in file in Cloud Storage o in un prodotto cloud diverso che vorresti analizzare in BigQuery, ma non avere ancora la possibilità di eseguire una migrazione.
Per ulteriori informazioni, consulta Introduzione alle origini dati esterne.
Crea una tabella quando carichi i dati
Quando carichi i dati in BigQuery, puoi caricarli in una nuova tabella o partizione, aggiungere dati a una tabella o partizione esistente oppure puoi sovrascrivere una tabella o una partizione. Non è necessario creare una tabella vuota prima di caricare i dati al suo interno. Puoi creare la nuova tabella e caricare i dati contemporaneamente.
Quando carichi i dati in BigQuery, puoi fornire lo schema della tabella o di partizione oppure, per i formati di dati supportati, puoi utilizzare il rilevamento automatico dello schema.
Per ulteriori informazioni sul caricamento dei dati, consulta Introduzione al caricamento dei dati in BigQuery.
Controlla l'accesso alle tabelle
Per configurare l'accesso a tabelle e viste, puoi concedere un ruolo IAM a un'entità ai seguenti livelli, elencati in ordine di intervallo di risorse consentite (dalla più grande alla più piccola):
- Un livello generale nella gerarchia delle risorse di Google Cloud, ad esempio a livello di progetto, cartella o organizzazione
- il livello del set di dati
- a livello di tabella o vista
Puoi anche limitare l'accesso ai dati all'interno delle tabelle utilizzando i seguenti metodi:
L'accesso con qualsiasi risorsa protetta da IAM è cumulativo. Ad esempio, se un'entità non ha accesso ad alto livello come un progetto, puoi concedere all'entità l'accesso a livello del set di dati e l'entità avrà accesso alle tabelle e alle viste nel set di dati. Analogamente, se l'entità non ha accesso a livello di set di dati generale, puoi concedere l'accesso all'entità a livello di tabella o vista.
La concessione di ruoli IAM a un livello superiore nella gerarchia delle risorse di Google Cloud, ad esempio a livello di progetto, cartella o organizzazione, consente all'entità di accedere a un insieme più ampio di risorse. Ad esempio, la concessione di un ruolo a un'entità a livello di progetto concede a tale entità le autorizzazioni che si applicano a tutti i set di dati nel progetto.
La concessione di un ruolo a livello di set di dati specifica le operazioni che un'entità può eseguire su tabelle e viste in quel determinato set di dati, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dei controlli dell'accesso a livello di set di dati, consulta Controllo dell'accesso ai set di dati.
La concessione di un ruolo a livello di tabella o vista specifica le operazioni che un'entità può eseguire su determinate tabelle e viste, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dei controlli di accesso a livello di tabella, consulta Controllo dell'accesso a tabelle e viste.
Puoi anche creare ruoli IAM personalizzati. Se crei un ruolo personalizzato, le autorizzazioni concesse dipendono dalle operazioni specifiche che vuoi che l'entità possa eseguire.
Non puoi impostare un'autorizzazione "nega" per le risorse protette da IAM.
Per ulteriori informazioni sui ruoli e sulle autorizzazioni, consulta Informazioni sui ruoli nella documentazione IAM e Ruoli e autorizzazioni IAM di BigQuery.
Ottieni informazioni sulle tabelle
Puoi ottenere informazioni o metadati sulle tabelle nei seguenti modi:
- Utilizzo della console Google Cloud.
- Utilizzando il comando a riga di comando bq
bq show
. - Chiamata al metodo API
tables.get
. - Utilizzo delle librerie client.
- Esecuzione di query sulle viste
INFORMATION_SCHEMA
(beta).
Autorizzazioni obbligatorie
Devi disporre almeno delle autorizzazioni bigquery.tables.get
per ottenere informazioni sulle tabelle. I seguenti ruoli IAM predefiniti includono le autorizzazioni bigquery.tables.get
:
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
bigquery.admin
Inoltre, se un utente ha autorizzazioni bigquery.datasets.create
, quando crea un set di dati, gli viene concesso l'accesso bigquery.dataOwner
.
L'accesso bigquery.dataOwner
consente all'utente di recuperare i metadati della tabella.
Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.
Recupera informazioni sulla tabella
Per ottenere informazioni sulle tabelle:
Console
Nel pannello di navigazione, nella sezione Risorse, espandi il progetto e seleziona un set di dati.
Fai clic sul nome del set di dati per espanderlo. Vengono visualizzate le tabelle e le visualizzazioni nel set di dati.
Fai clic sul nome della tabella.
Nel riquadro Dettagli, fai clic su Dettagli per visualizzare la descrizione e le informazioni della tabella.
Facoltativamente, passa alla scheda Schema per visualizzare la definizione dello schema della tabella.
bq
-
Nella console Google Cloud, attiva Cloud Shell.
Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.
Esegui il comando
bq show
per visualizzare tutte le informazioni sulla tabella. Utilizza il flag--schema
per visualizzare solo le informazioni dello schema della tabella. Il flag--format
può essere utilizzato per controllare l'output.Se ricevi informazioni su una tabella in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato:
project_id:dataset
.bq show \ --schema \ --format=prettyjson \ project_id:dataset.table
Dove:
- project_id è l'ID progetto.
- dataset è il nome del set di dati.
- table è il nome della tabella.
Esempi:
Inserisci il seguente comando per visualizzare tutte le informazioni su
mytable
inmydataset
.mydataset
è nel tuo progetto predefinito.bq show --format=prettyjson mydataset.mytable
Inserisci il seguente comando per visualizzare tutte le informazioni su
mytable
inmydataset
.mydataset
si trova inmyotherproject
, non è il tuo progetto predefinito.bq show --format=prettyjson myotherproject:mydataset.mytable
Inserisci il comando seguente per visualizzare solo le informazioni dello schema relative a
mytable
inmydataset
.mydataset
si trova inmyotherproject
, non nel tuo progetto predefinito.bq show --schema --format=prettyjson myotherproject:mydataset.mytable
API
Richiama il metodo tables.get
e fornisci i parametri pertinenti.
Go
Prima di provare questo esempio, segui le istruzioni di configurazione di Go disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Go.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Node.js
Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
PHP
Prima di provare questo esempio, segui le istruzioni di configurazione di PHP disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery PHP.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni di configurazione di Python disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Ottieni le informazioni sulla tabella utilizzando INFORMATION_SCHEMA
INFORMATION_SCHEMA
è una serie di viste che consentono di accedere ai metadati
relativi a set di dati, routine, tabelle, viste, job, prenotazioni e flussi di dati.
Per ottenere informazioni sulle tabelle, puoi eseguire query sulle seguenti viste:
- Utilizzare le viste
INFORMATION_SCHEMA.TABLES
eINFORMATION_SCHEMA.TABLE_OPTIONS
per recuperare i metadati sulle tabelle e sulle visualizzazioni in un progetto. - Utilizza le viste
INFORMATION_SCHEMA.COLUMNS
eINFORMATION_SCHEMA.COLUMN_FIELD_PATHS
per recuperare i metadati sulle colonne (campi) in una tabella. - Utilizza le viste
INFORMATION_SCHEMA.TABLE_STORAGE
per recuperare i metadati sull'utilizzo dello spazio di archiviazione attuale e storico da parte di una tabella.
Le viste TABLES
e TABLE_OPTIONS
contengono anche informazioni di alto livello sulle viste. Per informazioni dettagliate, esegui invece una query sulla visualizzazione INFORMATION_SCHEMA.VIEWS
.
TABLES
visualizzazione
Quando esegui una query sulla vista INFORMATION_SCHEMA.TABLES
, i risultati della query contengono una riga per ogni tabella o vista in un set di dati. Per informazioni dettagliate sulle viste, esegui invece una query sulla vista INFORMATION_SCHEMA.VIEWS
.
La vista INFORMATION_SCHEMA.TABLES
ha il seguente schema:
Nome colonna | Tipo di dati | Valore |
---|---|---|
table_catalog |
STRING |
L'ID del progetto che contiene il set di dati. |
table_schema |
STRING |
Il nome del set di dati che contiene la tabella o la vista. Chiamato anche datasetId . |
table_name |
STRING |
Il nome della tabella o della vista. Chiamato anche tableId . |
table_type |
STRING |
Il tipo di tabella; uno dei seguenti:
|
is_insertable_into |
STRING |
YES o NO a seconda che la tabella supporti le istruzioni DML INSERT |
is_typed |
STRING |
Il valore è sempre NO |
creation_time |
TIMESTAMP |
L'ora di creazione della tabella |
base_table_catalog |
STRING |
Per i cloni di tabella e gli snapshot delle tabelle, il progetto della tabella di base. Applicabile solo alle
tabelle con table_type impostato su CLONE o
SNAPSHOT .
|
base_table_schema |
STRING |
Per i cloni di tabelle e gli snapshot delle tabelle, il set di dati della tabella di base. Applicabile solo alle tabelle con
table_type impostato su CLONE o
SNAPSHOT . |
base_table_name |
STRING |
Per i cloni di tabella e gli snapshot delle tabelle, il nome della tabella di base. Applicabile solo alle tabelle con
table_type impostato su CLONE o
SNAPSHOT . |
snapshot_time_ms |
TIMESTAMP |
Per i cloni di tabella e gli snapshot di tabella, la data e l'ora in cui l'operazione clone o snapshot è stata eseguita nella tabella di base per creare questa tabella. Se è stato utilizzato viaggio nel tempo, questo campo contiene il timestamp del viaggio nel tempo. In caso contrario, il campo snapshot_time_ms corrisponde al campo creation_time . Applicabile solo alle
tabelle con table_type impostato su CLONE o
SNAPSHOT .
|
replica_source_catalog |
STRING |
Per le repliche della vista materializzata, il progetto della vista materializzata di base. |
replica_source_schema |
STRING |
Per le repliche delle viste materializzate, il set di dati della vista materializzata di base. |
replica_source_name |
STRING |
Per le repliche della vista materializzata, il nome della vista materializzata di base. |
replication_status |
STRING |
Per le repliche con vista materializzata, lo stato della replica dalla vista materializzata di base a quella della vista materializzata; uno dei seguenti:
|
replication_error |
STRING |
Se replication_status indica un problema di replica per una
replica con vista materializzata,
replication_error fornisce ulteriori dettagli sul problema. |
ddl |
STRING |
L'istruzione DDL che può essere utilizzata per ricreare la tabella, ad esempio CREATE TABLE o CREATE VIEW |
default_collation_name |
STRING |
Il nome della specifica di confronto predefinita, se esistente. In caso contrario, NULL .
|
upsert_stream_apply_watermark |
TIMESTAMP |
Per le tabelle che utilizzano Change Data Capture (CDC), l'ora in cui sono state applicate l'ultima modifica alle righe. Per maggiori informazioni, consulta Monitorare l'avanzamento dell'operazione di upsert della tabella. |
Esempi
Esempio 1:
L'esempio seguente recupera i metadati della tabella per tutte le tabelle nel
set di dati denominato mydataset
. I metadati
restituiti si riferiscono a tutti i tipi di tabelle in mydataset
nel tuo progetto predefinito.
mydataset
contiene le seguenti tabelle:
mytable1
: una tabella BigQuery standardmyview1
: una vista BigQuery
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES
.
SELECT table_catalog, table_schema, table_name, table_type, is_insertable_into, creation_time, ddl FROM mydataset.INFORMATION_SCHEMA.TABLES;
Il risultato è simile al seguente. Per la leggibilità, alcune colonne sono escluse dal risultato.
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+ | table_catalog | table_schema | table_name | table_type | is_insertable_into | creation_time | ddl | +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+ | myproject | mydataset | mytable1 | BASE TABLE | YES | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` | | | | | | | | ( | | | | | | | | id INT64 | | | | | | | | ); | | myproject | mydataset | myview1 | VIEW | NO | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1` | | | | | | | | AS SELECT 100 as id; | +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Esempio 2:
L'esempio seguente recupera i metadati della tabella per tutte le tabelle di tipo CLONE
o SNAPSHOT
dalla visualizzazione INFORMATION_SCHEMA.TABLES
. I metadati restituiti
si riferiscono alle tabelle in mydataset
nel progetto predefinito.
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES
.
SELECT table_name, table_type, base_table_catalog, base_table_schema, base_table_name, snapshot_time_ms FROM mydataset.INFORMATION_SCHEMA.TABLES WHERE table_type = 'CLONE' OR table_type = 'SNAPSHOT';
Il risultato è simile al seguente. Per la leggibilità, alcune colonne sono escluse dal risultato.
+--------------+------------+--------------------+-------------------+-----------------+---------------------+ | table_name | table_type | base_table_catalog | base_table_schema | base_table_name | snapshot_time_ms | +--------------+------------+--------------------+-------------------+-----------------+---------------------+ | items_clone | CLONE | myproject | mydataset | items | 2018-10-31 22:40:05 | | orders_bk | SNAPSHOT | myproject | mydataset | orders | 2018-11-01 08:22:39 | +--------------+------------+--------------------+-------------------+-----------------+---------------------+
Esempio 3:
L'esempio seguente recupera le colonne table_name
e ddl
dalla vista INFORMATION_SCHEMA.TABLES
per la tabella population_by_zip_2010
nel set di dati
census_bureau_usa
. Questo set di dati fa parte del programma di set di dati pubblici di BigQuery.
Poiché la tabella su cui stai eseguendo una query si trova in un altro progetto, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
.
In questo esempio, il valore è `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
.
SELECT table_name, ddl FROM `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES WHERE table_name = 'population_by_zip_2010';
Il risultato è simile al seguente:
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | table_name | ddl | +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010` | | | ( | | | geo_id STRING OPTIONS(description="Geo code"), | | | zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"), | | | population INT64 OPTIONS(description="The total count of the population for this segment."), | | | minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."), | | | maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), | | | gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.") | | | ) | | | OPTIONS( | | | labels=[("freebqcovid", "")] | | | ); | +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
TABLE_OPTIONS
visualizzazione
Quando esegui una query sulla vista INFORMATION_SCHEMA.TABLE_OPTIONS
, i risultati della query
contengono una riga per ogni opzione, per ogni tabella o vista in un set di dati. Per informazioni dettagliate sulle viste, esegui invece una query sulla vista INFORMATION_SCHEMA.VIEWS
.
La vista INFORMATION_SCHEMA.TABLE_OPTIONS
ha il seguente schema:
Nome colonna | Tipo di dati | Valore |
---|---|---|
TABLE_CATALOG |
STRING |
L'ID del progetto che contiene il set di dati |
TABLE_SCHEMA |
STRING |
Il nome del set di dati che contiene la tabella o la vista, denominata anche datasetId |
TABLE_NAME |
STRING |
Il nome della tabella o della vista, denominato anche tableId |
OPTION_NAME |
STRING |
Uno dei valori del nome nella tabella delle opzioni |
OPTION_TYPE |
STRING |
Uno dei valori del tipo di dati nella tabella delle opzioni. |
OPTION_VALUE |
STRING |
Una delle opzioni di valore nella tabella delle opzioni. |
Tabella delle opzioni
OPTION_NAME |
OPTION_TYPE |
OPTION_VALUE |
---|---|---|
partition_expiration_days |
FLOAT64 |
La durata predefinita, in giorni, di tutte le partizioni in una tabella partizionata |
expiration_timestamp |
TIMESTAMP |
L'ora di scadenza della tabella |
kms_key_name |
STRING |
Il nome della chiave Cloud KMS utilizzata per criptare la tabella |
friendly_name |
STRING |
Il nome descrittivo della tabella |
description |
STRING |
Una descrizione della tabella |
labels |
ARRAY<STRUCT<STRING, STRING>> |
Un array di STRUCT che rappresentano le etichette nella tabella |
require_partition_filter |
BOOL |
Se le query sulla tabella richiedono un filtro di partizionamento |
enable_refresh |
BOOL |
Indica se l'aggiornamento automatico è abilitato per una vista materializzata |
refresh_interval_minutes |
FLOAT64 |
Frequenza di aggiornamento di una vista materializzata |
Per le tabelle esterne, sono possibili le seguenti opzioni:
Opzioni | |
---|---|
allow_jagged_rows |
Se Si applica ai dati CSV. |
allow_quoted_newlines |
Se Si applica ai dati CSV. |
bigtable_options |
Richiesto solo quando si crea una tabella esterna Bigtable. Specifica lo schema della tabella esterna Bigtable in formato JSON. Per un elenco delle opzioni di definizione delle tabelle Bigtable, consulta
|
compression |
Il tipo di compressione dell'origine dati. I valori supportati includono:
Si applica ai dati CSV e JSON. |
decimal_target_types |
Determina come convertire un tipo di Esempio: |
description |
Una descrizione di questa tabella. |
enable_list_inference |
Se Si applica ai dati Parquet. |
enable_logical_types |
Se Si applica ai dati Avro. |
encoding |
La codifica dei caratteri dei dati. I valori supportati includono:
Si applica ai dati CSV. |
enum_as_string |
Se Si applica ai dati Parquet. |
expiration_timestamp |
L'ora di scadenza della tabella. Se non specificato, la tabella non ha scadenza. Esempio: |
field_delimiter |
Il separatore per i campi in un file CSV. Si applica ai dati CSV. |
format |
Il formato dei dati esterni.
I valori supportati per
I valori supportati per
Il valore |
hive_partition_uri_prefix |
Un prefisso comune per tutti gli URI di origine prima dell'inizio della codifica della chiave di partizione. Si applica solo alle tabelle esterne partizionate hive. Si applica ai dati Avro, CSV, JSON, Parquet e ORC. Esempio: |
file_set_spec_type |
Specifica come interpretare gli URI di origine per i job di caricamento e le tabelle esterne. In anteprima. I valori supportati includono:
Ad esempio, se hai un URI di origine di |
ignore_unknown_values |
Se Si applica ai dati CSV e JSON. |
json_extension |
Per i dati JSON, indica un particolare formato di interscambio JSON. Se non specificato, BigQuery legge i dati come record JSON generici. I valori supportati includono: |
max_bad_records |
Il numero massimo di record non validi da ignorare durante la lettura dei dati. Si applica a: dati CSV, JSON e Fogli Google. |
max_staleness |
Applicabile per tabelle BigLake e tabelle di oggetti. Specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella e la frequenza di aggiornamento dei metadati memorizzati nella cache affinché l'operazione li utilizzi. Per disattivare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita. Per abilitare la memorizzazione nella cache dei metadati, specifica un valore
letterale a intervalli
compreso tra 30 minuti e 7 giorni. Ad esempio, specifica |
metadata_cache_mode |
Applicabile per tabelle BigLake e tabelle di oggetti. Specifica se la cache dei metadati per la tabella viene aggiornata automaticamente o manualmente. Imposta Imposta il valore Devi impostare |
null_marker |
La stringa che rappresenta i valori Si applica ai dati CSV. |
object_metadata |
Richiesto solo quando si crea una tabella degli oggetti. Imposta il valore di questa opzione su |
preserve_ascii_control_characters |
Se Si applica ai dati CSV. |
projection_fields |
Un elenco di proprietà delle entità da caricare. Si applica ai dati di Datastore. |
quote |
La stringa utilizzata per citare le sezioni di dati in un file CSV. Se i dati contengono caratteri di nuova riga tra virgolette, imposta anche la proprietà Si applica ai dati CSV. |
reference_file_schema_uri |
File di riferimento fornito dall'utente con lo schema della tabella. Si applica ai dati Parquet/ORC/AVRO. Esempio: |
require_hive_partition_filter |
Se Si applica ai dati Avro, CSV, JSON, Parquet e ORC. |
sheet_range |
Intervallo di un foglio di lavoro di Fogli Google da cui eseguire la query. Si applica ai dati di Fogli Google. Esempio: |
skip_leading_rows |
Il numero di righe nella parte superiore di un file da saltare durante la lettura dei dati. Si applica ai dati CSV e Fogli Google. |
uris |
Per le tabelle esterne, incluse le tabelle degli oggetti, che non sono tabelle Bigtable:
Un array di URI completi per le posizioni dei dati esterni.
Ogni URI può contenere un carattere jolly asterisco ( I seguenti esempi mostrano valori
Per le tabelle Bigtable:
L'URI che identifica la tabella Bigtable da utilizzare come origine dati. Puoi specificare un solo URI Bigtable. Esempio:
Per maggiori informazioni sulla creazione di un URI di Bigtable, consulta Recupero dell'URI di Bigtable. |
Esempi
Esempio 1:
L'esempio seguente recupera la scadenza predefinita delle tabelle per tutte le tabelle in mydataset
nel progetto predefinito (myproject
) eseguendo una query sulla vista INFORMATION_SCHEMA.TABLE_OPTIONS
.
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
.
SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS WHERE option_name = 'expiration_timestamp';
Il risultato è simile al seguente:
+----------------+---------------+------------+----------------------+-------------+--------------------------------------+ | table_catalog | table_schema | table_name | option_name | option_type | option_value | +----------------+---------------+------------+----------------------+-------------+--------------------------------------+ | myproject | mydataset | mytable1 | expiration_timestamp | TIMESTAMP | TIMESTAMP "2020-01-16T21:12:28.000Z" | | myproject | mydataset | mytable2 | expiration_timestamp | TIMESTAMP | TIMESTAMP "2021-01-01T21:12:28.000Z" | +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
Esempio 2:
L'esempio seguente recupera i metadati su tutte le tabelle in mydataset
che contengono dati di test. La query utilizza i valori nell'opzione description
per trovare tabelle che contengono "test" in qualsiasi punto della descrizione. mydataset
si trova nel tuo
progetto predefinito: myproject
.
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
.
SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS WHERE option_name = 'description' AND option_value LIKE '%test%';
Il risultato è simile al seguente:
+----------------+---------------+------------+-------------+-------------+--------------+ | table_catalog | table_schema | table_name | option_name | option_type | option_value | +----------------+---------------+------------+-------------+-------------+--------------+ | myproject | mydataset | mytable1 | description | STRING | "test data" | | myproject | mydataset | mytable2 | description | STRING | "test data" | +----------------+---------------+------------+-------------+-------------+--------------+
COLUMNS
visualizzazione
Quando esegui una query sulla vista INFORMATION_SCHEMA.COLUMNS
, i risultati della query contengono una riga per ogni colonna (campo) in una tabella.
La vista INFORMATION_SCHEMA.COLUMNS
ha il seguente schema:
Nome colonna | Tipo di dati | Valore |
---|---|---|
TABLE_CATALOG |
STRING |
L'ID del progetto che contiene il set di dati |
TABLE_SCHEMA |
STRING |
Il nome del set di dati che contiene la tabella, indicato anche come datasetId |
TABLE_NAME |
STRING |
Il nome della tabella o della vista, denominato anche tableId |
COLUMN_NAME |
STRING |
Il nome della colonna |
ORDINAL_POSITION |
INT64 |
L'offset indicizzato di 1 della colonna all'interno della tabella. Se si tratta di una pseudo colonna come _PARTITIONTIME o _PARTITIONDATE, il valore è NULL |
IS_NULLABLE |
STRING |
YES o NO a seconda che la modalità della colonna
consenta i valori NULL |
DATA_TYPE |
STRING |
Il tipo di dati GoogleSQL della colonna |
IS_GENERATED |
STRING |
Il valore è sempre NEVER |
GENERATION_EXPRESSION |
STRING |
Il valore è sempre NULL |
IS_STORED |
STRING |
Il valore è sempre NULL |
IS_HIDDEN |
STRING |
YES o NO a seconda che si tratti di una pseudo colonna, come _PARTITIONTIME o _PARTITIONDATE |
IS_UPDATABLE |
STRING |
Il valore è sempre NULL |
IS_SYSTEM_DEFINED |
STRING |
YES o NO a seconda che si tratti di una pseudo colonna, come _PARTITIONTIME o _PARTITIONDATE |
IS_PARTITIONING_COLUMN |
STRING |
YES o NO a seconda che la colonna sia
o meno una colonna di partizionamento |
CLUSTERING_ORDINAL_POSITION |
INT64 |
L'offset indicizzato di 1 della colonna all'interno delle colonne di clustering della tabella; il valore è NULL se la tabella non è una tabella in cluster |
COLLATION_NAME |
STRING |
Il nome della specifica di confronto, se esistente. In caso contrario, NULL Se viene trasmesso STRING o ARRAY<STRING> , viene restituita la specifica delle regole di confronto, se esistente; in caso contrario,
viene restituito NULL
|
COLUMN_DEFAULT |
STRING |
Il valore predefinito della colonna, se esistente. In caso contrario, il valore è NULL .
|
ROUNDING_MODE |
STRING |
La modalità di arrotondamento utilizzata per i valori scritti nel campo se il tipo è NUMERIC o BIGNUMERIC con parametri; altrimenti il valore è NULL
|
Esempi
L'esempio seguente recupera i metadati dalla vista INFORMATION_SCHEMA.COLUMNS
per la tabella population_by_zip_2010
nel set di dati census_bureau_usa
. Questo set di dati fa parte del programma di set di dati pubblici di BigQuery.
Poiché la tabella su cui stai eseguendo una query si trova in un altro progetto, il progetto bigquery-public-data
, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; ad esempio, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
.
Le seguenti colonne sono escluse dai risultati della query perché sono attualmente riservate per un uso futuro:
IS_GENERATED
GENERATION_EXPRESSION
IS_STORED
IS_UPDATABLE
SELECT * EXCEPT(is_generated, generation_expression, is_stored, is_updatable) FROM `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS WHERE table_name = 'population_by_zip_2010';
Il risultato è simile al seguente. Per la leggibilità, alcune colonne sono escluse dal risultato.
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+ | table_name | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position | +------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+ | population_by_zip_2010 | zipcode | 1 | NO | STRING | NO | NO | NO | NULL | | population_by_zip_2010 | geo_id | 2 | YES | STRING | NO | NO | NO | NULL | | population_by_zip_2010 | minimum_age | 3 | YES | INT64 | NO | NO | NO | NULL | | population_by_zip_2010 | maximum_age | 4 | YES | INT64 | NO | NO | NO | NULL | | population_by_zip_2010 | gender | 5 | YES | STRING | NO | NO | NO | NULL | | population_by_zip_2010 | population | 6 | YES | INT64 | NO | NO | NO | NULL | +------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
COLUMN_FIELD_PATHS
visualizzazione
Quando esegui una query sulla vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
, i risultati della query contengono una riga per ogni colonna nidificata all'interno di una colonna RECORD
(o STRUCT
).
La vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
ha il seguente schema:
Nome colonna | Tipo di dati | Valore |
---|---|---|
TABLE_CATALOG |
STRING |
L'ID del progetto che contiene il set di dati |
TABLE_SCHEMA |
STRING |
Il nome del set di dati che contiene la tabella, indicato anche come datasetId |
TABLE_NAME |
STRING |
Il nome della tabella o della vista, denominato anche tableId |
COLUMN_NAME |
STRING |
Il nome della colonna |
FIELD_PATH |
STRING |
Il percorso di una colonna nidificata all'interno di una colonna "RECORD" o "STRUCT" |
DATA_TYPE |
STRING |
Il tipo di dati GoogleSQL della colonna |
DESCRIPTION |
STRING |
La descrizione della colonna |
COLLATION_NAME |
STRING |
Il nome della specifica di confronto, se esistente. In caso contrario, NULL Se viene trasmesso un campo STRING , ARRAY<STRING> o
STRING in un STRUCT , viene restituita la
specifica delle regole di confronto, se esistente; in caso contrario, viene restituito
NULL
|
ROUNDING_MODE |
STRING |
La modalità di arrotondamento utilizzata quando si applicano precisione e scala ai valori NUMERIC o BIGNUMERIC parametrizzati; altrimenti il valore è NULL
|
Esempi
L'esempio seguente recupera i metadati dalla vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
per la tabella commits
nel set di dati github_repos
.
Questo set di dati fa parte del programma di set di dati pubblici di BigQuery.
Poiché la tabella su cui stai eseguendo una query si trova in un altro progetto, il progetto bigquery-public-data
, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; ad esempio, `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
.
La tabella commits
contiene le seguenti colonne nidificate, nidificate e ripetute:
author
: colonnaRECORD
nidificatacommitter
: colonnaRECORD
nidificatatrailer
: colonnaRECORD
nidificata e ripetutadifference
: colonnaRECORD
nidificata e ripetuta
Per visualizzare i metadati relativi alle colonne author
e difference
, esegui la query riportata di seguito.
SELECT * FROM `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS WHERE table_name = 'commits' AND (column_name = 'author' OR column_name = 'difference');
Il risultato è simile al seguente. Per la leggibilità, alcune colonne sono escluse dal risultato.
+------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+ | table_name | column_name | field_path | data_type | description | +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+ | commits | author | author | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP> | NULL | | commits | author | author.name | STRING | NULL | | commits | author | author.email | STRING | NULL | | commits | author | author.time_sec | INT64 | NULL | | commits | author | author.tz_offset | INT64 | NULL | | commits | author | author.date | TIMESTAMP | NULL | | commits | difference | difference | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL | | commits | difference | difference.old_mode | INT64 | NULL | | commits | difference | difference.new_mode | INT64 | NULL | | commits | difference | difference.old_path | STRING | NULL | | commits | difference | difference.new_path | STRING | NULL | | commits | difference | difference.old_sha1 | STRING | NULL | | commits | difference | difference.new_sha1 | STRING | NULL | | commits | difference | difference.old_repo | STRING | NULL | | commits | difference | difference.new_repo | STRING | NULL | +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
TABLE_STORAGE
visualizzazione
Le viste TABLE_STORAGE
e TABLE_STORAGE_BY_ORGANIZATION
hanno 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" |
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.
Apri la pagina BigQuery nella console Google Cloud.
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;
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 |
Elenco delle tabelle in un set di dati
Puoi elencare le tabelle nei set di dati nei seguenti modi:
- Utilizzo della console Google Cloud.
- Utilizzando il comando a riga di comando bq
bq ls
. - Chiamata al metodo API
tables.list
. - Utilizzo delle librerie client.
Autorizzazioni obbligatorie
Per elencare le tabelle in un set di dati, devi disporre almeno delle autorizzazioni bigquery.tables.list
. I seguenti ruoli IAM predefiniti includono le autorizzazioni bigquery.tables.list
:
bigquery.user
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataEditor
bigquery.dataOwner
bigquery.admin
Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.
Elenca tabelle
Per elencare le tabelle in un set di dati:
Console
Nel riquadro di navigazione della console Google Cloud, fai clic sul set di dati per espanderlo. Vengono visualizzate le tabelle e le viste nel set di dati.
Scorri l'elenco per visualizzare le tabelle nel set di dati. Le tabelle e le visualizzazioni sono identificate da icone diverse.
bq
-
Nella console Google Cloud, attiva Cloud Shell.
Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.
Esegui il comando
bq ls
. Il flag--format
può essere usato per controllare l'output. Se stai elencando le tabelle in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato:project_id:dataset
.I flag aggiuntivi includono:
--max_results
o-n
: un numero intero che indica il numero massimo di risultati. Il valore predefinito è50
.
bq ls \ --format=pretty \ --max_results integer \ project_id:dataset
Dove:
- integer è un numero intero che rappresenta il numero di tabelle da elencare.
- project_id è l'ID progetto.
- dataset è il nome del set di dati.
Quando esegui il comando, nel campo
Type
viene visualizzatoTABLE
oVIEW
. Ad esempio:+-------------------------+-------+----------------------+-------------------+ | tableId | Type | Labels | Time Partitioning | +-------------------------+-------+----------------------+-------------------+ | mytable | TABLE | department:shipping | | | myview | VIEW | | | +-------------------------+-------+----------------------+-------------------+
Esempi:
Inserisci il comando seguente per elencare le tabelle nel set di dati
mydataset
nel progetto predefinito.bq ls --format=pretty mydataset
Inserisci il seguente comando per restituire un output superiore all'output predefinito di 50 tabelle da
mydataset
.mydataset
è nel tuo progetto predefinito.bq ls --format=pretty --max_results 60 mydataset
Inserisci il comando seguente per elencare le tabelle nel set di dati
mydataset
inmyotherproject
.bq ls --format=pretty myotherproject:mydataset
API
Per elencare le tabelle utilizzando l'API, chiama il metodo tables.list
.
C#
Prima di provare questo esempio, segui le istruzioni di configurazione di C# disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery C#.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Go
Prima di provare questo esempio, segui le istruzioni di configurazione di Go disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Go.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Node.js
Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
PHP
Prima di provare questo esempio, segui le istruzioni di configurazione di PHP disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery PHP.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni di configurazione di Python disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Ruby
Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Ruby.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Sicurezza della tabella
Per controllare l'accesso alle tabelle in BigQuery, consulta Introduzione ai controlli di accesso alle tabelle.
Passaggi successivi
- Per ulteriori informazioni sui set di dati, consulta la pagina Introduzione ai set di dati.
- Per ulteriori informazioni sulla gestione dei dati delle tabelle, vedi Gestione dei dati delle tabelle.
- Per saperne di più su come specificare gli schemi delle tabelle, consulta Specifica di uno schema.
- Per ulteriori informazioni sulla modifica degli schemi delle tabelle, consulta Modifica degli schemi delle tabelle.
- Per saperne di più sulla gestione delle tabelle, vedi Gestione delle tabelle.
- Per una panoramica di
INFORMATION_SCHEMA
, vai ad Introduzione a BigQueryINFORMATION_SCHEMA
.
Provalo
Se non hai mai utilizzato Google Cloud, crea un account per valutare le prestazioni di BigQuery in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
Prova BigQuery gratuitamente