Creare tabelle in cluster

Puoi ridurre la quantità di dati elaborati da una query utilizzando le tabelle in cluster in BigQuery.

Con le tabelle in cluster, i dati della tabella vengono organizzati in base ai valori delle colonne specificate, chiamate anche colonne di clustering. BigQuery ordina i dati in base alle colonne in cluster, quindi archivia le righe con valori simili negli stessi blocchi fisici o in blocchi vicini. Quando una query filtra una colonna in cluster, BigQuery analizza in modo efficiente solo i blocchi pertinenti e salta i dati che non corrispondono al filtro.

Per ulteriori informazioni, consulta le seguenti risorse:

• Per scoprire di più sulle tabelle in cluster in BigQuery, consulta la sezione Introduzione alle tabelle in cluster.
• Per informazioni su come utilizzare e controllare l'accesso alle tabelle in cluster, consulta Gestire le tabelle in cluster.

Prima di iniziare

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 le tabelle nei set di dati che crei.

Per ulteriori informazioni sui ruoli e sulle autorizzazioni IAM in BigQuery, vedi Ruoli e autorizzazioni predefiniti.

Requisiti per la 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 totale massimo di 1024 byte UTF-8.
• 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 alcuni esempi di nomi di tabelle validi: table 01, ग्राहक, 00_お客様, étudiant-01.

Avvertenze:

• I nomi delle tabelle sono sensibili alle maiuscole per impostazione predefinita. mytable e MyTable possono coesistere nello stesso set di dati, a meno che non facciano parte di un set di dati con distinzione tra maiuscole e minuscole disattivata.
• Alcuni nomi di tabelle e prefissi dei nomi di tabelle sono riservati. Se ricevi un errore che indica che il nome o il prefisso della tabella è riservato, seleziona un nome diverso e riprova.

• Se includi più operatori punto (.) in una sequenza, gli operatori duplicati vengono rimossi implicitamente.

  Ad esempio: project_name....dataset_name..table_name

  Diventa: project_name.dataset_name.table_name

Requisiti per le colonne in cluster

Puoi specificare le colonne utilizzate per creare la tabella in cluster quando crei una tabella in BigQuery. Dopo aver creato la tabella, puoi modificare le colonne utilizzate per creare la tabella in cluster. Per maggiori dettagli, vedi Modificare la specifica di clustering.

Le colonne di clustering devono essere colonne di primo livello, non ripetute e devono essere uno dei seguenti tipi di dati:

• BIGNUMERIC
• BOOL
• DATE
• DATETIME
• GEOGRAPHY
• INT64
• NUMERIC
• RANGE
• STRING
• TIMESTAMP

Puoi specificare fino a quattro colonne di clustering. Quando specifichi più colonne, l'ordine delle colonne determina l'ordinamento dei dati. Ad esempio, se la tabella è in cluster per le colonne a, b e c, i dati vengono ordinati nello stesso ordine: prima per la colonna a, poi per la colonna b e infine per la colonna c. Come best practice, posiziona per prima la colonna filtrata o aggregata più di frequente.

Anche l'ordine delle colonne di clustering influisce sul rendimento e sui prezzi delle query. Per ulteriori informazioni sulle best practice per le query per le tabelle in cluster, consulta Esecuzione di query sulle tabelle in cluster.

Crea una tabella in cluster vuota con una definizione dello schema

Per creare una tabella in cluster vuota con una definizione dello schema:

Console

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
1. Nella sezione Origine, seleziona Tabella vuota nell'elenco Crea tabella da.
2. Nella sezione Destinazione, specifica i seguenti dettagli:
   1. Per Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
   2. Nel campo Table (Tabella), inserisci il nome della tabella che vuoi creare.
   3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
3. 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 lo stesso processo di creazione di un file schema JSON. Per visualizzare lo schema di una tabella esistente in formato JSON, inserisci il seguente comando:

         bq show --format=prettyjson dataset.table
         

   • Opzione 2: fai clic su Aggiungi campo e inserisci lo schema della tabella. Specifica il nome, il tipo e la modalità di ogni campo.
4. Per Ordine di clustering, inserisci da uno a quattro nomi di colonne separati da virgole.
5. (Facoltativo) Nella sezione Opzioni avanzate, se vuoi utilizzare una chiave di crittografia gestita dal cliente, seleziona l'opzione Utilizza una chiave di crittografia gestita dal cliente (CMEK). Per impostazione predefinita, BigQuery cripta i contenuti dei clienti archiviati at-rest utilizzando un Google-owned and Google-managed encryption key.
6. Fai clic su Crea tabella.

SQL

Utilizza il comando CREATE TABLE DDL con l'opzione CLUSTER BY. L'esempio seguente crea una tabella in cluster denominata myclusteredtable in mydataset:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, inserisci la seguente istruzione:

   CREATE TABLE mydataset.myclusteredtable
   (
     customer_id STRING,
     transaction_amount NUMERIC
   )
   CLUSTER BY
     customer_id
     OPTIONS (
       description = 'a table clustered by customer_id');

3. Fai clic su Esegui.

Per maggiori informazioni su come eseguire le query, consulta Eseguire una query interattiva.

bq

Utilizza il comando bq mk con i seguenti flag:

• --table (o la scorciatoia -t).
• --schema. Puoi fornire la definizione dello schema della tabella in linea o utilizzare un file di schema JSON.
• --clustering_fields. Puoi specificare fino a quattro colonne di clustering.

I parametri facoltativi includono --expiration, --description, --time_partitioning_type, --time_partitioning_field, --time_partitioning_expiration, --destination_kms_key e --label.

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.

--destination_kms_key non è dimostrato qui. Per informazioni sull'utilizzo di --destination_kms_key, vedi Chiavi di crittografia gestite dal cliente.

Inserisci il comando seguente per creare una tabella in cluster vuota con una definizione dello schema:

bq mk \
    --table \
    --expiration INTEGER1 \
    --schema SCHEMA \
    --clustering_fields CLUSTER_COLUMNS \
    --description "DESCRIPTION" \
    --label KEY:VALUE,KEY:VALUE \
    PROJECT_ID:DATASET.TABLE

Sostituisci quanto segue:

• INTEGER1: la durata predefinita, in secondi, per la tabella. Il valore minimo è 3600 secondi (un'ora). La scadenza corrisponde all'ora UTC corrente più il valore intero. Se imposti il tempo di scadenza della tabella quando la crei, l'impostazione di scadenza della tabella predefinita del set di dati viene ignorata. Se imposti questo valore, la tabella viene eliminata dopo il periodo di tempo specificato.
• SCHEMA: una definizione di schema incorporata nel formato COLUMN:DATA_TYPE,COLUMN:DATA_TYPE o il percorso del file dello schema JSON sulla macchina locale.
• CLUSTER_COLUMNS: un elenco separato da virgole di un massimo di quattro colonne di clustering. L'elenco non può contenere spazi.
• DESCRIPTION: una descrizione della tabella, tra virgolette.
• KEY:VALUE: la coppia chiave-valore che rappresenta un'etichetta. Puoi inserire più etichette utilizzando un elenco separato da virgole.
• PROJECT_ID: il tuo ID progetto.
• DATASET: un set di dati nel tuo progetto.
• TABLE: il nome della tabella che stai creando.

Quando 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à sono impostate su NULLABLE per impostazione predefinita. Per includere descrizioni, modalità e tipi di RECORD, fornisci un file dello schema JSON.

Esempi:

Inserisci il comando seguente per creare una tabella in cluster denominata myclusteredtable in mydataset nel tuo progetto predefinito. La scadenza della tabella è impostata su 2.592.000 (1 mese di 30 giorni), la descrizione è impostata su This is my clustered table e l'etichetta è impostata su organization:development. Il comando utilizza la scorciatoia -t anziché --table.

Lo schema è specificato inline come: timestamp:timestamp,customer_id:string,transaction_amount:float. Il campo di clustering specificato customer_id viene utilizzato per raggruppare la tabella.

bq mk \
    -t \
    --expiration 2592000 \
    --schema 'timestamp:timestamp,customer_id:string,transaction_amount:float' \
    --clustering_fields customer_id \
    --description "This is my clustered table" \
    --label org:dev \
    mydataset.myclusteredtable

Inserisci il comando seguente per creare una tabella in cluster denominata myclusteredtable in myotherproject, non nel tuo progetto predefinito. La descrizione è impostata su This is my clustered table e l'etichetta su organization:development. Il comando utilizza la scorciatoia -t anziché --table. Questo comando non specifica una scadenza della tabella. Se il set di dati ha una scadenza predefinita della tabella, questa viene applicata. Se il set di dati non ha una scadenza della tabella predefinita, la tabella non scade mai.

Lo schema è specificato in un file JSON locale: /tmp/myschema.json. Il campo customer_id viene utilizzato per raggruppare la tabella.

bq mk \
    -t \
    --expiration 2592000 \
    --schema /tmp/myschema.json \
    --clustering_fields=customer_id \
    --description "This is my clustered table" \
    --label org:dev \
    myotherproject:mydataset.myclusteredtable

Dopo aver creato la tabella, puoi aggiornarne la descrizione e le etichette.

Terraform

Utilizza la risorsa google_bigquery_table.

Nota: per creare oggetti BigQuery utilizzando Terraform, devi attivare l'API Cloud Resource Manager.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

Il seguente esempio crea una tabella denominata mytable raggruppata nelle colonne ID e Created:

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

  clustering = ["ID", "Created"]

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

}

Per applicare la configurazione di Terraform in un progetto Google Cloud , completa i passaggi nelle sezioni seguenti.

Prepara Cloud Shell

1. Avvia Cloud Shell.

2. Imposta il progetto Google Cloud predefinito in 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 di Terraform deve avere la propria directory (chiamata anche modulo radice).

1. In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file viene denominato main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

   Copia il codice campione nel main.tf appena creato.

   (Facoltativo) Copia il codice da GitHub. Questa operazione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

3. Rivedi e modifica i parametri di esempio da applicare al tuo ambiente.
4. Salva le modifiche.
5. Inizializza Terraform. Devi effettuare questa operazione una sola volta per directory.

   terraform init

   (Facoltativo) Per utilizzare l'ultima versione del provider Google, includi l'opzione -upgrade:

   terraform init -upgrade

Applica le modifiche

1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o aggiornerà corrispondano alle tue aspettative:

   terraform plan

   Apporta le correzioni necessarie alla configurazione.

2. Applica la configurazione di Terraform eseguendo il comando seguente e inserendo yes al prompt:

   terraform apply

   Attendi che Terraform visualizzi il messaggio "Apply complete!" (Applicazione completata).

3. Apri il tuo Google Cloud progetto per visualizzare i risultati. Nella console Google Cloud , vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

Nota: gli esempi di Terraform in genere presuppongono che le API richieste siano attive nel tuo progetto Google Cloud .

API

Chiama il metodo tables.insert con una risorsa tabella definita che specifica la proprietà clustering.fields e la proprietà schema.

Python

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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi 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"),
    bigquery.SchemaField("city", "STRING"),
    bigquery.SchemaField("zipcode", "INTEGER"),
]

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

Vai

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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"time"

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

// createTableClustered demonstrates creating a BigQuery table with advanced properties like
// partitioning and clustering features.
func createTableClustered(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: "timestamp", Type: bigquery.TimestampFieldType},
		{Name: "origin", Type: bigquery.StringFieldType},
		{Name: "destination", Type: bigquery.StringFieldType},
		{Name: "amount", Type: bigquery.NumericFieldType},
	}
	metaData := &bigquery.TableMetadata{
		Schema: sampleSchema,
		TimePartitioning: &bigquery.TimePartitioning{
			Field:      "timestamp",
			Expiration: 90 * 24 * time.Hour,
		},
		Clustering: &bigquery.Clustering{
			Fields: []string{"origin", "destination"},
		},
	}
	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 di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi 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.Clustering;
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.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TimePartitioning;
import com.google.common.collect.ImmutableList;

public class CreateClusteredTable {
  public static void runCreateClusteredTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createClusteredTable(datasetName, tableName);
  }

  public static void createClusteredTable(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);

      TimePartitioning partitioning = TimePartitioning.of(TimePartitioning.Type.DAY);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      Clustering clustering =
          Clustering.newBuilder().setFields(ImmutableList.of("name", "post_abbr")).build();

      StandardTableDefinition tableDefinition =
          StandardTableDefinition.newBuilder()
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .setClustering(clustering)
              .build();
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

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

Crea una tabella in cluster da un risultato di query

Esistono due modi per creare una tabella in cluster da un risultato di query:

• Scrivi i risultati in una nuova tabella di destinazione e specifica le colonne di clustering.
• Utilizzando un'istruzione DDL CREATE TABLE AS SELECT. Per saperne di più su questo metodo, consulta Creazione di una tabella in cluster dal risultato di una query nella pagina Utilizzo delle istruzioni del linguaggio di definizione dei dati.

Puoi creare una tabella in cluster eseguendo query su una tabella partizionata o su una tabella non partizionata. Non puoi modificare una tabella esistente in una tabella in cluster utilizzando i risultati della query.

Quando crei una tabella in cluster da un risultato di query, devi utilizzare SQL standard. Al momento, l'SQL precedente non è supportato per l'esecuzione di query sulle tabelle in cluster o per la scrittura dei risultati delle query nelle tabelle in cluster.

SQL

Per creare una tabella in cluster da un risultato di query, utilizza l'istruzione DDL CREATE TABLE con l'opzione CLUSTER BY. L'esempio seguente crea una nuova tabella in cluster in base a customer_id eseguendo una query su una tabella non in cluster esistente:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, inserisci la seguente istruzione:

   CREATE TABLE mydataset.clustered_table
   (
     customer_id STRING,
     transaction_amount NUMERIC
   )
   CLUSTER BY
     customer_id
   AS (
     SELECT * FROM mydataset.unclustered_table
   );

3. Fai clic su Esegui.

Per maggiori informazioni su come eseguire le query, consulta Eseguire una query interattiva.

bq

Inserisci il seguente comando per creare una nuova tabella di destinazione in cluster da un risultato di query:

bq --location=LOCATION query \
    --use_legacy_sql=false 'QUERY'

Sostituisci quanto segue:

• LOCATION: il nome della tua sede. 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.
• QUERY: una query nella sintassi GoogleSQL. Al momento, non puoi utilizzare SQL precedente per eseguire query sulle tabelle in cluster o per scrivere i risultati delle query nelle tabelle in cluster. La query può contenere un'istruzione CREATE TABLE DDL che specifica le opzioni per la creazione della tabella in cluster. Puoi utilizzare DDL differiti anziché specificare i singoli flag della riga di comando.

Esempi:

Inserisci il seguente comando per scrivere i risultati della query in una tabella di destinazione in cluster denominata myclusteredtable in mydataset. mydataset si trova nel tuo progetto predefinito. La query recupera i dati da una tabella non partizionata: mytable. La colonna customer_id della tabella viene utilizzata per raggruppare la tabella. La colonna timestamp della tabella viene utilizzata per creare una tabella partizionata.

bq query --use_legacy_sql=false \
    'CREATE TABLE
       mydataset.myclusteredtable
     PARTITION BY
       DATE(timestamp)
     CLUSTER BY
       customer_id
     AS (
       SELECT
         *
       FROM
         `mydataset.mytable`
     );'

API

Per salvare i risultati della query in una tabella in cluster, chiama il metodo jobs.insert, configura un job query e includi un'istruzione DDL CREATE TABLE che crea la tabella in cluster.

Specifica la tua posizione nella proprietà location nella sezione jobReference della risorsa job.

Creare una tabella in cluster durante il caricamento dei dati

Puoi creare una tabella in cluster specificando le colonne di clustering quando carichi i dati in una nuova tabella. Non è necessario creare una tabella vuota prima di caricarvi i dati. Puoi creare la tabella in cluster e caricare i dati contemporaneamente.

Per ulteriori informazioni sul caricamento dei dati, vedi Caricare i dati in BigQuery.

Per definire il clustering durante la definizione di un job di caricamento:

SQL

Utilizza l'istruzione LOAD DATA. Il seguente esempio carica i dati AVRO per creare una tabella partizionata in base al campo transaction_date e raggruppata in cluster in base al campo customer_id. Inoltre, configura le partizioni in modo che scadano dopo tre giorni.

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, inserisci la seguente istruzione:

   LOAD DATA INTO mydataset.mytable
   PARTITION BY transaction_date
   CLUSTER BY customer_id
     OPTIONS (
       partition_expiration_days = 3)
   FROM FILES(
     format = 'AVRO',
     uris = ['gs://bucket/path/file.avro']);

3. Fai clic su Esegui.

Per maggiori informazioni su come eseguire le query, consulta Eseguire una query interattiva.

API

Per definire una configurazione di clustering durante la creazione di una tabella tramite un job di caricamento, puoi compilare le proprietà Clustering per la tabella.

Vai

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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

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

// importClusteredTable demonstrates creating a table from a load job and defining partitioning and clustering
// properties.
func importClusteredTable(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv")
	gcsRef.SkipLeadingRows = 1
	gcsRef.Schema = bigquery.Schema{
		{Name: "timestamp", Type: bigquery.TimestampFieldType},
		{Name: "origin", Type: bigquery.StringFieldType},
		{Name: "destination", Type: bigquery.StringFieldType},
		{Name: "amount", Type: bigquery.NumericFieldType},
	}
	loader := client.Dataset(destDatasetID).Table(destTableID).LoaderFrom(gcsRef)
	loader.TimePartitioning = &bigquery.TimePartitioning{
		Field: "timestamp",
	}
	loader.Clustering = &bigquery.Clustering{
		Fields: []string{"origin", "destination"},
	}
	loader.WriteDisposition = bigquery.WriteEmpty

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi 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.Clustering;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TimePartitioning;
import com.google.common.collect.ImmutableList;

public class LoadTableClustered {

  public static void runLoadTableClustered() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "/path/to/file.csv";
    loadTableClustered(datasetName, tableName, sourceUri);
  }

  public static void loadTableClustered(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      TimePartitioning partitioning = TimePartitioning.of(TimePartitioning.Type.DAY);

      Clustering clustering =
          Clustering.newBuilder().setFields(ImmutableList.of("name", "post_abbr")).build();

      LoadJobConfiguration loadJobConfig =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .setClustering(clustering)
              .build();

      Job loadJob = bigquery.create(JobInfo.newBuilder(loadJobConfig).build());

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Data successfully loaded into clustered table during load job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Data not loaded into clustered table during load job \n" + e.toString());
    }
  }
}

Python

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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi 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"

job_config = bigquery.LoadJobConfig(
    skip_leading_rows=1,
    source_format=bigquery.SourceFormat.CSV,
    schema=[
        bigquery.SchemaField("timestamp", bigquery.SqlTypeNames.TIMESTAMP),
        bigquery.SchemaField("origin", bigquery.SqlTypeNames.STRING),
        bigquery.SchemaField("destination", bigquery.SqlTypeNames.STRING),
        bigquery.SchemaField("amount", bigquery.SqlTypeNames.NUMERIC),
    ],
    time_partitioning=bigquery.TimePartitioning(field="timestamp"),
    clustering_fields=["origin", "destination"],
)

job = client.load_table_from_uri(
    ["gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv"],
    table_id,
    job_config=job_config,
)

job.result()  # Waits for the job to complete.

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

Passaggi successivi

• Per informazioni sull'utilizzo delle tabelle in cluster, consulta Gestire le tabelle in cluster.
• Per informazioni sull'esecuzione di query sulle tabelle in cluster, consulta Esecuzione di query sulle tabelle in cluster.
• Per una panoramica del supporto delle tabella partizionata in BigQuery, consulta Introduzione alle tabelle partizionate.
• Per scoprire come creare tabelle partizionate, consulta Creazione delle tabelle partizionate.
• Per una panoramica di INFORMATION_SCHEMA, consulta Introduzione a BigQuery INFORMATION_SCHEMA.