Creare e utilizzare tabelle
Questo documento descrive come creare e utilizzare tabelle standard (integrate) in in BigQuery. Per informazioni sulla creazione di altri tipi di tabelle, consulta:
Dopo aver creato una tabella, puoi:
- Controllare l'accesso ai dati della tabella
- Recuperare informazioni sulle tabelle
- Elenca le tabelle in un set di dati
- Recupero metadati tabella
Per ulteriori informazioni sulla gestione delle tabelle, ad esempio l'aggiornamento delle proprietà, la copia e l'eliminazione, consulta Gestire le tabelle.
Prima di iniziare
Prima di creare una tabella in BigQuery:
- Configura un progetto seguendo una guida introduttiva a BigQuery.
- Crea un set di dati BigQuery.
- Se vuoi, leggi Introduzione alle tabelle. per comprendere i limiti delle tabelle, le quote e i prezzi.
Denominazione delle tabelle
Quando crei una tabella in BigQuery, il nome della tabella deve univoci per ogni set di dati. Il nome della tabella può:
- Contenere caratteri con un massimo di 1024 byte UTF-8 in totale.
- Contenere caratteri Unicode nella categoria L (lettera), M (segno), N (numero), Pc (connettore, trattino basso incluso), Pd (trattino), Z (spazio). Per maggiori informazioni le informazioni, vedi Categoria generale.
Di seguito sono riportati tutti esempi di nomi di tabella validi:
table 01
, ग्राहक
, 00_お客様
e étudiant-01
.
Precisazioni:
- Per impostazione predefinita, i nomi delle tabelle sono sensibili alle maiuscole.
mytable
eMyTable
possono coesistono nello stesso set di dati, a meno che non facciano parte di un set di dati con sensibilità alle maiuscole disattivata. - Alcuni nomi di tabella e prefissi di nomi di tabelle sono riservati. Se viene visualizzato un messaggio di errore che indica che il nome o il prefisso della tabella è riservato, seleziona un nome diverso e riprova.
Se includi più operatori punto (
.
) in una sequenza, gli operatori duplicati vengono rimossi implicitamente.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:
- Uso manuale della console Google Cloud o dello strumento a riga di comando bq
Comando
bq mk
. - Chiamando
tables.insert
in modo programmatico API. - Utilizzando le librerie client.
- Dai risultati della query.
- definendo una tabella che fa riferimento a un'origine dati esterna.
- Quando carichi i dati.
- Utilizzando un
CREATE TABLE
l'istruzione DDL (Data Definition Language).
Autorizzazioni obbligatorie
Per creare una tabella, devi disporre delle seguenti autorizzazioni IAM:
bigquery.tables.create
bigquery.tables.updateData
bigquery.jobs.create
Inoltre, potresti aver bisogno dell'autorizzazione bigquery.tables.getData
per
accedere ai dati che scrivi 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 sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Ruoli e autorizzazioni 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 in linea 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
delle API.
Per ulteriori informazioni su come specificare uno schema di tabella, consulta la sezione Specifica di uno schema.
Dopo aver creato la tabella, puoi caricare i dati o compilarlo scrivendo i risultati della query che le sono assegnati.
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 e 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 creare il tabella.
- Nel campo Tabella, inserisci il nome della tabella da creare.
- Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
- Nella sezione Schema, inserisci lo schema.
definizione di Kubernetes.
Puoi inserire le informazioni sullo schema manualmente utilizzando uno dei seguenti
utilizza i seguenti metodi:
- Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di
un array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando la stessa procedura utilizzata per creare un file di schema JSON.
Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo quanto segue:
:
bq show --format=prettyjson dataset.table
- Opzione 2: fai clic su Tipo, e Modalità. Aggiungi campo e inserisci lo schema della tabella. Specifica il Nome di ogni campo,
- Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di
un array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando la stessa procedura utilizzata per creare un file di schema JSON.
Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo quanto segue:
:
- (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, vedi Creazione di tabelle partizionate e Creazione e utilizzo di tabelle in cluster.
- (Facoltativo) Nella sezione Opzioni avanzate, se vuoi utilizzare una di crittografia gestita dal cliente, quindi seleziona la casella Utilizza una chiave di crittografia gestita dal cliente chiave di crittografia (CMEK). Per impostazione predefinita, BigQuery cripta i contenuti archiviati inattivi dei clienti mediante una chiave di proprietà di 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
-
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Usa il comando
bq mk
con il flag--table
o-t
. Puoi fornire una tabella le informazioni sullo schema inline o con un file di schema JSON. Per un elenco completo vedi i parametri Riferimentobq mk --table
. Alcuni 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 dimostrate qui. Per saperne di più, consulta i seguenti link su questi parametri facoltativi:- Per ulteriori informazioni su
--time_partitioning_field
,--time_partitioning_type
e--range_partitioning
, consulta le tabelle partizionate. - Per ulteriori informazioni su
--clustering_fields
, vedi tabelle in cluster. - Per ulteriori informazioni su
--destination_kms_key
, vedi chiavi di crittografia gestite dal cliente.
Se crei 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 \ --add_tags=key_3:value_3[,...] \ project_id:dataset.table \ schema
Sostituisci quanto segue:
- integer è la durata predefinita (in secondi) della tabella. La il valore minimo è 3600 secondi (un'ora). La scadenza viene valutata come l'ora UTC corrente più il valore intero. Se imposti il parametro scadenza quando crei una tabella, la tabella predefinita 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.
- key_3:value_3 sono coppie chiave-valore che specificano i tag. Aggiungi più tag nel tag lo stesso flag con virgole tra coppie chiave:valore.
- 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 in linea nel formato field:data_type,field:data_type o il percorso dello schema JSON sul tuo computer locale.
Quando specifichi lo schema sulla riga di comando, non puoi includere un tipo
RECORD
(STRUCT
), una descrizione della colonna e non puoi specificare la modalità della colonna. Tutte le modalità predefinite sono:NULLABLE
. Per includere le descrizioni, e i tipi diRECORD
, fornisci un file di schema JSON .Esempi:
Inserisci il seguente comando per creare una tabella utilizzando una definizione di schema in linea. 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 suorganization:development
. Il comando usa la scorciatoia-t
anziché--table
. Lo schema viene 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 crea una tabella denominata
mytable
inmydataset
nel browser progetto. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione suThis is my table
e l'etichetta 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 seguente comando 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 suThis is my table
e l'etichetta 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
Una volta creata la tabella, puoi aggiornarne la scadenza, la descrizione e le etichette. Puoi anche modificare la definizione dello schema.
Terraform
Utilizza la
google_bigquery_table
risorsa.
Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Creare una tabella
Il seguente esempio crea una tabella denominata mytable
:
Creare una tabella e concedere l'accesso
L'esempio seguente crea una tabella denominata mytable
, quindi utilizza il metodo
Risorsa google_bigquery_table_iam_policy
da concedere
per accedervi. Esegui questo passaggio solo se vuoi concedere l'accesso
alla tabella alle entità che non hanno accesso al set di dati in cui
della tabella.
Crea una tabella con una chiave di crittografia gestita dal cliente
L'esempio seguente crea una tabella denominata mytable
e utilizza anche
google_kms_crypto_key
e
google_kms_key_ring
per specificare
Chiave Cloud Key Management Service per
tabella. Devi
abilita l'API Cloud Key Management Service prima di eseguire questo esempio.
Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.
Prepara Cloud Shell
- Avvia Cloud Shell.
-
Imposta il progetto Google Cloud predefinito dove vuoi applicare le configurazioni Terraform.
Devi eseguire questo comando una sola volta per progetto e puoi farlo in qualsiasi directory.
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
Le variabili di ambiente vengono sostituite se imposti valori espliciti in Terraform di configurazione del deployment.
Prepara la directory
Ogni file di configurazione Terraform deve avere una directory (inoltre chiamato modulo principale).
-
In Cloud Shell, crea una directory e un nuovo
all'interno di quella directory. Il nome file deve avere l'estensione
.tf
, ad esempiomain.tf
. In questo tutorial, il file è denominatomain.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 di esempio nel file
main.tf
appena creato.Facoltativamente, copia il codice da GitHub. Opzione consigliata quando 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
-upgrade
:terraform init -upgrade
Applica le modifiche
-
Rivedi la configurazione e verifica che le risorse che Terraform creerà o
che l'aggiornamento soddisfi le tue aspettative:
terraform plan
Apporta le correzioni necessarie alla configurazione.
-
Applica la configurazione Terraform eseguendo questo comando e inserendo
yes
alla richiesta:terraform apply
Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". per creare un nuovo messaggio email.
- Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.
API
Chiama il tables.insert
con una risorsa di tabella definita.
C#
Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API C# BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.
Vai
Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Node.js
Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
PHP
Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Ruby
Prima di provare questo esempio, segui le istruzioni per la configurazione di Ruby nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Ruby BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Crea una tabella vuota senza una definizione di schema
Java
Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Creare una tabella da un risultato di 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 vuoi creare la tabella e poi scegli un ID tabella.
Nella sezione Preferenza di scrittura per la tabella di destinazione, scegli una delle le seguenti:
- Scrive se vuota: scrive i risultati della query nella tabella solo se la tabella è vuota.
- Aggiungi alla tabella: aggiunge i risultati della query a una tabella esistente.
- Sovrascrivi tabella: sovrascrive una tabella esistente con lo stesso utilizzando i risultati della query.
(Facoltativo) Per Località dei dati, scegli la tua posizione.
Per aggiornare le impostazioni della query, fai clic su Salva.
Fai clic su Esegui. In questo modo viene creato un job di query che scrive dei risultati della query alla tabella specificata.
In alternativa, se dimentichi di specificare una tabella di destinazione prima di eseguire la query, puoi copiare la tabella dei risultati memorizzati nella cache in una tabella permanente facendo clic sul pulsante Salva risultati sopra l'editor.
SQL
L'esempio seguente utilizza il metodo
Dichiarazione CREATE TABLE
per creare la tabella trips
dai dati pubblici
Tabella bikeshare_trips
:
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'editor di 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 ulteriori informazioni, vedi Creazione di una nuova tabella da una tabella esistente.
bq
-
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Inserisci il valore
bq query
e specifica il flag--destination_table
creare una tabella permanente in base ai risultati della query. Specificause_legacy_sql=false
per usare la sintassi GoogleSQL. Per scrivere la query a una tabella che non è 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 su località.Per controllare l'istruzione 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 sono 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 per elaborare la query. Il flag--location
è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il flag suasia-northeast1
. Puoi impostare un valore predefinito per la località: utilizzando File.bigqueryrc
.project_id
è l'ID progetto.dataset
è il nome del set di dati che contiene la tabella in cui stai scrivendo i risultati della query.table
è il nome della tabella a cui stai scrivere i risultati della query.query
è una query con la sintassi GoogleSQL.Se non viene specificato alcun flag di disposizione di scrittura, il comportamento predefinito è scrivi i risultati nella tabella solo se è vuota. Se la tabella esiste e non è vuota, viene restituito il seguente errore:
BigQuery error in query operation: Error processing 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 denominato
mytable
inmydataset
. Il set di dati si trova nel progetto predefinito. Poiché nel comando non viene specificato alcun flag di disposizione di scrittura, la tabella deve essere nuovo o vuoto. In caso contrario, viene restituito un erroreAlready exists
. La query recupera i dati dal set di dati pubblico Name Data USA.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 comando seguente per utilizzare i risultati della query per sovrascrivere una destinazione tabella denominata
mytable
inmydataset
. Il set di dati è quello predefinito progetto. Il comando utilizza il flag--replace
per sovrascrivere la destinazione tabella.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 accodare i risultati della query a una tabella di destinazione
mytable
inmydataset
. Il set di dati si trova inmy-other-project
, non il progetto predefinito. Il comando usa il flag--append_table
per aggiungere i risultati della query nella 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 per ciascuno di questi esempi è simile al seguente. Per la leggibilità elevata, 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, richiama il metodo
jobs.insert
,
configura un job query
e includi un valore per destinationTable
proprietà. per controllare l'istruzione di scrittura per una destinazione esistente.
configura la proprietà writeDisposition
.
Per controllare il percorso di elaborazione del job di query, specifica location
nella sezione jobReference
della risorsa job.
Vai
Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di BigQuery. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.
Per salvare i risultati della query in una tabella permanente, imposta la tabella di destinazione sul TableId desiderato in un QueryJobConfiguration.
Node.js
Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo delle librerie client di BigQuery. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.
Per salvare i risultati della query in una tabella permanente, crea un'istanza QueryJobConfig e imposta destinazione al TableReference. Passa la configurazione del job al metodo query.Crea una tabella che fa riferimento a un'origine dati esterna
Un'origine dati esterna è un'origine dati su cui puoi eseguire query direttamente in BigQuery, anche se i dati non vengono archiviati di archiviazione BigQuery. Ad esempio, potresti avere dati in una un database Google Cloud diverso, nei file di Cloud Storage o in un prodotto cloud completamente diverso da analizzare a BigQuery, ma che non è tutto pronto per la migrazione.
Per ulteriori informazioni, consulta Introduzione alle origini dati esterne.
Creare una tabella quando carichi i dati
Quando carichi i dati in BigQuery, puoi caricarli in un nuovo una tabella o una partizione, puoi aggiungere dati a una tabella o a una partizione esistente oppure puoi sovrascrivere una tabella o una partizione. Non è necessario creare un campo vuoto prima di caricare i dati. Puoi creare la nuova tabella e caricare contemporaneamente.
Quando carichi i dati in BigQuery, puoi fornire lo schema della tabella o della 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.
Controllare l'accesso alle tabelle
Per configurare l'accesso a tabelle e viste, puoi concedere a ruolo IAM a un'entità ai seguenti livelli, elencati in ordine delle risorse consentite (dalla più grande alla più piccola):
- ad alto livello Gerarchia delle risorse di Google Cloud ad esempio a livello di progetto, cartella o organizzazione
- a livello del set di dati
- il livello della tabella o della visualizzazione
Puoi anche limitare l'accesso ai dati all'interno delle tabelle utilizzando quanto segue: metodo:
L'accesso con qualsiasi risorsa protetta da IAM è cumulativo. Per Ad esempio, se un'entità non ha accesso ad alto livello, come un progetto, puoi concedere l'accesso all'entità a livello del set di dati, dopodiché hanno accesso alle tabelle e alle visualizzazioni del set di dati. Analogamente, se l'entità non ha accesso a livello generale o del set di dati, puoi concedere accesso alle entità a livello di tabella o vista.
Concessione di ruoli IAM a un livello superiore in Google Cloud gerarchia delle risorse a livello di progetto, cartella o organizzazione, concede all'entità l'accesso a un di un'ampia gamma di risorse. Ad esempio, l'assegnazione di un ruolo a un'entità a livello di progetto assegna a quell'entità le autorizzazioni che si applicano a tutti i set di dati del progetto.
La concessione di un ruolo a livello di set di dati specifica le operazioni a cui è soggetta un'entità possono essere eseguite su tabelle e viste in quello specifico set di dati, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione 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à è autorizzata a eseguire su tabelle e viste specifiche, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dell'accesso a livello di tabella di controllo, consulta Controllo dell'accesso a tabelle e viste.
Puoi anche creare ruoli IAM personalizzati. Se crei un ruolo personalizzato, le autorizzazioni che concedi dipendono dall'impostazione le operazioni che deve essere eseguita dall'entità.
Non puoi impostare un rifiuto su qualsiasi risorsa protetta o IAM.
Per ulteriori informazioni su ruoli e autorizzazioni, consulta la sezione Informazioni sui ruoli. nella documentazione di IAM e BigQuery Ruoli e autorizzazioni IAM.
Visualizzare informazioni sulle tabelle
Puoi ottenere informazioni o metadati sulle tabelle nei seguenti modi:
- Utilizzo della console Google Cloud.
- Utilizzo dello strumento a riga di comando bq
Comando
bq show
. - Chiamata a
tables.get
API. - Utilizzo delle librerie client.
- Esecuzione di query sulle viste
INFORMATION_SCHEMA
(beta).
Autorizzazioni obbligatorie
Per ottenere informazioni sulle tabelle, devi disporre almeno della licenza
bigquery.tables.get
autorizzazioni. Le impostazioni IAM predefinite
i ruoli includono bigquery.tables.get
autorizzazioni:
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
bigquery.admin
Inoltre, se un utente dispone delle autorizzazioni bigquery.datasets.create
, quando
crea un set di dati e gli viene concesso l'accesso bigquery.dataOwner
.
L'accesso bigquery.dataOwner
offre all'utente la possibilità di recuperare la tabella
metadati.
Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.
Recupera informazioni tabella
Per ottenere informazioni sulle tabelle:
Console
Nel riquadro di navigazione, nella sezione Risorse, espandi il progetto e seleziona un set di dati.
Fai clic sul nome del set di dati per espanderlo. Le tabelle e le viste del set di dati vengono visualizzate.
Fai clic sul nome della tabella.
Nel riquadro Dettagli, fai clic su Dettagli per visualizzare i dati della tabella. la descrizione e le informazioni della tabella.
Se vuoi, passa alla scheda Schema per visualizzare lo schema della tabella. definizione di Kubernetes.
bq
-
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Esegui il comando
bq show
per visualizzare tutte le informazioni della tabella. Utilizza il flag--schema
per visualizzare solo le informazioni sullo schema della tabella.--format
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 nel progetto predefinito.bq show --format=prettyjson myotherproject:mydataset.mytable
Inserisci il comando seguente per visualizzare solo le informazioni sullo schema
mytable
amydataset
.mydataset
si trova inmyotherproject
, non in tuo progetto predefinito.bq show --schema --format=prettyjson myotherproject:mydataset.mytable
API
Chiama il metodo tables.get
e fornisci eventuali parametri pertinenti.
Vai
Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.
Node.js
Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.
Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
PHP
Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.
Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Ottieni informazioni della tabella utilizzando INFORMATION_SCHEMA
INFORMATION_SCHEMA
è una serie di visualizzazioni che forniscono accesso ai metadati
su set di dati, routine, tabelle, viste, job, prenotazioni e flussi di dati.
Per ottenere informazioni sulle tabelle, puoi eseguire query sulle seguenti viste:
- Utilizza
INFORMATION_SCHEMA.TABLES
eINFORMATION_SCHEMA.TABLE_OPTIONS
per recuperare i metadati relativi alle tabelle e alle viste di un progetto. - Utilizza
INFORMATION_SCHEMA.COLUMNS
eINFORMATION_SCHEMA.COLUMN_FIELD_PATHS
viste per recuperare i metadati sulla colonne (campi) in una tabella. - Utilizza le viste
INFORMATION_SCHEMA.TABLE_STORAGE
per recuperare i metadati sull'utilizzo attuale e storico dello spazio di archiviazione in base a una tabella.
Le viste TABLES
e TABLE_OPTIONS
contengono anche
informazioni sulle viste. Per informazioni dettagliate, esegui una query
INFORMATION_SCHEMA.VIEWS
visualizzazione
.
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 su
viste, esegui una query sul INFORMATION_SCHEMA.VIEWS
visualizza invece.
La vista INFORMATION_SCHEMA.TABLES
ha lo schema seguente:
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 contenente la tabella o la visualizzazione. Chiamato anche
come datasetId . |
table_name |
STRING |
Il nome della tabella o della visualizzazione. 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
supporta DML INSERT
Estratti conto |
is_typed |
STRING |
Il valore è sempre NO |
creation_time |
TIMESTAMP |
L'ora di creazione della tabella |
base_table_catalog |
STRING |
Per cloni di tabelle
e gli snapshot delle tabelle,
progetto della tabella di base. Applicabile solo a
tabelle con table_type impostato su CLONE o
SNAPSHOT .
|
base_table_schema |
STRING |
Per cloni di tabelle
e gli snapshot delle tabelle,
il set di dati della tabella di base. Applicabile solo alle tabelle con
table_type impostata 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 impostata su CLONE o
SNAPSHOT . |
snapshot_time_ms |
TIMESTAMP |
Per cloni di tabelle
e gli snapshot delle tabelle,
il momento in cui il clone
o istantanea
è stata eseguita sulla tabella di base per creare questa tabella. Se
tempo di viaggio, questo
contiene il timestamp dello spostamento cronologico. In caso contrario,
Il campo snapshot_time_ms è uguale al
creation_time . Applicabile solo a
tabelle con table_type impostato su CLONE o
SNAPSHOT .
|
replica_source_catalog |
STRING |
Per repliche di viste materializzate, progetto della vista materializzata di base. |
replica_source_schema |
STRING |
Per repliche di viste materializzate, il set di dati della vista materializzata di base. |
replica_source_name |
STRING |
Per repliche di viste materializzate, il nome della vista materializzata di base. |
replication_status |
STRING |
Per
repliche di viste materializzate,
lo stato della replica dalla vista materializzata di base
replica della vista materializzata; uno dei seguenti:
|
replication_error |
STRING |
Se replication_status indica un problema di replica per un
replica della vista materializzata,
replication_error fornisce ulteriori dettagli sul problema. |
ddl |
STRING |
L'istruzione DDL
che può essere utilizzato per ricreare la tabella,
CREATE TABLE
o CREATE VIEW |
default_collation_name |
STRING |
Il nome della specifica di confronto predefinita
se esiste; altrimenti NULL .
|
upsert_stream_apply_watermark |
TIMESTAMP |
Per le tabelle che utilizzano Change Data Capture (CDC), l'ora in cui la riga l'ultima modifica apportata. Per ulteriori informazioni, vedi Monitora l'avanzamento dell'operazione di upsert della tabella. |
Esempi
Esempio 1:
L'esempio seguente recupera i metadati di una tabella per tutte le tabelle nel
set di dati denominato mydataset
. I metadati
restituito per tutti i tipi di tabelle in mydataset
del 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
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 migliorare la leggibilità, alcune colonne 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 di una tabella per tutte le tabelle di tipo CLONE
o SNAPSHOT
dalla visualizzazione INFORMATION_SCHEMA.TABLES
. I metadati restituiti
è per le tabelle in mydataset
nel progetto predefinito.
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi
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 migliorare la leggibilità, alcune colonne 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
da INFORMATION_SCHEMA.TABLES
per la tabella population_by_zip_2010
nel
census_bureau_usa
del set di dati. Questo set di dati fa parte di BigQuery
programma set di dati pubblici.
Poiché la tabella su cui stai eseguendo query si trova in un altro progetto, aggiungi l'ID progetto al set di dati in
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 su
query, esegui una query
INFORMATION_SCHEMA.VIEWS
visualizzazione
.
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 |
Indica il nome del set di dati che contiene la tabella o la vista
come datasetId |
TABLE_NAME |
STRING |
Il nome della tabella o della vista indicato anche come 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 dei valori nella tabella delle opzioni |
Tabella delle opzioni
|
|
|
---|---|---|
|
|
Una descrizione della tabella |
|
|
Indica se l'aggiornamento automatico è abilitato per una vista materializzata |
|
|
L'ora di scadenza della tabella |
|
|
Il nome descrittivo della tabella |
|
|
Il nome della chiave Cloud KMS utilizzata per criptare la tabella |
|
|
Un array di STRUCT che rappresentano le etichette nella tabella |
|
|
La durata predefinita, in giorni, di tutte le partizioni in un tavola |
|
|
Frequenza di aggiornamento di una vista materializzata |
|
|
Se le query sulla tabella richiedono un filtro di partizione |
|
|
Tag collegati a una tabella in un <key, value> con spazio dei nomi a riga di comando. Per ulteriori informazioni, consulta Tag e accesso condizionale. |
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 |
Obbligatorio solo per la creazione di una tabella esterna Bigtable. Specifica lo schema della tabella esterna di Bigtable in formato JSON. Per un elenco delle opzioni di definizione delle tabelle Bigtable, consulta
|
column_name_character_map |
Definisce l'ambito dei caratteri supportati per i nomi delle colonne e la del comportamento di gestione dei caratteri non supportati. I valori supportati includono:
Si applica ai dati CSV e Parquet. |
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 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 specificata, la tabella non scadono. Esempio: |
field_delimiter |
Il separatore per i campi di un file CSV. Si applica ai dati CSV. |
format |
Il formato dei dati esterni.
Valori supportati per
Valori supportati per
Il valore |
hive_partition_uri_prefix |
Un prefisso comune per tutti gli URI di origine prima della codifica della chiave di partizione inizia. Si applica solo alle tabelle esterne partizionate in 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. I valori supportati includono:
Ad esempio, se hai un URI di origine |
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 JSON generico record. 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 Tavoli BigLake e tabelle di oggetti. Specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella e quanto devono essere aggiornati per poter essere utilizzati dall'operazione. Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita. Per abilitare la memorizzazione nella cache dei metadati, specifica
valore letterale intervallo
compreso tra 30 minuti e 7 giorni. Ad esempio, specifica
|
null_marker |
La stringa che rappresenta i valori Si applica ai dati CSV. |
object_metadata |
Obbligatorio solo quando crei un'istanza 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 tuoi dati
contiene caratteri di nuova riga tra virgolette, imposta anche
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 le query. Si applica ai dati di Fogli Google. Esempio: |
skip_leading_rows |
Il numero di righe all'inizio di un file da saltare durante la lettura dell'attributo e i dati di Google Cloud. Si applica ai dati CSV e Fogli Google. |
uris |
Per le tabelle esterne, incluse le tabelle di oggetti, che non sono Tabelle Bigtable:
Un array di URI completi per le posizioni dei dati esterni.
Ogni URI può contenere
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 ulteriori informazioni sulla creazione di una Bigtable URI, consulta Recupero dell'URI Bigtable. |
Esempi
Esempio 1:
L'esempio seguente recupera i tempi di scadenza predefiniti per le tabelle
in mydataset
nel tuo progetto predefinito (myproject
) eseguendo una query
INFORMATION_SCHEMA.TABLE_OPTIONS
visualizzazione.
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi
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
che contengono dati di test. La query utilizza i valori dell'opzione description
per trovare
tabelle che contengono "test" in qualsiasi punto della descrizione. mydataset
è in
progetto predefinito - myproject
.
Per eseguire la query su un progetto diverso da quello predefinito, aggiungi
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 contenente la tabella, chiamato anche
il datasetId |
TABLE_NAME |
STRING |
Il nome della tabella o della vista indicato anche come tableId |
COLUMN_NAME |
STRING |
Il nome della colonna |
ORDINAL_POSITION |
INT64 |
L'offset indicizzato con 1 della colonna all'interno della tabella; se si tratta di uno pseudo
colonna come _PARTITIONTIME o _PARTITIONDATE, il valore è
NULL |
IS_NULLABLE |
STRING |
YES o NO a seconda che la colonna
consente NULL valori |
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 la colonna sia
una pseudocolonna come _PARTITIONTIME o _PARTITIONDATE |
IS_UPDATABLE |
STRING |
Il valore è sempre NULL |
IS_SYSTEM_DEFINED |
STRING |
YES o NO a seconda che la colonna sia
una pseudocolonna come _PARTITIONTIME o _PARTITIONDATE |
IS_PARTITIONING_COLUMN |
STRING |
YES o NO a seconda che la colonna sia
una colonna di partizionamento |
CLUSTERING_ORDINAL_POSITION |
INT64 |
L'offset con indice 1 della colonna all'interno delle colonne di clustering della tabella. Il valore è NULL se la tabella non è una tabella raggruppata |
COLLATION_NAME |
STRING |
Il nome della specifica di confronto
se esiste; altrimenti NULL Se viene superato un valore STRING o ARRAY<STRING>
la specifica delle regole di confronto viene restituita, se esistente; altrimenti
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 è con parametri NUMERIC o BIGNUMERIC ;
altrimenti il valore è NULL
|
Esempi
L'esempio seguente recupera i metadati dall'INFORMATION_SCHEMA.COLUMNS
per la tabella population_by_zip_2010
nel
census_bureau_usa
:
del set di dati. Questo set di dati fa parte del programma per i set di dati pubblici di BigQuery.
Poiché la tabella su cui esegui la 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 riservati per 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 migliorare la leggibilità, alcune colonne 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
, la query
risultati contengono una riga per ogni colonna
nidificati all'interno di 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 contenente la tabella, chiamato anche
il datasetId |
TABLE_NAME |
STRING |
Il nome della tabella o della vista indicato anche come tableId |
COLUMN_NAME |
STRING |
Il nome della colonna |
FIELD_PATH |
STRING |
Il percorso di una colonna nidificato in una colonna "RECORD" o "STRUCT" |
DATA_TYPE |
STRING |
Il codice GoogleSQL della colonna tipo di dati |
DESCRIPTION |
STRING |
La descrizione della colonna |
COLLATION_NAME |
STRING |
Il nome della specifica di confronto
se esiste; altrimenti NULL Se STRING , ARRAY<STRING> o
Viene passato un campo STRING in un STRUCT , il valore
la specifica delle regole di confronto viene restituita, se esistente; altrimenti
Viene restituito NULL
|
ROUNDING_MODE |
STRING |
La modalità di arrotondamento utilizzata quando si applicano precisione e scala a
valori NUMERIC o BIGNUMERIC con parametri;
altrimenti il valore è NULL
|
Esempi
L'esempio seguente recupera i metadati
INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
visualizzazione per la tabella commits
in
github_repos
set di dati.
Questo set di dati fa parte di BigQuery
programma set di dati pubblici.
Poiché la tabella su cui stai eseguendo query si trova in un altro progetto,
bigquery-public-data
, aggiungi l'ID progetto al set di dati nella
seguente formato:
`project_id`.dataset.INFORMATION_SCHEMA.view
;
ad esempio
`bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
.
La tabella commits
contiene i seguenti elementi nidificati, nidificati e ripetuti
colonne:
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 seguente query.
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 migliorare la leggibilità, alcune colonne 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 le seguenti caratteristiche
schema:
Nome colonna | Tipo di dati | Valore |
---|---|---|
PROJECT_ID |
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_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 materializzata,
chiamato anche datasetId . |
TABLE_NAME |
STRING |
Il nome della tabella o della vista materializzata, indicato 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 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) precedenti a 90 giorni. |
CURRENT_PHYSICAL_BYTES |
INT64 |
Numero totale di byte fisici per l'archiviazione attuale del in tutte le partizioni. |
TOTAL_PHYSICAL_BYTES |
INT64 |
Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi i viaggi attivi, a lungo termine e nel tempo (dati eliminati o modificati) byte. Fail-safe (dati eliminati o modificati conservati dopo il viaggio nel tempo) (finestra) byte non sono inclusi. |
ACTIVE_PHYSICAL_BYTES |
INT64 |
Numero di byte fisici (compressi) inferiori a 90 giorni, inclusi i byte relativi ai viaggi nel tempo (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 per l'archiviazione dei viaggi nel tempo (dati eliminati o modificati). |
STORAGE_LAST_MODIFIED_TIME |
TIMESTAMP |
L'ora più recente in cui i dati sono stati scritti nella tabella. |
DELETED |
BOOLEAN |
Indica se la tabella è stata eliminata o meno. |
TABLE_TYPE |
STRING |
Il tipo di tabella. Ad esempio, EXTERNAL o
BASE TABLE .
|
FAIL_SAFE_PHYSICAL_BYTES |
INT64 |
Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione fail-safe (dati eliminati o modificati). |
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 come prevedere la differenza di prezzo per tra modelli di fatturazione logici e fisici per i prossimi 30 giorni. Questo esempio presuppone che l'utilizzo dello spazio di archiviazione futuro sia costante 30 giorni dal momento dell'esecuzione della query. Tieni presente che la previsione è limitata a di base, esclude tutti gli altri tipi di tabelle in 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 un'altra regione,
aggiornare le variabili di prezzo in modo appropriato. Consulta
Prezzi dell'archiviazione per informazioni sui prezzi.
Apri la pagina BigQuery nella console Google Cloud.
Inserisci la seguente query GoogleSQL nella casella Editor query.
INFORMATION_SCHEMA
richiede la sintassi di 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.
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 |
Elenca tabelle in un set di dati
Puoi elencare le tabelle nei set di dati nei seguenti modi:
- Utilizzo della console Google Cloud.
- Utilizzo dello strumento a riga di comando bq
Comando
bq ls
. - Chiamata a
tables.list
API. - Utilizzo delle librerie client.
Autorizzazioni obbligatorie
Come minimo, per elencare le tabelle in un set di dati, devi avere
bigquery.tables.list
autorizzazioni. Le impostazioni IAM predefinite
i ruoli includono bigquery.tables.list
autorizzazioni:
bigquery.user
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataEditor
bigquery.dataOwner
bigquery.admin
Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, vedi Controllo dell'accesso.
Elenca tabelle
Per elencare le tabelle in un set di dati:
Console
Nella console Google Cloud, nel riquadro di navigazione, fai clic sul set di dati per espanderlo. Vengono mostrate le tabelle e le visualizzazioni nel set di dati.
Scorri l'elenco per visualizzare le tabelle nel set di dati. Tabelle e sono identificate da icone diverse.
bq
-
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Emetti
bq ls
. Il flag--format
può essere utilizzato per controllare come 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 che consentono di analizzare i dati e visualizzare i 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, il campo
Type
mostraTABLE
oVIEW
. Ad esempio:+-------------------------+-------+----------------------+-------------------+ | tableId | Type | Labels | Time Partitioning | +-------------------------+-------+----------------------+-------------------+ | mytable | TABLE | department:shipping | | | myview | VIEW | | | +-------------------------+-------+----------------------+-------------------+
Esempi:
Inserisci il seguente comando per elencare le tabelle nel set di dati
mydataset
nel tuo progetto predefinito.bq ls --format=pretty mydataset
Inserisci il comando seguente per restituire un output superiore all'output predefinito (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 tables.list
.
C#
Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API C# BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Vai
Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di BigQuery. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Node.js
Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
PHP
Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Python
Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Ruby
Prima di provare questo esempio, segui le istruzioni di configurazione Ruby riportate nella guida rapida all'utilizzo delle librerie client di BigQuery. Per ulteriori informazioni, consulta API Ruby BigQuery documentazione di riferimento.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.
Sicurezza dei tavoli
Per controllare l'accesso alle tabelle in BigQuery, consulta Introduzione ai controlli di accesso alle tabelle.
Passaggi successivi
- Per saperne di più sui set di dati, consulta Introduzione ai set di dati.
- Per saperne di più sulla gestione dei dati della tabella, vedi Gestire i dati della tabella.
- Per ulteriori informazioni su come specificare gli schemi delle tabelle, consulta la sezione Specifica di uno schema.
- Per saperne di più sulla modifica degli schemi delle tabelle, consulta Modifica degli schemi delle tabelle.
- Per saperne di più sulla gestione delle tabelle, vedi Gestire le tabelle.
- Per una panoramica di
INFORMATION_SCHEMA
, vai a Introduzione a BigQueryINFORMATION_SCHEMA
.
Provalo
Se non hai mai utilizzato Google Cloud, crea un account per valutare in che modo BigQuery funziona nel mondo reale diversi scenari. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
Prova BigQuery gratuitamente