Questa pagina è stata tradotta dall'API Cloud Translation.

Creare e utilizzare tabelle

Questo documento descrive come creare e utilizzare tabelle standard (integrate) 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, tra cui l'aggiornamento delle proprietà delle tabelle, la copia e l'eliminazione di una tabella, 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.
Facoltativamente, consulta Introduzione alle tabelle per comprendere limitazioni, quote e prezzi delle tabelle.

Denominazione delle tabelle

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 massimo di 1024 byte UTF-8 in totale.
Contenere caratteri Unicode nelle categorie L (lettera), M (segno), N (numero), Pc (connettore, incluso il trattino basso), Pd (trattino), Zs (spazio). Per ulteriori informazioni, consulta Categoria generale.

Di seguito sono riportati tutti esempi di nomi di tabella validi: table 01, ग्राहक, 00_お客様, étudiant-01.

Precisazioni:

Per impostazione predefinita, i nomi delle tabelle sono sensibili alle maiuscole. mytable e MyTable 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 tabella e prefissi di nomi di tabelle sono riservati. Se ricevi un errore che indica che il nome o il prefisso della tabella è riservato, seleziona un altro nome e riprova.
Se includi più operatori di punto (.) in una sequenza, gli operatori duplicati vengono eliminati in modo implicito.

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 della query.
definendo una tabella che fa riferimento a un'origine dati esterna.
Quando carichi i dati.
Utilizzando un'istruzione DDL (Data Definition Language) di CREATE TABLE.

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 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'autorizzazione bigquery.jobs.create)
roles/bigquery.user (include l'autorizzazione bigquery.jobs.create)
roles/bigquery.jobUser (include l'autorizzazione bigquery.jobs.create)

Inoltre, se disponi dell'autorizzazione bigquery.datasets.create, puoi creare e aggiornare tabelle nei set di dati che crei.

Per ulteriori informazioni su ruoli e 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 dell'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 al suo interno o completarla scrivendo i risultati della query.

Per creare una tabella vuota con una definizione di schema:

Console

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a 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:
1. In Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
2. Nel campo Tabella, inserisci il nome della tabella da creare.
3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
Nella sezione Schema, inserisci la definizione dello schema. Puoi inserire manualmente le informazioni sullo 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, generi lo schema utilizzando 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 Aggiungi campo e inserisci lo schema della tabella. Specifica Name, Type e Mode di ogni campo.
(Facoltativo) Specifica le impostazioni di partizione e clustering. Per saperne di più, consulta Creazione di tabelle partizionate e Creazione e utilizzo di 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 archiviati inattivi dei clienti utilizzando una chiave di proprietà di Google e 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.

Vai a 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, vedi Eseguire una query interattiva.

bq

Nella console Google Cloud, attiva Cloud Shell.

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 informazioni sullo schema delle tabelle 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 presenti dimostrazioni qui. Per ulteriori informazioni su questi parametri facoltativi, consulta i seguenti link:
- Per ulteriori informazioni su --time_partitioning_field, --time_partitioning_type e --range_partitioning, consulta le tabelle partizionate.
- Per ulteriori informazioni su --clustering_fields, consulta le tabelle in cluster.
- Per maggiori informazioni su --destination_kms_key, consulta la pagina relativa alle 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). La scadenza restituisce l'ora UTC attuale più il valore intero. Se imposti la scadenza quando crei una tabella, l'impostazione di scadenza predefinita per la 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 incorporata nel formato field:data_type,field:data_type, ovvero il percorso del file di schema JSON sulla macchina locale.
Se specifichi lo schema nella riga di comando, non puoi includere un tipo RECORD (STRUCT), non puoi includere una descrizione della colonna e non puoi specificare la modalità della colonna. Tutte le modalità predefinite sono: NULLABLE. Per includere descrizioni, modalità e tipi di RECORD, fornisci 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 in mydataset nel progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta è impostata su organization:development. Il comando usa 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 in mydataset nel tuo progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta è impostata su organization: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 in mydataset in myotherproject. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta è impostata su organization: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 aggiornarne la scadenza, la descrizione e le etichette. Puoi anche modificare la definizione dello schema.

Terraform

Utilizza la risorsa google_bigquery_table.

Per eseguire l'autenticazione in BigQuery, configura le 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:

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

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 concedervi 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.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:raha@altostrat.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.default.policy_data
}

Crea 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. Devi abilitare l'API Cloud Key Management Service prima di eseguire questo esempio.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

Per applicare la tua configurazione Terraform a 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
```
Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.

Prepara la directory

Ogni file di configurazione Terraform deve avere la propria directory (chiamata 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 esempio main.tf. In questo tutorial, il file è denominato main.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 nuovo oggetto main.tf.

Facoltativamente, 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

Esamina la configurazione e verifica che le risorse che Terraform creerà o aggiornerà soddisfino le tue aspettative:
```
terraform plan
```
Apporta le correzioni necessarie alla configurazione.
Applica la configurazione Terraform eseguendo questo comando e inserendo yes al prompt:
```
terraform apply
```
Attendi finché in Terraform non viene visualizzato il messaggio "Applicazione completata!".
Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI 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 per la configurazione di C# nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API C# di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.


using Google.Cloud.BigQuery.V2;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Go

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"time"

	"cloud.google.com/go/bigquery"
)

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(String datasetName, String tableName, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

PHP

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API PHP di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

Prima di provare questo esempio, segui le istruzioni per la configurazione di Ruby nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Ruby di BigQuery.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

Crea una tabella vuota senza una definizione dello schema

Java

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a table without schema
public class CreateTableWithoutSchema {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createTableWithoutSchema(datasetName, tableName);
  }

  public static void createTableWithoutSchema(String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(Schema.of());
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Crea una tabella dal risultato di una query

Per creare una tabella a partire dal risultato di una query, scrivi i risultati in una tabella di destinazione.

Console

Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina di BigQuery
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, quindi scegli un ID tabella.
Nella sezione Preferenza di scrittura per la tabella di destinazione, scegli una delle seguenti opzioni:
- Scrivi se vuoto: 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 memorizzati 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 della tabella bikeshare_trips pubblica:

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a 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, vedi Eseguire una query interattiva.

Per ulteriori informazioni, consulta Creazione di una nuova tabella da una tabella esistente.

bq

Nella console Google Cloud, attiva Cloud Shell.

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 flag use_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 posizione.

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 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 su asia-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 che contiene la tabella in cui vengono scritti i risultati della query.
- table è il nome della tabella in cui stai scrivendo i risultati della query.
- query è una query con la sintassi GoogleSQL.
  
  Se non viene specificato alcun flag di scrittura, il comportamento predefinito prevede di scrivere i 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 durante l'elaborazione del job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.
  
  Esempi:
  
  Nota: questi esempi eseguono query su un set di dati pubblico basato negli Stati Uniti. Poiché il set di dati pubblico è archiviato nella località multiregionale degli Stati Uniti, anche il set di dati che contiene la tabella di destinazione deve trovarsi negli Stati Uniti. Non puoi eseguire query su un set di dati in una località e scrivere i risultati in una tabella di destinazione in un'altra.
  
  Inserisci il comando seguente per scrivere i risultati della query in una tabella di destinazione denominata mytable in mydataset. 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 nuova o vuota. In caso contrario, viene restituito un errore Already 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 al fine di sovrascrivere una tabella di destinazione denominata mytable in mydataset. 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 comando seguente per aggiungere i risultati della query a una tabella di destinazione denominata mytable in mydataset. Il set di dati si trova in my-other-project, non nel progetto predefinito. Il comando usa 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 per ciascuno 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 l'istruzione di scrittura per 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 job.

Go

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

Per eseguire l'autenticazione su 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 TableId desiderato in una QueryJobConfiguration.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \n" + e.toString());
    }
  }
}

Node.js

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

Python

Per eseguire l'autenticazione su 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 QueryJobConfig e imposta la destinazione sul valore TableReference desiderato. Passa la configurazione del job al metodo di query.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

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 di Cloud Storage o in un prodotto cloud completamente diverso che vorresti analizzare in BigQuery, ma che non sei pronto per la 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, aggiungerli a una tabella o partizione esistente oppure sovrascrivere una tabella o una partizione. Non è necessario creare una tabella vuota prima di caricarvi i dati. Puoi creare la nuova tabella e caricare contemporaneamente i dati.

Quando carichi i dati in BigQuery, puoi fornire la tabella o lo schema di partizione oppure, per i formati di dati supportati, puoi utilizzare lo schema di rilevamento automatico.

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 un ruolo IAM a un'entità ai seguenti livelli, elencati in ordine di gamma di risorse consentite (dal più grande al più piccolo):

a livello generale nella gerarchia delle risorse di Google Cloud, come a livello di progetto, cartella o organizzazione
a 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 a livello generale come un progetto, puoi concederle l'accesso a livello del set di dati. In questo modo, l'entità avrà accesso alle tabelle e alle viste nel set di dati. Allo stesso modo, se l'entità non ha accesso a livello generale o del set di dati, puoi concedere l'accesso all'entità a livello di tabella o visualizzazione.

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 ampio insieme di risorse. Ad esempio, la concessione di un ruolo a un'entità a livello di progetto concede a quell'entità le autorizzazioni applicabili a tutti i set di dati nel progetto.

La concessione di un ruolo a livello del set di dati consente di specificare le operazioni consentite a un'entità su tabelle e visualizzazioni in quello specifico 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 consentite a un'entità su tabelle e viste specifiche, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dei controlli dell'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 l'entità deve eseguire.

Non puoi impostare un'autorizzazione "deny" su nessuna risorsa protetta da IAM.

Per ulteriori informazioni su ruoli e autorizzazioni, consulta la sezione Informazioni sui ruoli nella documentazione IAM e in 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.
Utilizzo dello strumento a riga di comando bq bq show.
Chiamata al metodo API tables.get.
Utilizzare le librerie client.
Esecuzione di query sulle viste INFORMATION_SCHEMA (beta).

Autorizzazioni obbligatorie

Come minimo, per ottenere informazioni sulle tabelle devi disporre delle autorizzazioni bigquery.tables.get. 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 dispone delle 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, vedi Controllo dell'accesso.

Recupera informazioni tabella

Per ottenere informazioni sulle tabelle:

Console

Nella sezione Risorse del pannello di navigazione, 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 viste del 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.

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 della tabella. Utilizza il flag --schema per visualizzare solo le informazioni sullo 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 comando seguente per visualizzare tutte le informazioni su mytable in mydataset. mydataset è nel tuo progetto predefinito.
```
bq show --format=prettyjson mydataset.mytable
```
Inserisci il comando seguente per visualizzare tutte le informazioni su mytable in mydataset. mydataset si trova nella cartella myotherproject, non nel tuo progetto predefinito.
```
bq show --format=prettyjson myotherproject:mydataset.mytable
```
Inserisci il comando seguente per visualizzare solo le informazioni sullo schema relative a mytable in mydataset. mydataset si trova nella cartella myotherproject, non nel progetto predefinito.
```
bq show --schema --format=prettyjson myotherproject:mydataset.mytable
```

API

Chiama il metodo tables.get e fornisci i parametri pertinenti.

Go

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	// Print basic information about the table.
	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
	fmt.Fprintf(w, "Description: %s\n", meta.Description)
	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
	return nil
}

Java

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

public class GetTable {

  public static void runGetTable() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery_public_data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    getTable(projectId, datasetName, tableName);
  }

  public static void getTable(String projectId, String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);
      System.out.println("Table info: " + table.getDescription());
    } catch (BigQueryException e) {
      System.out.println("Table not retrieved. \n" + e.toString());
    }
  }
}

Node.js

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

PHP

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
//$projectId = 'The Google project ID';
//$datasetId = 'The BigQuery dataset ID';
//$tableId   = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

Python

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

Ottieni informazioni della tabella utilizzando `INFORMATION_SCHEMA`

INFORMATION_SCHEMA è una serie di viste che forniscono accesso a 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:

Utilizza le viste INFORMATION_SCHEMA.TABLES e INFORMATION_SCHEMA.TABLE_OPTIONS per recuperare i metadati relativi alle tabelle e alle viste di un progetto.
Utilizza le viste INFORMATION_SCHEMA.COLUMNS e INFORMATION_SCHEMA.COLUMN_FIELD_PATHS per recuperare i metadati relativi alle colonne (campi) in una tabella.
Usa le viste INFORMATION_SCHEMA.TABLE_STORAGE per recuperare i metadati sull'utilizzo attuale e storico dell'archiviazione in base a una tabella.

Le viste TABLES e TABLE_OPTIONS contengono anche informazioni generali sulle viste. Per informazioni dettagliate, esegui 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 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 visualizzazione. Chiamato anche `tableId`.
`table_type`	`STRING`	Il tipo di tabella; uno dei seguenti: `BASE TABLE`: una tabella standard `CLONE`: un clone di tabelle `SNAPSHOT`: uno snapshot di tabella `VIEW`: una vista `MATERIALIZED VIEW`: una vista materializzata o replica della vista materializzata `EXTERNAL`: una tabella che fa riferimento a un'origine dati esterna
`is_insertable_into`	`STRING`	`YES` o `NO` a seconda che la tabella supporti o meno 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 tabelle 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 cloni di tabelle e 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 tabelle 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 tabelle e gli snapshot delle tabelle, la data e l'ora in cui l'operazione clone o snapshot è stata eseguita sulla tabella di base per creare questa tabella. Se è stato utilizzato viaggio cronologico, questo campo contiene il timestamp del viaggio cronologico. In caso contrario, il campo `snapshot_time_ms` è uguale 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 della vista materializzata, 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 replica della vista materializzata, lo stato della replica dalla vista materializzata di base a quella della vista materializzata; uno dei seguenti valori: `REPLICATION_STATUS_UNSPECIFIED` `ACTIVE`: la replica è attiva senza errori `SOURCE_DELETED`: la vista materializzata di origine è stata eliminata `PERMISSION_DENIED`: la vista materializzata di origine non è stata autorizzata sul set di dati che contiene le tabelle Amazon S3 BigLake di origine utilizzate nella query che ha creato la vista materializzata. `UNSUPPORTED_CONFIGURATION`: si è verificato un problema con i prerequisiti della replica diversi dall'autorizzazione della vista materializzata di origine.
`replication_error`	`STRING`	Se `replication_status` indica un problema di replica per una replica della 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), la data e l'ora in cui sono state applicate l'ultima modifica delle 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 del progetto predefinito.

mydataset contiene le seguenti tabelle:

mytable1: una tabella BigQuery standard
myview1: 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. Alcune colonne sono escluse dal risultato per migliorarne la leggibilità.

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| 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 si riferiscono alle tabelle in mydataset nel progetto predefinito.

  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. Alcune colonne sono escluse dal risultato per migliorarne la leggibilità.

  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | 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 Public dataset di BigQuery.

Poiché la tabella su cui stai eseguendo 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 visualizzazione in un set di dati. Per informazioni dettagliate sulle viste, esegui 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, indicato anche 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

`OPTION_NAME`	`OPTION_TYPE`	`OPTION_VALUE`
`partition_expiration_days`	`FLOAT64`	La durata predefinita, in giorni, di tutte le partizioni di una tabella partizionata
`expiration_timestamp`	`TIMESTAMP`	L'ora di scadenza di questa 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 partizione
`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`	`BOOL` Se `true`, consenti le righe in cui mancano le colonne finali facoltative. Si applica ai dati CSV.
`allow_quoted_newlines`	`BOOL` Se `true`, consenti le sezioni di dati tra virgolette che contengono caratteri di nuova riga nel file. Si applica ai dati CSV.
`bigtable_options`	`STRING` Obbligatorio solo quando crei una tabella esterna di Bigtable. Specifica lo schema della tabella esterna di Bigtable in formato JSON. Per un elenco delle opzioni di definizione delle tabelle Bigtable, consulta `BigtableOptions` nel riferimento dell'API REST.
`column_name_character_map`	`STRING` Definisce l'ambito dei caratteri supportati per i nomi delle colonne e il comportamento di gestione dei caratteri non supportati. I valori supportati includono: `STRICT`. Abilita i nomi flessibili delle colonne. I job di caricamento con caratteri non supportati nei nomi di colonna non riescono e viene visualizzato un messaggio di errore. Questo è il valore predefinito. `V1`. I nomi delle colonne possono contenere solo caratteri standard per i nomi delle colonne. I caratteri non supportati vengono sostituiti con trattini bassi. `V2`. Abilita i nomi flessibili delle colonne. I caratteri non supportati vengono sostituiti con trattini bassi. Questa è l'impostazione consigliata, tranne nei casi d'uso con tabelle esterne.
`compression`	`STRING` Il tipo di compressione dell'origine dati. I valori supportati includono: `GZIP`. Se non specificato, l'origine dati è decompressa. Si applica ai dati CSV e JSON.
`decimal_target_types`	`ARRAY<STRING>` Determina come convertire un tipo `Decimal`. Equivalente a ExternalDataConfiguration.decimal_target_types Esempio: `["NUMERIC", "BIGNUMERIC"]`.
`description`	`STRING` Una descrizione di questa tabella.
`enable_list_inference`	`BOOL` Se `true`, utilizza l'inferenza dello schema specifica per il tipo logico Parquet LIST. Si applica ai dati Parquet.
`enable_logical_types`	`BOOL` Se `true`, converti i tipi logici Avro nei tipi SQL corrispondenti. Per maggiori informazioni, consulta Tipi logici. Si applica ai dati Avro.
`encoding`	`STRING` La codifica dei caratteri dei dati. I valori supportati includono: `UTF8` (o `UTF-8`), `ISO_8859_1` (o `ISO-8859-1`). Si applica ai dati CSV.
`enum_as_string`	`BOOL` Se `true`, deduci il tipo logico Parquet ENUM come STRING anziché BYTES per impostazione predefinita. Si applica ai dati Parquet.
`expiration_timestamp`	`TIMESTAMP` L'ora di scadenza della tabella. Se non specificata, la tabella non scade. Esempio: `"2025-01-01 00:00:00 UTC"`.
`field_delimiter`	`STRING` Il separatore per i campi di un file CSV. Si applica ai dati CSV.
`format`	`STRING` Il formato dei dati esterni. I valori supportati per `CREATE EXTERNAL TABLE` includono: `AVRO`, `CLOUD_BIGTABLE`, `CSV`, `DATASTORE_BACKUP`, `DELTA_LAKE` (anteprima), `GOOGLE_SHEETS`, `NEWLINE_DELIMITED_JSON` (o `JSON`), `ORC`, `PARQUET`. I valori supportati per `LOAD DATA` includono: `AVRO`, `CSV`, `DELTA_LAKE` (anteprima) `NEWLINE_DELIMITED_JSON` (o `JSON`), `ORC`, `PARQUET`. Il valore `JSON` equivale a `NEWLINE_DELIMITED_JSON`.
`hive_partition_uri_prefix`	`STRING` Prefisso comune per tutti gli URI di origine prima dell'inizio della codifica della chiave di partizione. Si applica solo alle tabelle esterne partizionate in hive. Si applica ai dati Avro, CSV, JSON, Parquet e ORC. Esempio: `"gs://bucket/path"`.
`file_set_spec_type`	`STRING` Specifica come interpretare gli URI di origine per i job di caricamento e le tabelle esterne. In anteprima. I valori supportati includono: `FILE_SYSTEM_MATCH`. Espande gli URI di origine elencando i file dell'archivio oggetti. Questo è il comportamento predefinito se FileSetSpecType non è impostato. `NEW_LINE_DELIMITED_MANIFEST`. Indica che gli URI forniti sono file manifest delimitati da nuova riga, con un URI per riga. Gli URI con caratteri jolly non sono supportati nei file manifest. Ad esempio, se hai un URI di origine `"gs://bucket/path/file"` e il valore `file_set_spec_type` è `FILE_SYSTEM_MATCH`, il file viene utilizzato direttamente come file di dati. Se `file_set_spec_type` è `NEW_LINE_DELIMITED_MANIFEST`, ogni riga del file è interpretata come un URI che punta a un file di dati.
`ignore_unknown_values`	`BOOL` Se `true`, ignora i valori aggiuntivi che non sono rappresentati nello schema della tabella, senza restituire un errore. Si applica ai dati CSV e JSON.
`json_extension`	`STRING` 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: `GEOJSON`. Dati GeoJSON delimitato da nuova riga. Per maggiori informazioni, consulta Creazione di una tabella esterna da un file GeoJSON delimitato da nuova riga.
`max_bad_records`	`INT64` 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`	`INTERVAL` Applicabile per tabelle BigLake e tabelle di oggetti. Specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella e se devono essere aggiornati per consentire all'operazione di utilizzarli. Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita. Per abilitare la memorizzazione nella cache dei metadati, specifica un valore di valore letterale intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica `INTERVAL 4 HOUR` per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se sono stati aggiornati nelle ultime 4 ore. Se i metadati memorizzati nella cache sono precedenti, l'operazione utilizza il recupero dei metadati da Cloud Storage.
`null_marker`	`STRING` La stringa che rappresenta i valori `NULL` in un file CSV. Si applica ai dati CSV.
`object_metadata`	`STRING` Obbligatorio solo quando si crea una tabella di oggetti. Imposta il valore di questa opzione su `SIMPLE` quando crei una tabella di oggetti.
`preserve_ascii_control_characters`	`BOOL` Se `true`, i caratteri di controllo ASCII incorporati che sono i primi 32 caratteri nella tabella ASCII, compresi tra "\x00" e "\x1F", vengono conservati. Si applica ai dati CSV.
`projection_fields`	`STRING` Un elenco di proprietà delle entità da caricare. Si applica ai dati Datastore.
`quote`	`STRING` 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à `allow_quoted_newlines` su `true`. Si applica ai dati CSV.
`reference_file_schema_uri`	`STRING` File di riferimento fornito dall'utente con lo schema della tabella. Si applica ai dati Parquet/ORC/AVRO. Esempio: `"gs://bucket/path/reference_schema_file.parquet"`.
`require_hive_partition_filter`	`BOOL` Se `true`, tutte le query su questa tabella richiedono un filtro di partizionamento che può essere utilizzato per eliminare le partizioni durante la lettura dei dati. Si applica solo alle tabelle esterne partizionate in hive. Si applica ai dati Avro, CSV, JSON, Parquet e ORC.
`sheet_range`	`STRING` Intervallo di un foglio di lavoro di Fogli Google da cui eseguire le query. Si applica ai dati di Fogli Google. Esempio: `"sheet1!A1:B20"`,
`skip_leading_rows`	`INT64` Il numero di righe all'inizio 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 di oggetti, che non sono tabelle Bigtable: `ARRAY<STRING>` Un array di URI completi per le posizioni dei dati esterni. Ogni URI può contenere un asterisco (``) carattere jolly, che deve essere seguito dal nome del bucket. Se specifichi valori di `uris` che hanno come target più file, tutti questi file devono condividere uno schema compatibile. I seguenti esempi mostrano valori `uris` validi: `['gs://bucket/path1/myfile.csv']` `['gs://bucket/path1/.csv']` `['gs://bucket/path1/', 'gs://bucket/path2/file00']` Per le tabelle Bigtable: `STRING` L'URI che identifica la tabella Bigtable da utilizzare come origine dati. Puoi specificare un solo URI Bigtable. Esempio: `https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name` Per ulteriori informazioni sulla creazione di un URI Bigtable, consulta la pagina relativa al recupero dell'URI Bigtable.

Esempi

Esempio 1:

L'esempio seguente recupera i tempi di scadenza predefiniti delle tabelle per tutte le tabelle in mydataset nel progetto predefinito (myproject) eseguendo una query sulla vista 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 dell'opzione description per trovare le tabelle che contengono "test" in qualsiasi punto della descrizione. mydataset si trova nel progetto predefinito: myproject.

  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, denominata anche `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 a 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 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 la colonna sia una pseudo colonna, ad esempio _PARTITIONTIME o _PARTITIONDATE
`IS_UPDATABLE`	`STRING`	Il valore è sempre `NULL`
`IS_SYSTEM_DEFINED`	`STRING`	`YES` o `NO` a seconda che la colonna sia una pseudo colonna, ad esempio _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 a 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 passata `STRING` o `ARRAY<STRING>`, la specifica di confronto viene restituita, 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 è un `NUMERIC` o `BIGNUMERIC` con parametri; in caso contrario, 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 Public dataset di BigQuery.

Poiché la tabella su cui stai eseguendo 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é al momento sono 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. Alcune colonne sono escluse dal risultato per migliorarne la leggibilità.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       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, denominata anche `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 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 passato un campo `STRING`, `ARRAY<STRING>` o `STRING` in un `STRUCT`, viene restituita la specifica di confronto, se esistente; in caso contrario, viene restituito `NULL`.
`ROUNDING_MODE`	`STRING`	La modalità di arrotondamento utilizzata quando si applica la precisione e la scala a valori con parametri `NUMERIC` o `BIGNUMERIC`; in caso contrario, il valore è `NULL`

Esempi

L'esempio seguente recupera i metadati dalla visualizzazione INFORMATION_SCHEMA.COLUMN_FIELD_PATHS per la tabella commits nel set di dati github_repos. Questo set di dati fa parte del programma Public dataset di BigQuery.

La tabella commits contiene le seguenti colonne nidificate, nidificate e ripetute:

author: colonna RECORD nidificata
committer: colonna RECORD nidificata
trailer: colonna RECORD nidificata e ripetuta
difference: colonna RECORD nidificata e ripetuta

Per visualizzare i metadati relativi alle colonne author e difference, esegui questa 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. Alcune colonne sono escluse dal risultato per migliorarne la leggibilità.

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | 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.
`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 nella vista materializzata.
`ACTIVE_LOGICAL_BYTES`	`INT64`	Numero di byte logici (non compressi) precedenti a 90 giorni.
`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 della tabella in tutte le partizioni.
`TOTAL_PHYSICAL_BYTES`	`INT64`	Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi i byte attivi, a lungo termine e per i viaggi nel tempo (dati eliminati o modificati). I byte a prova di errore (dati eliminati o modificati conservati dopo il periodo di viaggio temporale) non sono inclusi.
`ACTIVE_PHYSICAL_BYTES`	`INT64`	Numero di byte fisici (compressi) meno di 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 dall'archiviazione a prova di errore (dati eliminati o modificati).

Esempi

Esempio 1:

L'esempio seguente mostra il totale dei byte logici 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 prossimi 30 giorni. Questo esempio presuppone che l'utilizzo futuro dello spazio di archiviazione sia costante nei successivi 30 giorni dal momento in cui è stata eseguita la query. Tieni presente che la previsione è limitata alle tabelle 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, aggiorna le variabili di prezzo in modo appropriato. Per informazioni sui prezzi, vedi Prezzi dell'archiviazione.

Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina di BigQuery

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 > 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 bq ls.
Chiamata al metodo API tables.list.
Utilizzare le librerie client.

Autorizzazioni obbligatorie

Come minimo, per elencare le tabelle in un set di dati devi disporre 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, 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 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.

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, il campo Type mostra TABLE o VIEW. 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 comando seguente 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 in myotherproject.
```
   bq ls --format=pretty myotherproject:mydataset
```

API

Per elencare le tabelle utilizzando l'API, chiama il metodo tables.list.

C#

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.


using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

Go

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

Java

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Table;

public class ListTables {

  public static void runListTables() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    listTables(projectId, datasetName);
  }

  public static void listTables(String projectId, String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
      tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));

      System.out.println("Tables listed successfully.");
    } catch (BigQueryException e) {
      System.out.println("Tables were not listed. Error occurred: " + e.toString());
    }
  }
}

Node.js

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function listTables() {
  // Lists tables in 'my_dataset'.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';

  // List all tables in the dataset
  const [tables] = await bigquery.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}

PHP

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

Python

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

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 BigQuery INFORMATION_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

Creare e utilizzare tabelle

Prima di iniziare

Denominazione delle tabelle

Creare tabelle

Autorizzazioni obbligatorie

Crea una tabella vuota con una definizione di schema

Console

SQL

bq

Terraform

Prepara Cloud Shell

Prepara la directory

Applica le modifiche

API

C#

Go

Java

Node.js

PHP

Python

Ruby

Crea una tabella vuota senza una definizione dello schema

Java

Crea una tabella dal risultato di una query

Console

SQL

bq

API

Go

Java

Node.js

Python

Crea una tabella che fa riferimento a un'origine dati esterna

Crea una tabella quando carichi i dati

Controllare l'accesso alle tabelle

Ottieni informazioni sulle tabelle

Autorizzazioni obbligatorie

Recupera informazioni tabella

Console

bq

API

Go

Java

Node.js

PHP

Python

Ottieni informazioni della tabella utilizzando INFORMATION_SCHEMA

TABLES visualizzazione

Esempi

Esempio 1:

Esempio 2:

Esempio 3:

TABLE_OPTIONS visualizzazione

Tabella delle opzioni

Esempi

Esempio 1:

Esempio 2:

COLUMNS visualizzazione

Esempi

COLUMN_FIELD_PATHS visualizzazione

Esempi

TABLE_STORAGE visualizzazione

Esempi

Esempio 1:

Esempio 2:

Elenca tabelle in un set di dati

Autorizzazioni obbligatorie

Elenca tabelle

Console

bq

API

C#

Go

Java

Node.js

PHP

Python

Ruby

Sicurezza dei tavoli

Passaggi successivi

Ottieni informazioni della tabella utilizzando `INFORMATION_SCHEMA`

`TABLES` visualizzazione

`TABLE_OPTIONS` visualizzazione

`COLUMNS` visualizzazione

`COLUMN_FIELD_PATHS` visualizzazione

`TABLE_STORAGE` visualizzazione