Creazione delle tabelle partizionate

Questa pagina descrive come creare tabelle partizionate in BigQuery. Per una panoramica delle tabelle partizionate, consulta Introduzione alle tabelle partizionate.

Prima di iniziare

Concedi i ruoli IAM (Identity and Access Management) che concedono agli utenti le autorizzazioni necessarie per eseguire ogni 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 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, consulta Ruoli e autorizzazioni predefiniti.

Creare una tabella partizionata vuota

I passaggi per creare una tabella partizionata in BigQuery sono simili alla creazione di una tabella standard, tranne per il fatto che specifichi le opzioni di partizione, oltre a qualsiasi altra opzione della tabella.

Creare una tabella partizionata per colonne di unità di tempo

Per creare una tabella partizionata per 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 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 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. Lo schema deve includere una colonna DATE, TIMESTAMP o DATETIME per la colonna di partizione. Per ulteriori informazioni, consulta Specificare uno schema. Puoi inserire manualmente le informazioni dello schema utilizzando uno dei seguenti metodi:
      • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando la stessa procedura utilizzata per creare un file di schema JSON. Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo il seguente comando: 
            bq show --format=prettyjson dataset.table
      • Opzione 2: fai clic su Aggiungi campo e inserisci lo schema della tabella. Specifica Nome, Tipo e Modalità di ogni campo.
    4. Nella sezione Impostazioni di cluster e partizionamento, nell'elenco Partizionamento, seleziona Partiziona per campo e poi scegli la colonna di partizionamento. Questa opzione è disponibile solo se lo schema contiene una colonna DATE, TIMESTAMP o DATETIME.
    5. (Facoltativo) Per richiedere un filtro di partizione per tutte le query per questa tabella, seleziona la casella di controllo Richiedi filtro di partizione. Un filtro di partizionamento può ridurre i costi e migliorare le prestazioni. Per maggiori informazioni, consulta Impostare i requisiti del filtro delle partizioni.
    6. Seleziona il Tipo di partizione per scegliere la partizione giornaliera, oraria, mensile o annuale.
    7. (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 in stato inattivo utilizzando una chiave di proprietà di Google e gestita da Google.
    8. Fai clic su Crea tabella.

SQL

Per creare una tabella partizionata per colonne di unità di tempo, utilizza l'istruzione DDL CREATE TABLE con una clausola PARTITION BY.

L'esempio seguente crea una tabella con partizioni giornaliere in base alla colonnatransaction_date:

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

    Vai a BigQuery

  2. Nell'editor di 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);

    Utilizza la clausola OPTIONS per impostare le opzioni della tabella, ad esempio la scadenza della partizione e i requisiti del filtro di partizione.

  3. Fai clic su Esegui.

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

Il tipo di partizionamento predefinito per le colonne DATE è il partizionamento giornaliero. Per specificare un tipo di partizionamento diverso, includi la funzione 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 colonna di suddivisione. In questo caso, includi la funzione TIMESTAMP_TRUNC o DATETIME_TRUNC nella clausola PARTITION BY per specificare il tipo di partizione. Ad esempio, la seguente istruzione crea una tabella con partizioni giornaliere basate su 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. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Utilizza il comando bq mk con il flag --table (o la 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: una definizione di schema nel formato column:data_type,column:data_type o il percorso di un file schema JSON sulla tua macchina locale. Per ulteriori informazioni, consulta la sezione Specificare uno schema.
    • COLUMN: il nome della colonna di partizione. Nello schema della tabella, questa colonna deve essere di tipo TIMESTAMP, DATETIME o DATE.
    • UNIT_TIME: il tipo di partizionamento. I valori supportati includono DAY, HOUR, MONTH o YEAR.
    • EXPIRATION_TIME: la data e l'ora di scadenza delle partizioni della tabella, in secondi. Il flag --time_partitioning_expiration è facoltativo. Per ulteriori informazioni, consulta Impostare la scadenza della partizione.
    • BOOLEAN: se true, le query su questa tabella devono includere un filtro di partizione. Il flag --require_partition_filter è facoltativo. Per ulteriori informazioni, consulta Impostare i requisiti del filtro delle partizioni.
    • PROJECT_ID: l'ID progetto. Se omesso, viene utilizzato il progetto predefinito.
    • DATASET: il nome di un set di dati nel progetto.
    • TABLE: il nome della tabella da creare.

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

    L'esempio seguente crea una tabella denominata mytable suddivisa sulla colonna ts utilizzando la suddivisione ogni ora. La scadenza della partizione è di 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 risorsa google_bigquery_table.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Il seguente esempio crea una tabella denominata mytable partizionata in base 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 in un progetto Google Cloud, completa i passaggi nelle seguenti sezioni.

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 farlo 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 una propria directory (chiamata anche modulo principale).

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

    Se vuoi, copia il codice da GitHub. Questa 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

    Se vuoi, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade: 

    terraform init -upgrade

Applica le modifiche

  1. Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative: 
    terraform plan

    Apporta le correzioni necessarie alla configurazione.

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

    Attendi che Terraform mostri il messaggio "Applicazione completata".

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

API

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

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, 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.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 di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, 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 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 di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 dello schema:

Console

  1. Apri la pagina BigQuery nella console Google Cloud.

    Vai alla pagina BigQuery

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

  3. Espandi l'opzione 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 Tabella vuota.

  6. Nella sezione Destinazione:

    • Per Nome set di dati, scegli il set di dati appropriato.
    • Nel campo Nome tabella, inserisci il nome della tabella.
    • Verifica che Tipo di tabella sia impostato su Tabella nativa.

  7. Nella sezione Schema, inserisci la definizione dello schema.

  8. Nella sezione Impostazioni di cluster e partizionamento, per Partizionamento, fai clic su Partiziona per data di importazione.

  9. (Facoltativo) Per richiedere un filtro di partizione per tutte le query per questa tabella, selezionate la casella di controllo Richiedi filtro di partizione. Se il filtro di partizionamento è obbligatorio, gli utenti devono includere una clausola WHERE che specifichi le partizioni su cui eseguire la query. L'utilizzo di un filtro di partizionamento può ridurre i costi e migliorare le prestazioni. Per ulteriori informazioni, consulta Impostare i requisiti del filtro delle partizioni.

  10. Fai clic su Crea tabella.

SQL

Per creare una tabella partizionata per data di importazione, utilizza l'istruzione CREATE TABLE con una clausola PARTITION BY che esegue la partizione in base a _PARTITIONDATE.

L'esempio seguente crea una tabella con partizioni giornaliere:

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

    Vai a BigQuery

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

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

    Utilizza la clausola OPTIONS per impostare le opzioni della tabella, ad esempio la scadenza della partizione e i requisiti del filtro di partizione.

  3. Fai clic su Esegui.

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

Il tipo di partizionamento predefinito per il partizionamento in base all'ora di importazione è il partitioning giornaliero. Per specificare un tipo di partizionamento diverso, includi la funzione 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. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Utilizza il comando bq mk con il flag --table (o la 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 formatocolumn:data_type,column:data_type o il percorso di un file dello schema JSON sul tuo computer locale. Per ulteriori informazioni, consulta la sezione Specificare uno schema.
    • UNIT_TIME: il tipo di partizionamento. I valori supportati includono DAY, HOUR, MONTH o YEAR.
    • EXPIRATION_TIME: la data e l'ora di scadenza delle partizioni della tabella, in secondi. Il flag --time_partitioning_expiration è facoltativo. Per ulteriori informazioni, consulta Impostare la scadenza della partizione.
    • BOOLEAN: se true, le query su questa tabella devono includere un filtro di partizione. Il flag --require_partition_filter è facoltativo. Per ulteriori informazioni, consulta Impostare i requisiti del filtro delle partizioni.
    • PROJECT_ID: l'ID progetto. Se omesso, viene utilizzato il progetto predefinito.
    • DATASET: il nome di un set di dati nel 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 denominata mytable. La tabella è partizionata su base giornaliera, con una scadenza della partizione 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 risorsa google_bigquery_table.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Il seguente esempio crea una tabella denominata mytable partizionata 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 in un progetto Google Cloud, completa i passaggi nelle seguenti sezioni.

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 farlo 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 una propria directory (chiamata anche modulo principale).

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

    Se vuoi, copia il codice da GitHub. Questa 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

    Se vuoi, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade: 

    terraform init -upgrade

Applica le modifiche

  1. Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative: 
    terraform plan

    Apporta le correzioni necessarie alla configurazione.

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

    Attendi che Terraform mostri il messaggio "Applicazione completata".

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

API

Chiama il metodo tables.insert con una risorsa 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 intervallo di numeri interi vuota con una definizione dello schema:

Console

  1. Apri la pagina BigQuery nella console Google Cloud.

    Vai alla pagina BigQuery

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

  3. Espandi l'opzione 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 Tabella vuota.

  6. Nella sezione Destinazione:

    • Per Nome set di dati, scegli il set di dati appropriato.
    • Nel campo Nome tabella, inserisci il nome della tabella.
    • Verifica che Tipo di tabella sia impostato su Tabella nativa.

  7. Nella sezione Schema, inserisci la definizione dello schema. Assicurati che lo schema includa una colonna INTEGER per la colonna di partizionamento. Per maggiori informazioni, consulta Specificare uno schema.

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

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

    • Inizio è l'inizio dell'intervallo della prima partizione (incluso).
    • Fine è la fine dell'ultimo intervallo di partizione (esclusivo).
    • Intervallo è la larghezza di ogni intervallo di partizione.

    I valori al di fuori di questi intervalli vengono inseriti in una partizione __UNPARTITIONED__ speciale.

  10. (Facoltativo) Per richiedere un filtro di partizione per tutte le query per questa tabella, selezionate la casella di controllo Richiedi filtro di partizione. Se il filtro di partizionamento è obbligatorio, gli utenti devono includere una clausola WHERE che specifichi le partizioni su cui eseguire la query. L'utilizzo di un filtro di partizionamento può ridurre i costi e migliorare le prestazioni. Per ulteriori informazioni, consulta Impostare i requisiti del filtro delle partizioni.

  11. Fai clic su Crea tabella.

SQL

Per creare una tabella partizionata con intervallo di numeri interi, utilizza l'istruzione DDL CREATE TABLE con una clausola PARTITION BY.

L'esempio seguente crea una tabella partizionata in base alla 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 di 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);

    Utilizza la clausola OPTIONS per impostare le opzioni della tabella, ad esempio i requisiti dei filtri di partizione.

  3. Fai clic su Esegui.

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

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Utilizza il comando bq mk con il flag --table (o la 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 in linea nel formatocolumn:data_type,column:data_type o il percorso di un file dello schema JSON sul tuo computer locale. Per ulteriori informazioni, consulta la sezione Specificare uno schema.
    • COLUMN_NAME: il nome della colonna di partizione. Nello schema della 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 (esclusivo).
    • INTERVAL: la larghezza di ogni intervallo di partizione.
    • BOOLEAN: se true, le query su questa tabella devono includere un filtro di partizione. Il flag --require_partition_filter è facoltativo. Per ulteriori informazioni, consulta Impostare i requisiti del filtro delle partizioni.
    • PROJECT_ID: l'ID progetto. Se omesso, viene utilizzato il progetto predefinito.
    • DATASET: il nome di un set di dati nel progetto.
    • TABLE: il nome della tabella da creare.

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

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

    Il seguente esempio crea una tabella denominata mytable suddivisa in base alla 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 risorsa google_bigquery_table.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

L'esempio seguente crea una tabella denominata mytable partizionata in base a un 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 in un progetto Google Cloud, completa i passaggi nelle seguenti sezioni.

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 farlo 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 una propria directory (chiamata anche modulo principale).

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

    Se vuoi, copia il codice da GitHub. Questa 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

    Se vuoi, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade: 

    terraform init -upgrade

Applica le modifiche

  1. Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative: 
    terraform plan

    Apporta le correzioni necessarie alla configurazione.

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

    Attendi che Terraform mostri il messaggio "Applicazione completata".

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

API

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

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, 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.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 di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, 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 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 di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

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

Creare una tabella partizionata da un risultato di query

Puoi creare una tabella partizionata da un risultato di query nei seguenti modi:

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

  • Chiama il metodo dell'API jobs.insert e specifica il partizionamento nella proprietà timePartitioning o nella proprietà rangePartitioning.

SQL

Utilizza l'istruzione CREATE TABLE. Includi una clausola PARTITION BY per configurare il partizionamento.

L'esempio seguente crea una tabella partizionata in base alla colonnatransaction_date:

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

    Vai a BigQuery

  2. Nell'editor di 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
);

    Utilizza la clausola OPTIONS per impostare le opzioni della tabella, ad esempio i requisiti dei filtri di partizione.

  3. Fai clic su Esegui.

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

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

    Partizionamento per colonne di 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 per data di importazione:

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

    Partizionamento per intervalli 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 progetto. Se omesso, viene utilizzato il progetto predefinito.
    • DATASET: il nome di un set di dati nel progetto.
    • TABLE: il nome della tabella da creare.
    • COLUMN: il nome della colonna di partizione.
    • UNIT_TIME: il tipo di partizionamento. I valori supportati includono DAY, HOUR, MONTH o YEAR.
    • START: l'inizio del partizionamento degli intervalli, incluso.
    • END: la fine del partizionamento dell'intervallo, esclusa.
    • 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 alla colonna transaction_date, utilizzando la partizione 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 alla colonna customer_id utilizzando la suddivisione in base a intervalli 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 per data di importazione, puoi anche caricare i dati in una partizione specifica utilizzando un decoratore partizione. Il seguente esempio crea una nuova tabella partizionata per data di importazione e 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 in destinationTable. Specifica la suddivisione nella proprietà timePartitioning o nella proprietà rangePartitioning.

Convertire le tabelle con suddivisione in base alla data in tabelle partizionate per data di importazione

Se in precedenza hai creato tabelle con suddivisione in base alla data, puoi convertire l'intero insieme di tabelle correlate in un'unica tabella partizionata per data di importazione#39;importazione utilizzando il 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 località. Il flag --location è facoltativo.
  • PARTITION_TYPE: il tipo di partizione. I valori possibili includono DAY, HOUR, MONTH o YEAR.
  • INTEGER: la data e l'ora di scadenza della partizione, in secondi. Non è previsto un valore minimo. La data e l'ora di scadenza vengono valutate come la data UTC della partizione più il valore intero. Il flag time_partitioning_expiration è facoltativo.
  • PROJECT_ID: l'ID del tuo progetto.
  • SOURCE_DATASET: il set di dati che contiene le tabelle con suddivisione in parti in base alla data.
  • SOURCE_TABLE: il prefisso delle tabelle con suddivisione in parti in base alla data.
  • 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 i flag --label, --expiration, --add_tags o --description. Puoi aggiungere etichette, una scadenza della tabella, 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 suddivise in parti.

Il seguente esempio crea una tabella partizionata per data di importazione denominata mytable_partitioned da un insieme di tabelle con suddivisione in base alla data con prefisso sourcetable_. La nuova tabella viene partizionata ogni giorno, con una scadenza della 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 con partizione in base alla data fossero sourcetable_20180126 e sourcetable_20180127, questo comando creerebbe le seguenti partizioni: mydataset.mytable_partitioned$20180126 e mydataset.mytable_partitioned$20180127.

Sicurezza delle tabelle partizionate

Il controllo dell'accesso per le tabelle partizionate è uguale al controllo dell'accesso per le tabelle standard. Per ulteriori informazioni, consulta Introduzione ai controlli di accesso alle tabelle.

Passaggi successivi