Creazione delle tabelle partizionate

In questa pagina viene descritto come creare tabelle partizionate in BigQuery. Per una panoramica delle tabelle partizionate, consulta Introduzione alle tabelle partizionate.

Prima di iniziare

Concede ruoli IAM (Identity and Access Management) che concedono agli utenti le autorizzazioni necessarie per eseguire ciascuna attività in questo documento.

Autorizzazioni obbligatorie

Per creare una tabella, devi disporre delle seguenti autorizzazioni IAM:

• bigquery.tables.create
• bigquery.tables.updateData
• bigquery.jobs.create

Inoltre, potresti aver bisogno dell'autorizzazione bigquery.tables.getData per accedere ai dati che scrivi nella tabella.

Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per creare una tabella:

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin (include l'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 su ruoli e autorizzazioni IAM in per BigQuery, consulta Ruoli e autorizzazioni predefiniti.

Crea una tabella partizionata vuota

I passaggi per creare una tabella partizionata in BigQuery sono simili alla creazione di una tabella standard, tranne quando specifichi le opzioni di partizionamento, insieme a qualsiasi altra opzione della tabella.

Crea una tabella partizionata per colonne di unità di tempo

Per creare una tabella partizionata in colonne di unità di tempo 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. In Set di dati, seleziona il set di dati in cui creare il .
   2. Nel campo Tabella, inserisci il nome della tabella da creare.
   3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
3. Nella sezione Schema, inserisci lo schema. definizione di Kubernetes. La lo schema deve includere una colonna DATE, TIMESTAMP o DATETIME per la colonna di partizionamento. Per ulteriori informazioni, vedi Specifica di uno schema. Puoi inserire le informazioni sullo schema manualmente utilizzando uno dei seguenti utilizza i seguenti metodi:
   • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di un array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando è la stessa procedura utilizzata per la creazione di un file di schema JSON. Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo quanto segue: :

         bq show --format=prettyjson dataset.table
         

   • Opzione 2: fai clic su Aggiungi campo e inserisci lo schema della tabella. Specifica il Nome di ogni campo, Tipo, e Modalità.
4. Nella sezione Impostazioni di partizionamento e clustering, Nell'elenco Partizionamento, seleziona Partizionamento per campo, quindi scegli la colonna di partizionamento. Questa opzione è disponibile solo se schema contiene una colonna DATE, TIMESTAMP o DATETIME.
5. (Facoltativo) Per richiedere un filtro di partizione su tutte le query per questa tabella, Seleziona la casella di controllo Richiedi filtro di partizione. Una partizione può ridurre i costi e migliorare il rendimento. Per ulteriori informazioni, vedi Imposta i requisiti del filtro di partizionamento.
6. Seleziona il Tipo di partizionamento per scegliere tra giornaliera, oraria, mensile o con il partizionamento annuale.
7. (Facoltativo) Nella sezione Opzioni avanzate, se vuoi utilizzare una di crittografia gestita dal cliente, quindi seleziona la casella Utilizza una chiave di crittografia gestita dal cliente chiave di crittografia (CMEK). Per impostazione predefinita, BigQuery cripta i contenuti archiviati inattivi dei clienti mediante una chiave di proprietà di Google.
8. Fai clic su Crea tabella.

Nota: non puoi impostare la scadenza della partizione nella console Google Cloud. Per impostare la partizione dopo aver creato la tabella, vedi Aggiorna la scadenza della partizione.

SQL

Per creare una tabella partizionata per colonne di unità di tempo, utilizza il metodo CREATE TABLE Istruzione DDL con una clausola PARTITION BY.

L'esempio seguente crea una tabella con partizioni giornaliere basate sul Colonna transaction_date:

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

   Vai a BigQuery

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

   CREATE TABLE
     mydataset.newtable (transaction_id INT64, transaction_date DATE)
   PARTITION BY
     transaction_date
     OPTIONS (
       partition_expiration_days = 3,
       require_partition_filter = TRUE);
   

   Utilizzare la clausola OPTIONS per impostare opzioni della tabella come scadenza della partizione e i requisiti del filtro di partizione.

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

Il tipo di partizionamento predefinito per le colonne DATE è il partizionamento giornaliero. A specifica un tipo di partizionamento diverso, includi DATE_TRUNC nella clausola PARTITION BY. Ad esempio, la seguente query crea una tabella con partizioni mensili:

CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_date DATE)
PARTITION BY
  DATE_TRUNC(transaction_date, MONTH)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

Puoi anche specificare una colonna TIMESTAMP o DATETIME come partizionamento colonna. In questo caso, includi TIMESTAMP_TRUNC o DATETIME_TRUNC nella clausola PARTITION BY per specificare il tipo di partizione. Per Ad esempio, la seguente istruzione crea una tabella con partizioni giornaliere basate in una colonna TIMESTAMP:

CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_ts TIMESTAMP)
PARTITION BY
  TIMESTAMP_TRUNC(transaction_ts, DAY)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

bq

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

2. Utilizza la bq mk con il flag --table (o una scorciatoia -t):

   bq mk \
      --table \
      --schema SCHEMA \
      --time_partitioning_field COLUMN \
      --time_partitioning_type UNIT_TIME \
      --time_partitioning_expiration EXPIRATION_TIME \
      --require_partition_filter=BOOLEAN
      PROJECT_ID:DATASET.TABLE
   

   Sostituisci quanto segue:

   • SCHEMA: definizione di schema nel formato column:data_type,column:data_type o il percorso di un file JSON di schema del tuo computer. Per ulteriori informazioni, vedi Specifica di uno schema.
   • COLUMN: il nome della colonna di partizionamento. Nella tabella questa colonna deve essere di tipo TIMESTAMP, DATETIME o DATE.
   • UNIT_TIME: il tipo di partizionamento. Valori supportati includono DAY, HOUR, MONTH o YEAR.
   • EXPIRATION_TIME: la data e l'ora di scadenza partizioni di memoria, in secondi. Il flag --time_partitioning_expiration è facoltativo. Per ulteriori informazioni, vedi Imposta la scadenza della partizione.
   • BOOLEAN: se true le query in questa tabella devono includere un filtro di partizionamento. Il flag --require_partition_filter è facoltativo. Per ulteriori informazioni, vedi Imposta i requisiti del filtro di partizionamento.
   • PROJECT_ID: l'ID del progetto. Se omesso, il progetto predefinito .
   • DATASET: il nome di un set di dati nel tuo progetto.
   • TABLE: il nome della tabella da creare.

   Per altre opzioni della riga di comando, consulta bq mk.

   L'esempio seguente crea una tabella partizionata denominata mytable sulla colonna ts, utilizzando il partizionamento orario. La scadenza della partizione è 259.200 secondi (3 giorni).

   bq mk \
      -t \
      --schema 'ts:TIMESTAMP,qtr:STRING,sales:FLOAT' \
      --time_partitioning_field ts \
      --time_partitioning_type HOUR \
      --time_partitioning_expiration 259200  \
      mydataset.mytable
   

Terraform

Utilizza la google_bigquery_table risorsa.

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

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una tabella partizionata denominata mytable al giorno:

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

  time_partitioning {
    type          = "DAY"
    field         = "Created"
    expiration_ms = 432000000 # 5 days
  }
  require_partition_filter = true

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

}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

1. Avvia Cloud Shell.

2. Imposta il progetto Google Cloud predefinito dove 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 in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory (inoltre chiamato modulo principale).

1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome del file deve contenere .tf, ad esempio main.tf. In questo tutorial, il file è 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 nuovo oggetto main.tf.

   Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

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

   terraform init

   Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade :

   terraform init -upgrade

Applica le modifiche

1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative:

   terraform plan

   Apporta le correzioni necessarie alla configurazione.

2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta:

   terraform apply

   Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". .

3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

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

API

Chiama il tables.insert con una risorsa di tabella definita che specifica la proprietà timePartitioning e la proprietà schema.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"time"

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

// createTablePartitioned demonstrates creating a table and specifying a time partitioning configuration.
func createTablePartitioned(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: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.IntegerFieldType},
		{Name: "date", Type: bigquery.DateFieldType},
	}
	metadata := &bigquery.TableMetadata{
		TimePartitioning: &bigquery.TimePartitioning{
			Field:      "date",
			Expiration: 90 * 24 * time.Hour,
		},
		Schema: sampleSchema,
	}
	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 nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TimePartitioning;

// Sample to create a partition table
public class CreatePartitionedTable {

  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";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING),
            Field.of("date", StandardSQLTypeName.DATE));
    createPartitionedTable(datasetName, tableName, schema);
  }

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

      TimePartitioning partitioning =
          TimePartitioning.newBuilder(TimePartitioning.Type.DAY)
              .setField("date") //  name of column to use for partitioning
              .setExpirationMs(7776000000L) // 90 days
              .build();

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

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

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

async function createTablePartitioned() {
  // Creates a new partitioned 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, Post_Abbr:string, Date:date';

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

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);
  console.log(`Table ${table.id} created with partitioning: `);
  console.log(table.metadata.timePartitioning);
}

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

from google.cloud import bigquery

client = bigquery.Client()

# Use format "your-project.your_dataset.your_table_name" for table_id
table_id = your_fully_qualified_table_id
schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
    bigquery.SchemaField("date", "DATE"),
]
table = bigquery.Table(table_id, schema=schema)
table.time_partitioning = bigquery.TimePartitioning(
    type_=bigquery.TimePartitioningType.DAY,
    field="date",  # name of column to use for partitioning
    expiration_ms=1000 * 60 * 60 * 24 * 90,
)  # 90 days

table = client.create_table(table)

print(
    f"Created table {table.project}.{table.dataset_id}.{table.table_id}, "
    f"partitioned on column {table.time_partitioning.field}."
)

Crea una tabella partizionata per data di importazione

Per creare una tabella partizionata per data di importazione vuota con una definizione di schema:

Console

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Espandi Azioni e fai clic su Apri.

4. Nel riquadro dei dettagli, fai clic su Crea tabella. .

5. Nella sezione Origine della pagina Crea tabella, seleziona Vuota. .

6. Nella sezione Destinazione:

   • In Nome set di dati, scegli il set di dati appropriato.
   • Nel campo Nome tabella, inserisci il nome della tabella.
   • Verifica che l'opzione Tipo di tabella sia impostata su Tabella nativa.

7. Nella sezione Schema, inserisci lo schema. definizione di Kubernetes.

8. Nella sezione Impostazioni di partizionamento e clustering, per Partizionamento, fai clic su Partizione in base all'ora di importazione.

9. (Facoltativo) Per richiedere un filtro di partizionamento su tutte le query per questa tabella: Seleziona la casella di controllo Richiedi filtro di partizione. Richiesta di una partizione può ridurre i costi e migliorare il rendimento. Per ulteriori informazioni, vedi Imposta i requisiti del filtro di partizionamento.

10. Fai clic su Crea tabella.

Nota: non puoi impostare la scadenza della partizione nella console Google Cloud. Per impostare la partizione dopo aver creato la tabella, vedi Aggiorna la scadenza della partizione.

SQL

Per creare una tabella partizionata per data di importazione, utilizza Dichiarazione CREATE TABLE con una clausola PARTITION BY che esegue la partizione su _PARTITIONDATE.

Nell'esempio seguente viene creata una tabella con partizioni giornaliere:

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

   Vai a BigQuery

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

   CREATE TABLE
     mydataset.newtable (transaction_id INT64)
   PARTITION BY
     _PARTITIONDATE
     OPTIONS (
       partition_expiration_days = 3,
       require_partition_filter = TRUE);
   

   Utilizzare la clausola OPTIONS per impostare opzioni della tabella come scadenza della partizione e i requisiti del filtro di partizione.

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

Il tipo di partizionamento predefinito per il partizionamento in fase di importazione è giornaliero il partizionamento orizzontale. Per specificare un tipo di partizionamento diverso, includi il comando DATE_TRUNC nella clausola PARTITION BY. Ad esempio, la seguente query crea una tabella con partizioni mensili:

CREATE TABLE
  mydataset.newtable (transaction_id INT64)
PARTITION BY
  DATE_TRUNC(_PARTITIONTIME, MONTH)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

bq

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

2. Utilizza la bq mk con il flag --table (o una scorciatoia -t):

   bq mk \
      --table \
      --schema SCHEMA \
      --time_partitioning_type UNIT_TIME \
      --time_partitioning_expiration EXPIRATION_TIME \
      --require_partition_filter=BOOLEAN  \
      PROJECT_ID:DATASET.TABLE
   

   Sostituisci quanto segue:

   • SCHEMA: una definizione nel formato column:data_type,column:data_type o il percorso di un file di schema JSON su della macchina locale. Per ulteriori informazioni, vedi Specifica di uno schema.
   • UNIT_TIME: il tipo di partizionamento. Valori supportati includono DAY, HOUR, MONTH o YEAR.
   • EXPIRATION_TIME: la data e l'ora di scadenza partizioni di memoria, in secondi. Il flag --time_partitioning_expiration è facoltativo. Per ulteriori informazioni, vedi Imposta la scadenza della partizione.
   • BOOLEAN: se true le query in questa tabella devono includere un filtro di partizionamento. Il flag --require_partition_filter è facoltativo. Per ulteriori informazioni, vedi Imposta i requisiti del filtro di partizionamento.
   • PROJECT_ID: l'ID del progetto. Se omesso, il progetto predefinito .
   • DATASET: il nome di un set di dati nel tuo progetto.
   • TABLE: il nome della tabella da creare.

   Per altre opzioni della riga di comando, consulta bq mk.

   L'esempio seguente crea una tabella partizionata per data di importazione denominato mytable. La tabella ha un partizionamento giornaliero, con una partizione una scadenza di 259.200 secondi (3 giorni).

   bq mk \
      -t \
      --schema qtr:STRING,sales:FLOAT,year:STRING \
      --time_partitioning_type DAY \
      --time_partitioning_expiration 259200 \
      mydataset.mytable
   

Terraform

Utilizza la google_bigquery_table risorsa.

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

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una tabella partizionata denominata mytable per data di importazione:

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

  time_partitioning {
    type          = "MONTH"
    expiration_ms = 604800000 # 7 days
  }
  require_partition_filter = true

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

}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

1. Avvia Cloud Shell.

2. Imposta il progetto Google Cloud predefinito dove 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 in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory (inoltre chiamato modulo principale).

1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome del file deve contenere .tf, ad esempio main.tf. In questo tutorial, il file è 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 nuovo oggetto main.tf.

   Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

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

   terraform init

   Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade :

   terraform init -upgrade

Applica le modifiche

1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative:

   terraform plan

   Apporta le correzioni necessarie alla configurazione.

2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta:

   terraform apply

   Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". .

3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

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

API

Chiama il tables.insert con una risorsa di tabella definita che specifica la proprietà timePartitioning e la proprietà schema.

crea una tabella partizionata con intervallo di numeri interi

Per creare una tabella partizionata con intervalli interi vuota con una definizione di schema:

Console

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Espandi Azioni e fai clic su Apri.

4. Nel riquadro dei dettagli, fai clic su Crea tabella. .

5. Nella sezione Origine della pagina Crea tabella, seleziona Vuota. .

6. Nella sezione Destinazione:

   • In Nome set di dati, scegli il set di dati appropriato.
   • Nel campo Nome tabella, inserisci il nome della tabella.
   • Verifica che l'opzione Tipo di tabella sia impostata su Tabella nativa.

7. Nella sezione Schema, inserisci la definizione dello schema. Assicurati che Lo schema include una colonna INTEGER per la colonna di partizionamento. Per ulteriori informazioni, vedi Specifica di uno schema.

8. Nella sezione Impostazioni di partizionamento e clustering, Nell'elenco a discesa Partizionamento, seleziona Partizionamento per campo e scegli la colonna di partizionamento. Questa opzione è disponibile solo se schema contiene una colonna INTEGER.

9. Fornisci i valori per Inizio, Fine e Intervallo:

   • Start (Inizio) indica l'inizio del primo intervallo di partizione (incluso).
   • End indica la fine dell'ultimo intervallo di partizioni (escluso).
   • Intervallo è la larghezza di ogni intervallo di partizione.

   I valori al di fuori di questi intervalli vengono inseriti in un __UNPARTITIONED__ speciale della partizione di testo.

10. (Facoltativo) Per richiedere un filtro di partizionamento su tutte le query per questa tabella: Seleziona la casella di controllo Richiedi filtro di partizione. Richiesta di una partizione può ridurre i costi e migliorare il rendimento. Per ulteriori informazioni, vedi Imposta i requisiti del filtro di partizionamento.

11. Fai clic su Crea tabella.

Nota: non puoi impostare la scadenza della partizione nella console Google Cloud. Per impostare la partizione dopo aver creato la tabella, vedi Aggiorna la scadenza della partizione.

SQL

Per creare una tabella partizionata con intervalli di numeri interi, utilizza CREATE TABLE Istruzione DDL con una clausola PARTITION BY.

L'esempio seguente crea una tabella partizionata in base Colonna customer_id con inizio 0, fine 100 e intervallo 10:

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

   Vai a BigQuery

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

   CREATE TABLE mydataset.newtable (customer_id INT64, date1 DATE)
   PARTITION BY
     RANGE_BUCKET(customer_id, GENERATE_ARRAY(0, 100, 10))
     OPTIONS (
       require_partition_filter = TRUE);
   

   Utilizzare la clausola OPTIONS per impostare opzioni della tabella come requisiti del filtro di partizione.

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

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

2. Utilizza la bq mk con il flag --table (o una scorciatoia -t):

   bq mk \
      --schema schema \
      --range_partitioning=COLUMN_NAME,START,END,INTERVAL \
      --require_partition_filter=BOOLEAN  \
      PROJECT_ID:DATASET.TABLE
   

   Sostituisci quanto segue:

   • SCHEMA: una definizione di schema incorporato nel formato column:data_type,column:data_type o il percorso di un file di schema JSON su della macchina locale. Per ulteriori informazioni, vedi Specifica di uno schema.
   • COLUMN_NAME: il nome della colonna di partizionamento. Nella tabella questa colonna deve essere di tipo INTEGER.
   • START: l'inizio del primo intervallo di partizione (incluso).
   • END: la fine dell'ultimo intervallo di partizione (escluso).
   • INTERVAL: la larghezza di ogni intervallo di partizione.
   • BOOLEAN: se true le query in questa tabella devono includere un filtro di partizionamento. Il flag --require_partition_filter è facoltativo. Per ulteriori informazioni, vedi Imposta i requisiti del filtro di partizionamento.
   • PROJECT_ID: l'ID del progetto. Se omesso, il progetto predefinito .
   • DATASET: il nome di un set di dati nel tuo progetto.
   • TABLE: il nome della tabella da creare.

   I valori al di fuori dell'intervallo di partizione vengono inseriti in un __UNPARTITIONED__ speciale della partizione di testo.

   Per altre opzioni della riga di comando, consulta bq mk.

   L'esempio seguente crea una tabella partizionata denominata mytable nella colonna customer_id.

   bq mk \
      -t \
      --schema 'customer_id:INTEGER,qtr:STRING,sales:FLOAT' \
      --range_partitioning=customer_id,0,100,10 \
      mydataset.mytable
   

Terraform

Utilizza la google_bigquery_table risorsa.

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

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una tabella partizionata denominata mytable per intervallo di numeri interi:

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

  range_partitioning {
    field = "ID"
    range {
      start    = 0
      end      = 1000
      interval = 10
    }
  }
  require_partition_filter = true

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

}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

1. Avvia Cloud Shell.

2. Imposta il progetto Google Cloud predefinito dove 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 in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory (inoltre chiamato modulo principale).

1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome del file deve contenere .tf, ad esempio main.tf. In questo tutorial, il file è 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 nuovo oggetto main.tf.

   Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

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

   terraform init

   Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade :

   terraform init -upgrade

Applica le modifiche

1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative:

   terraform plan

   Apporta le correzioni necessarie alla configurazione.

2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta:

   terraform apply

   Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". .

3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

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

API

Chiama il tables.insert con una risorsa di tabella definita che specifica la proprietà rangePartitioning e la proprietà schema.

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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.RangePartitioning;
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;

// Sample to create a range partitioned table
public class CreateRangePartitionedTable {

  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";
    Schema schema =
        Schema.of(
            Field.of("integerField", StandardSQLTypeName.INT64),
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL),
            Field.of("dateField", StandardSQLTypeName.DATE));
    createRangePartitionedTable(datasetName, tableName, schema);
  }

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

      // Note: The field must be a top- level, NULLABLE/REQUIRED field.
      // The only supported type is INTEGER/INT64
      RangePartitioning partitioning =
          RangePartitioning.newBuilder()
              .setField("integerField")
              .setRange(
                  RangePartitioning.Range.newBuilder()
                      .setStart(1L)
                      .setInterval(2L)
                      .setEnd(10L)
                      .build())
              .build();

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

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

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

async function createTableRangePartitioned() {
  // Creates a new integer range partitioned 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: 'fullName', type: 'STRING'},
    {name: 'city', type: 'STRING'},
    {name: 'zipcode', type: 'INTEGER'},
  ];

  // To use integer range partitioning, select a top-level REQUIRED or
  // NULLABLE column with INTEGER / INT64 data type. Values that are
  // outside of the range of the table will go into the UNPARTITIONED
  // partition. Null values will be in the NULL partition.
  const rangePartition = {
    field: 'zipcode',
    range: {
      start: 0,
      end: 100000,
      interval: 10,
    },
  };

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

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

  console.log(`Table ${table.id} created with integer range partitioning: `);
  console.log(table.metadata.rangePartitioning);
}

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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.range_partitioning = bigquery.RangePartitioning(
    # To use integer range partitioning, select a top-level REQUIRED /
    # NULLABLE column with INTEGER / INT64 data type.
    field="zipcode",
    range_=bigquery.PartitionRange(start=0, end=100000, interval=10),
)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

crea una tabella partizionata dal risultato di una query

Puoi creare una tabella partizionata a partire dai risultati di una query nei seguenti modi:

• In SQL, utilizza un'istruzione CREATE TABLE ... AS SELECT. Puoi utilizzare questo per creare una tabella partizionata per colonna dell'unità di tempo o numero intero ma non la data di importazione.
• Usa lo strumento a riga di comando bq o l'API BigQuery per impostare una tabella di destinazione per una query. Quando la query viene eseguita, BigQuery scrive i risultati nella tabella di destinazione. Puoi usare questo approccio per qualsiasi di partizionamento.

• Chiama il metodo API jobs.insert e specifica il partizionamento nel timePartitioning o rangePartitioning.

SQL

Utilizza la CREATE TABLE con un SELECT AS per la query. Includi un elemento PARTITION BY per configurare il partizionamento.

L'esempio seguente crea una tabella partizionata in base Colonna transaction_date:

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

   Vai a BigQuery

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

   CREATE TABLE
     mydataset.newtable (transaction_id INT64, transaction_date DATE)
   PARTITION BY
     transaction_date
   AS (
     SELECT
       transaction_id, transaction_date
     FROM
       mydataset.mytable
   );
   

   Utilizzare la clausola OPTIONS per impostare opzioni della tabella come requisiti del filtro di partizione.

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

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

2. Per creare una tabella partizionata da una query, utilizza il metodo Comando bq query con il flag --destination_table e --time_partitioning_type flag.

   Partizionamento delle colonne in base all'unità di tempo:

   bq query \
      --use_legacy_sql=false \
      --destination_table TABLE_NAME \
      --time_partitioning_field COLUMN \
      --time_partitioning_type UNIT_TIME \
      'QUERY_STATEMENT'
   

   Partizionamento in fase di importazione:

   bq query \
      --use_legacy_sql=false \
      --destination_table TABLE_NAME \
      --time_partitioning_type UNIT_TIME \
      'QUERY_STATEMENT'
   

   Partizionamento dell'intervallo di numeri interi:

   bq query \
      --use_legacy_sql=false \
      --destination_table PROJECT_ID:DATASET.TABLE \
      --range_partitioning COLUMN,START,END,INTERVAL \
      'QUERY_STATEMENT'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto. Se omesso, il progetto predefinito .
   • DATASET: il nome di un set di dati nel tuo progetto.
   • TABLE: il nome della tabella da creare.
   • COLUMN: il nome della colonna di partizionamento.
   • UNIT_TIME: il tipo di partizionamento. I valori supportati includono DAY, HOUR, MONTH o YEAR.
   • START: l'inizio del partizionamento dell'intervallo, incluso.
   • END: il partizionamento alla fine dell'intervallo, esclusivo.
   • INTERVAL: la larghezza di ogni intervallo all'interno della partizione.
   • QUERY_STATEMENT: la query utilizzata per compilare la tabella.

   L'esempio seguente crea una tabella partizionata in base transaction_date, utilizzando il partizionamento mensile.

   bq query \
      --use_legacy_sql=false \
      --destination_table mydataset.newtable \
      --time_partitioning_field transaction_date \
      --time_partitioning_type MONTH \
      'SELECT transaction_id, transaction_date FROM mydataset.mytable'
   

   L'esempio seguente crea una tabella partizionata in base Colonna customer_id, con il partizionamento dell'intervallo di numeri interi.

   bq query \
      --use_legacy_sql=false \
      --destination_table mydataset.newtable \
      --range_partitioning customer_id,0,100,10 \
      'SELECT * FROM mydataset.ponies'
   

   Per le tabelle partizionate in fase di importazione, puoi anche caricare i dati in un una partizione specifica decoratore della partizione. L'esempio seguente crea una nuova tabella partizionata per data di importazione carica i dati nella partizione 20180201 (1° febbraio 2018):

   bq query \
      --use_legacy_sql=false  \
      --time_partitioning_type=DAY \
      --destination_table='newtable$20180201' \
      'SELECT * FROM mydataset.mytable'
   

API

Per salvare i risultati della query in una tabella partizionata, chiama il metodo jobs.insert. Configura un job query. Specifica la tabella di destinazione nel destinationTable. Specifica il partizionamento nel timePartitioning o rangePartitioning.

Converti le tabelle con frazioni di data in tabelle partizionate in fase di importazione

Se in precedenza hai creato tabelle con frazioni di date, puoi convertire l'intero insieme le tabelle correlate in un'unica tabella partizionata per data di importazione utilizzando Comando partition nello strumento a riga di comando bq.

bq --location=LOCATION partition \
    --time_partitioning_type=PARTITION_TYPE \
    --time_partitioning_expiration INTEGER \
    PROJECT_ID:SOURCE_DATASET.SOURCE_TABLE \
    PROJECT_ID:DESTINATION_DATASET.DESTINATION_TABLE

Sostituisci quanto segue:

• LOCATION: il nome della tua sede. Il flag --location è facoltativo.
• PARTITION_TYPE: il tipo di partizione. Valori possibili includono DAY, HOUR, MONTH o YEAR.
• INTEGER: la scadenza della partizione, espressa in secondi. Non sono presenti il valore minimo. La scadenza corrisponde alla data UTC della partizione più il valore intero. Il flag time_partitioning_expiration è facoltativo.
• PROJECT_ID: l'ID progetto.
• SOURCE_DATASET: il set di dati che contiene le tabelle con frazioni di date.
• SOURCE_TABLE: il prefisso delle tabelle con frazionamento delle date.
• DESTINATION_DATASET; Il set di dati per la nuova tabella partizionata.
• DESTINATION_TABLE; Il nome della tabella partizionata da creare.

Il comando partition non supporta --label, --expiration, Flag --add_tags o --description. Puoi aggiungere etichette, una scadenza tag e una descrizione alla tabella dopo averla creata.

Quando esegui il comando partition, BigQuery crea un job di copia che genera partizioni dalle tabelle con sharding.

L'esempio seguente crea una tabella partizionata per data di importazione denominata mytable_partitioned da un insieme di tabelle con frazionamento di date preceduto da sourcetable_. La nuova tabella viene partizionata quotidianamente, con una scadenza per la partizione di 259.200 secondi (3 giorni).

bq partition \
    --time_partitioning_type=DAY \
    --time_partitioning_expiration 259200 \
    mydataset.sourcetable_ \
    mydataset.mytable_partitioned

Se le tabelle di cui è stato eseguito il frazionamento in base alla data erano sourcetable_20180126 e sourcetable_20180127, questo comando creerà le seguenti partizioni: mydataset.mytable_partitioned$20180126 e mydataset.mytable_partitioned$20180127.

Sicurezza delle tabelle partizionate

Il controllo dell'accesso per le tabelle partizionate è lo stesso del controllo dell'accesso per nelle tabelle standard. Per ulteriori informazioni, vedi Introduzione ai controlli di accesso alle tabelle.

Passaggi successivi

• Per scoprire come gestire e aggiornare le tabelle partizionate, consulta Gestione delle tabelle partizionate.
• Per informazioni sull'esecuzione di query su tabelle partizionate, consulta Esecuzione di query su tabelle partizionate.