Créer des tables partitionnées

Cette page explique comment créer des tables partitionnées dans BigQuery. Pour une vue d'ensemble des tables partitionnées, consultez la page Présentation des tables partitionnées.

Avant de commencer

Attribuez aux utilisateurs des rôles IAM (Identity and Access Management) incluant les autorisations nécessaires pour effectuer l'ensemble des tâches du présent document.

Autorisations requises

Pour créer une table, vous devez disposer des autorisations IAM suivantes :

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

En outre, vous pouvez avoir besoin de l'autorisation bigquery.tables.getData pour accéder aux données que vous écrivez dans la table.

Chacun des rôles IAM prédéfinis suivants inclut les autorisations dont vous avez besoin pour créer une table :

roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin (inclut l'autorisation bigquery.jobs.create)
roles/bigquery.user (inclut l'autorisation bigquery.jobs.create)
roles/bigquery.jobUser (inclut l'autorisation bigquery.jobs.create)

En outre, si vous disposez de l'autorisation bigquery.datasets.create, vous pouvez créer et mettre à jour des tables dans les ensembles de données que vous créez.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles prédéfinis et autorisations.

Créer une table partitionnée vide

Les étapes permettant de créer une table partitionnée dans BigQuery sont semblables à la création d'une table standard, à la différence que vous spécifiez les options de partitionnement et d'autres options de table.

Créer une table partitionnée par colonne d'unité de temps

Pour créer une table partitionnée par colonne d'unité de temps vide avec une définition de schéma, procédez comme suit :

Console

Dans la console Google Cloud, accédez à la page BigQuery.

Accéder à BigQuery
Dans le volet Explorateur, développez votre projet, puis sélectionnez un ensemble de données.
Dans la section Informations sur l'ensemble de données, cliquez sur Créer une table.
Dans le panneau Créer une table, spécifiez les détails suivants :

Dans la section Source, sélectionnez Table vide dans la liste Créer une table à partir de.
Dans la section Destination, spécifiez les détails suivants :
1. Pour Ensemble de données, sélectionnez l'ensemble de données dans lequel vous souhaitez créer la table.
2. Dans le champ Table, saisissez le nom de la table que vous souhaitez créer.
3. Vérifiez que le champ Type de table est défini sur Table native.
Dans la section Schéma, saisissez la définition du schéma. Le schéma doit inclure une colonne DATE, TIMESTAMP ou DATETIME pour la colonne de partitionnement. Pour en savoir plus, consultez la section Spécifier un schéma. Vous pouvez saisir les informations de schéma manuellement à l'aide de l'une des méthodes suivantes :
- Option 1 : Cliquez sur Modifier sous forme de texte et collez le schéma sous la forme d'un tableau JSON. Lorsque vous utilisez un tableau JSON, vous générez le schéma en utilisant le même processus que pour la création d'un fichier de schéma JSON. Vous pouvez afficher le schéma d'une table existante au format JSON en saisissant la commande suivante :
```
    bq show --format=prettyjson dataset.table
    
```
- Option 2 : Cliquez sur Ajouter un champ et saisissez le schéma de la table. Spécifiez le nom, le type et le mode de chaque champ.
Dans la section Paramètres de partitionnement et de clustering, dans la liste Partitionnement, sélectionnez Partition par champ, puis choisissez le partitionnement. Cette option n'est disponible que si le schéma contient une colonne DATE, TIMESTAMP ou DATETIME.
(Facultatif) Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Définir les exigences de filtrage des partitions.
Sélectionnez le Type de partitionnement pour choisir le partitionnement quotidien, horaire, mensuel ou annuel.
Facultatif: dans la section Options avancées si vous souhaitez utiliser une clé de chiffrement gérée par le client, sélectionnezUtiliser une clé de chiffrement gérée par le client (CMEK). Par défaut, BigQuery chiffre le contenu client stocké au repos à l'aide d'une clé gérée par Google.
Cliquez sur Créer une table.

SQL

Pour créer une table partitionnée par colonnes d'unités de temps, utilisez l'instruction LDD CREATE TABLE avec une clause PARTITION BY.

L'exemple suivant crée une table avec des partitions quotidiennes basées sur la colonne transaction_date :

Dans la console Google Cloud, accédez à la page BigQuery.

Accéder à BigQuery
Dans l'éditeur de requête, saisissez l'instruction suivante :
```
CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_date DATE)
PARTITION BY
  transaction_date
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);
```
Utilisez la clause OPTIONS pour définir les options de la table, telles que l'expiration de la partition et les exigences de filtrage des partitions.
Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez la page Exécuter une requête interactive.

Le type de partitionnement par défaut pour les colonnes DATE est le partitionnement quotidien. Pour spécifier un type de partitionnement différent, incluez la fonction DATE_TRUNC dans la clause PARTITION BY. Par exemple, la requête suivante crée une table avec des partitions mensuelles :

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);

Vous pouvez également spécifier une colonne TIMESTAMP ou DATETIME en tant que colonne de partitionnement. Dans ce cas, incluez la fonction TIMESTAMP_TRUNC ou DATETIME_TRUNC dans la clause PARTITION BY pour spécifier le type de partition. Par exemple, l'instruction suivante crée une table avec des partitions quotidiennes basées sur une colonne 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

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq mk avec l'option --table (ou le raccourci -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
```
Remplacez les éléments suivants :
- SCHEMA : définition de schéma au format column:data_type,column:data_type ou chemin d'accès à un fichier de schéma JSON sur votre ordinateur local. Pour en savoir plus, consultez la section Spécifier un schéma.
- COLUMN : nom de la colonne de partitionnement. Dans le schéma de la table, cette colonne doit être de type TIMESTAMP, DATETIME ou DATE.
- UNIT_TIME : type de partitionnement. Valeurs autorisées : DAY, HOUR, MONTH ou YEAR.
- EXPIRATION_TIME : délai d'expiration des partitions de la table, en secondes. L'option --time_partitioning_expiration est facultative. Pour en savoir plus, consultez la section Définir le délai d'expiration de la partition.
- BOOLEAN : si true, les requêtes de cette table doivent inclure un filtre de partition. L'option --require_partition_filter est facultative ; Pour en savoir plus, consultez la section Définir les exigences de filtrage des partitions.
- PROJECT_ID : ID du projet S'il est omis, votre projet par défaut est utilisé.
- DATASET : nom d'un ensemble de données dans votre projet.
- TABLE : nom de la table à créer.
Pour connaître les autres options de ligne de commande, consultez la section bq mk.

L'exemple suivant crée une table nommée mytable qui est partitionnée sur la colonne ts, à l'aide du partitionnement horaire. Le délai d'expiration du partitionnement est défini sur 259 200 secondes (trois jours).
```
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

Utilisez la ressource google_bigquery_table.

L'exemple suivant crée une table nommée mytable qui est partitionnée par jour :

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

}

Pour appliquer votre configuration Terraform dans un projet Google Cloud, suivez les procédures des sections suivantes.

Préparer Cloud Shell

Lancez Cloud Shell.
Définissez le projet Google Cloud par défaut dans lequel vous souhaitez appliquer vos configurations Terraform.

Vous n'avez besoin d'exécuter cette commande qu'une seule fois par projet et vous pouvez l'exécuter dans n'importe quel répertoire.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Les variables d'environnement sont remplacées si vous définissez des valeurs explicites dans le fichier de configuration Terraform.

Préparer le répertoire

Chaque fichier de configuration Terraform doit avoir son propre répertoire (également appelé module racine).

Dans Cloud Shell, créez un répertoire et un nouveau fichier dans ce répertoire. Le nom du fichier doit comporter l'extension .tf, par exemple main.tf. Dans ce tutoriel, le fichier est appelé main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Si vous suivez un tutoriel, vous pouvez copier l'exemple de code dans chaque section ou étape.

Copiez l'exemple de code dans le fichier main.tf que vous venez de créer.

Vous pouvez également copier le code depuis GitHub. Cela est recommandé lorsque l'extrait Terraform fait partie d'une solution de bout en bout.
Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
Enregistrez les modifications.
Initialisez Terraform. Cette opération n'est à effectuer qu'une seule fois par répertoire.
```
terraform init
```
Vous pouvez également utiliser la dernière version du fournisseur Google en incluant l'option -upgrade :
```
terraform init -upgrade
```

Appliquer les modifications

Examinez la configuration et vérifiez que les ressources que Terraform va créer ou mettre à jour correspondent à vos attentes :
```
terraform plan
```
Corrigez les modifications de la configuration si nécessaire.
Appliquez la configuration Terraform en exécutant la commande suivante et en saisissant yes lorsque vous y êtes invité :
```
terraform apply
```
Attendez que Terraform affiche le message "Apply completed!" (Application terminée).
Ouvrez votre projet Google Cloud pour afficher les résultats. Dans la console Google Cloud, accédez à vos ressources dans l'interface utilisateur pour vous assurer que Terraform les a créées ou mises à jour.

API

Appelez la méthode tables.insert avec une ressource de table définie qui spécifie les propriétés timePartitioning et schema.

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Go.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Java.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

// 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

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}."
)

Créer une table partitionnée par date d'ingestion

Pour créer une table partitionnée par date d'ingestion vide avec une définition de schéma, procédez comme suit :

Console

Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à BigQuery
Dans le panneau Explorateur, développez votre projet et sélectionnez un ensemble de données.
Développez l'option Actions puis cliquez sur Ouvrir.
Dans le panneau de détails, cliquez sur Créer une table.
Dans la section Source de la page Créer une table, sélectionnez Table vide.
Dans la section Destination :
- Sous Dataset name (Nom de l'ensemble de données), sélectionnez l'ensemble de données approprié.
- Dans le champ Nom de la table, saisissez le nom de la table.
- Vérifiez que Type de table est défini sur Table native.
Dans la section Schema (Schéma), saisissez la définition du schéma.
Dans la section Paramètres de partitionnement et de clustering, pour le champ Partitionnement, cliquez sur Partitionner par date d'ingestion.
(Facultatif) Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Définir les exigences de filtrage des partitions.
Cliquez sur Créer une table.

SQL

Pour créer une table partitionnée par date d'ingestion, utilisez l'instruction CREATE TABLE avec une clause PARTITION BY qui partitionne selon _PARTITIONDATE.

L'exemple suivant crée une table avec des partitions quotidiennes :

Dans la console Google Cloud, accédez à la page BigQuery.

Accéder à BigQuery
Dans l'éditeur de requête, saisissez l'instruction suivante :
```
CREATE TABLE
  mydataset.newtable (transaction_id INT64)
PARTITION BY
  _PARTITIONDATE
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);
```
Utilisez la clause OPTIONS pour définir les options de la table, telles que l'expiration de la partition et les exigences de filtrage des partitions.
Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez la page Exécuter une requête interactive.

Le type de partitionnement par défaut pour le partitionnement par date d'ingestion est le partitionnement quotidien. Pour spécifier un type de partitionnement différent, incluez la fonction DATE_TRUNC dans la clause PARTITION BY. Par exemple, la requête suivante crée une table avec des partitions mensuelles :

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

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq mk avec l'option --table (ou le raccourci -t) :
```
bq mk \
   --table \
   --schema SCHEMA \
   --time_partitioning_type UNIT_TIME \
   --time_partitioning_expiration EXPIRATION_TIME \
   --require_partition_filter=BOOLEAN  \
   PROJECT_ID:DATASET.TABLE
```
Remplacez les éléments suivants :
- SCHEMA : définition au format column:data_type,column:data_type ou chemin d'accès à un fichier de schéma JSON sur votre ordinateur local. Pour en savoir plus, consultez la section Spécifier un schéma.
- UNIT_TIME : type de partitionnement. Valeurs autorisées : DAY, HOUR, MONTH ou YEAR.
- EXPIRATION_TIME : délai d'expiration des partitions de la table, en secondes. L'option --time_partitioning_expiration est facultative. Pour en savoir plus, consultez la section Définir le délai d'expiration de la partition.
- BOOLEAN : si true, les requêtes de cette table doivent inclure un filtre de partition. L'option --require_partition_filter est facultative ; Pour en savoir plus, consultez la section Définir les exigences de filtrage des partitions.
- PROJECT_ID : ID du projet S'il est omis, votre projet par défaut est utilisé.
- DATASET : nom d'un ensemble de données dans votre projet.
- TABLE : nom de la table à créer.
Pour connaître les autres options de ligne de commande, consultez la section bq mk.

L'exemple suivant crée une table partitionnée par date d'ingestion nommée mytable. La table est partitionnée par jour, avec un délai d'expiration de partitionnement défini sur 259 200 secondes (trois jours).
```
bq mk \
   -t \
   --schema qtr:STRING,sales:FLOAT,year:STRING \
   --time_partitioning_type DAY \
   --time_partitioning_expiration 259200 \
   mydataset.mytable
```

Terraform

Utilisez la ressource google_bigquery_table.

L'exemple suivant crée une table nommée mytable qui est partitionnée par date d'ingestion :

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

}

Pour appliquer votre configuration Terraform dans un projet Google Cloud, suivez les procédures des sections suivantes.

Préparer Cloud Shell

Lancez Cloud Shell.
Définissez le projet Google Cloud par défaut dans lequel vous souhaitez appliquer vos configurations Terraform.

Vous n'avez besoin d'exécuter cette commande qu'une seule fois par projet et vous pouvez l'exécuter dans n'importe quel répertoire.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Les variables d'environnement sont remplacées si vous définissez des valeurs explicites dans le fichier de configuration Terraform.

Préparer le répertoire

Chaque fichier de configuration Terraform doit avoir son propre répertoire (également appelé module racine).

Dans Cloud Shell, créez un répertoire et un nouveau fichier dans ce répertoire. Le nom du fichier doit comporter l'extension .tf, par exemple main.tf. Dans ce tutoriel, le fichier est appelé main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Si vous suivez un tutoriel, vous pouvez copier l'exemple de code dans chaque section ou étape.

Copiez l'exemple de code dans le fichier main.tf que vous venez de créer.

Vous pouvez également copier le code depuis GitHub. Cela est recommandé lorsque l'extrait Terraform fait partie d'une solution de bout en bout.
Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
Enregistrez les modifications.
Initialisez Terraform. Cette opération n'est à effectuer qu'une seule fois par répertoire.
```
terraform init
```
Vous pouvez également utiliser la dernière version du fournisseur Google en incluant l'option -upgrade :
```
terraform init -upgrade
```

Appliquer les modifications

Examinez la configuration et vérifiez que les ressources que Terraform va créer ou mettre à jour correspondent à vos attentes :
```
terraform plan
```
Corrigez les modifications de la configuration si nécessaire.
Appliquez la configuration Terraform en exécutant la commande suivante et en saisissant yes lorsque vous y êtes invité :
```
terraform apply
```
Attendez que Terraform affiche le message "Apply completed!" (Application terminée).
Ouvrez votre projet Google Cloud pour afficher les résultats. Dans la console Google Cloud, accédez à vos ressources dans l'interface utilisateur pour vous assurer que Terraform les a créées ou mises à jour.

API

Appelez la méthode tables.insert avec une ressource de table définie qui spécifie les propriétés timePartitioning et schema.

Créer une table partitionnée par plages d'entiers

Pour créer une table partitionnée par plages d'entiers vide avec une définition de schéma, procédez comme suit :

Console

Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à BigQuery
Dans le panneau Explorateur, développez votre projet et sélectionnez un ensemble de données.
Développez l'option Actions puis cliquez sur Ouvrir.
Dans le panneau de détails, cliquez sur Créer une table.
Dans la section Source de la page Créer une table, sélectionnez Table vide.
Dans la section Destination :
- Sous Dataset name (Nom de l'ensemble de données), sélectionnez l'ensemble de données approprié.
- Dans le champ Nom de la table, saisissez le nom de la table.
- Vérifiez que Type de table est défini sur Table native.
Dans la section Schéma, saisissez la définition du schéma. Assurez-vous que le schéma inclut une colonne INTEGER pour la colonne de partitionnement. Pour en savoir plus, consultez la section Spécifier un schéma.
Dans la section Paramètres de partitionnement et de clustering, dans la liste déroulante Partitionnement, sélectionnez Partitionner par champ, puis choisissez la colonne de partitionnement. Cette option n'est disponible que si le schéma contient une colonne INTEGER.
Indiquez des valeurs pour Start, End et Interval :
- Start est le début de la première plage de partitions (inclusive).
- End est la fin de la dernière plage de partitions (exclusive).
- Interval est la largeur de chaque plage de partitions.
Les valeurs non comprises dans ces plages sont incluses dans une partition __UNPARTITIONED__ spéciale.
(Facultatif) Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Définir les exigences de filtrage des partitions.
Cliquez sur Créer une table.

SQL

Pour créer une table partitionnée par plages d'entiers, utilisez l'instruction LDD CREATE TABLE avec une clause PARTITION BY.

L'exemple suivant crée une table partitionnée dans la colonne customer_id avec les valeurs commençant par 0 et finissant par 100, avec un intervalle de 10 :

Dans la console Google Cloud, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

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);

Utilisez la clause OPTIONS pour définir les options de la table, telles que les exigences de filtrage des partitions.

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq mk avec l'option --table (ou le raccourci -t) :
```
bq mk \
   --schema schema \
   --range_partitioning=COLUMN_NAME,START,END,INTERVAL \
   --require_partition_filter=BOOLEAN  \
   PROJECT_ID:DATASET.TABLE
```
Remplacez les éléments suivants :
- SCHEMA : définition de schéma intégrée au format column:data_type,column:data_type ou le chemin d'accès à un fichier de schéma JSON sur votre machine locale. Pour en savoir plus, consultez la section Spécifier un schéma.
- COLUMN_NAME : nom de la colonne de partitionnement. Dans le schéma de la table, cette colonne doit être de type INTEGER.
- START : début de la première plage de partition (inclusive).
- END : fin de la dernière plage de partitions (exclusive).
- INTERVAL : largeur de chaque plage de partition.
- BOOLEAN : si true, les requêtes de cette table doivent inclure un filtre de partition. L'option --require_partition_filter est facultative ; Pour en savoir plus, consultez la section Définir les exigences de filtrage des partitions.
- PROJECT_ID : ID du projet S'il est omis, votre projet par défaut est utilisé.
- DATASET : nom d'un ensemble de données dans votre projet.
- TABLE : nom de la table à créer.
Les valeurs non comprises dans la plage de partitions sont incluses dans une partition __UNPARTITIONED__ spéciale.

Pour connaître les autres options de ligne de commande, consultez la section bq mk.

L'exemple suivant crée une table nommée mytable qui est partitionnée en fonction de la colonne customer_id.
```
bq mk \
   -t \
   --schema 'customer_id:INTEGER,qtr:STRING,sales:FLOAT' \
   --range_partitioning=customer_id,0,100,10 \
   mydataset.mytable
```

Terraform

Utilisez la ressource google_bigquery_table.

L'exemple suivant crée une table nommée mytable qui est partitionnée par plages d'entiers :

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

}

Pour appliquer votre configuration Terraform dans un projet Google Cloud, suivez les procédures des sections suivantes.

Préparer Cloud Shell

Lancez Cloud Shell.
Définissez le projet Google Cloud par défaut dans lequel vous souhaitez appliquer vos configurations Terraform.

Vous n'avez besoin d'exécuter cette commande qu'une seule fois par projet et vous pouvez l'exécuter dans n'importe quel répertoire.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Les variables d'environnement sont remplacées si vous définissez des valeurs explicites dans le fichier de configuration Terraform.

Préparer le répertoire

Chaque fichier de configuration Terraform doit avoir son propre répertoire (également appelé module racine).

Dans Cloud Shell, créez un répertoire et un nouveau fichier dans ce répertoire. Le nom du fichier doit comporter l'extension .tf, par exemple main.tf. Dans ce tutoriel, le fichier est appelé main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Si vous suivez un tutoriel, vous pouvez copier l'exemple de code dans chaque section ou étape.

Copiez l'exemple de code dans le fichier main.tf que vous venez de créer.

Vous pouvez également copier le code depuis GitHub. Cela est recommandé lorsque l'extrait Terraform fait partie d'une solution de bout en bout.
Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
Enregistrez les modifications.
Initialisez Terraform. Cette opération n'est à effectuer qu'une seule fois par répertoire.
```
terraform init
```
Vous pouvez également utiliser la dernière version du fournisseur Google en incluant l'option -upgrade :
```
terraform init -upgrade
```

Appliquer les modifications

Examinez la configuration et vérifiez que les ressources que Terraform va créer ou mettre à jour correspondent à vos attentes :
```
terraform plan
```
Corrigez les modifications de la configuration si nécessaire.
Appliquez la configuration Terraform en exécutant la commande suivante et en saisissant yes lorsque vous y êtes invité :
```
terraform apply
```
Attendez que Terraform affiche le message "Apply completed!" (Application terminée).
Ouvrez votre projet Google Cloud pour afficher les résultats. Dans la console Google Cloud, accédez à vos ressources dans l'interface utilisateur pour vous assurer que Terraform les a créées ou mises à jour.

API

Appelez la méthode tables.insert avec une ressource de table définie qui spécifie les propriétés rangePartitioning et schema.

Java

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

// 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

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)
)

Créer une table partitionnée à partir d'un résultat de requête

Vous pouvez créer une table partitionnée à partir d'un résultat de requête de plusieurs manières :

En SQL, utiliser une instruction CREATE TABLE ... AS SELECT. Vous pouvez utiliser cette approche pour créer une table partitionnée par colonnes d'unités de temps ou par plages d'entiers, mais pas par date d'ingestion.
Utiliser l'outil de ligne de commande bq ou l'API BigQuery pour définir une table de destination pour une requête. Lorsque la requête s'exécute, BigQuery écrit les résultats dans la table de destination. Vous pouvez utiliser cette approche pour n'importe quel type de partitionnement.
Appelez la méthode API jobs.insert et spécifiez le partitionnement dans la propriété timePartitioning ou la propriété rangePartitioning.

SQL

Utilisez l'instruction CREATE TABLE avec une clause SELECT AS pour la requête. Incluez une clause PARTITION BY pour configurer le partitionnement.

L'exemple suivant crée une table partitionnée dans la colonne transaction_date :

Dans la console Google Cloud, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

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

Utilisez la clause OPTIONS pour définir les options de la table, telles que les exigences de filtrage des partitions.

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Pour créer une table partitionnée à partir d'une requête, exécutez la commande bq query avec l'option --destination_table et l'option --time_partitioning_type.

Partitionnement par colonnes d'unités de temps :
```
bq query \
   --use_legacy_sql=false \
   --destination_table TABLE_NAME \
   --time_partitioning_field COLUMN \
   --time_partitioning_type UNIT_TIME \
   'QUERY_STATEMENT'
```
Partitionnement par date d'ingestion :
```
bq query \
   --use_legacy_sql=false \
   --destination_table TABLE_NAME \
   --time_partitioning_type UNIT_TIME \
   'QUERY_STATEMENT'
```
Partitionnement par plages d'entiers :
```
bq query \
   --use_legacy_sql=false \
   --destination_table PROJECT_ID:DATASET.TABLE \
   --range_partitioning COLUMN,START,END,INTERVAL \
   'QUERY_STATEMENT'
```
Remplacez les éléments suivants :
- PROJECT_ID : ID du projet. S'il est omis, votre projet par défaut est utilisé.
- DATASET : nom d'un ensemble de données dans votre projet.
- TABLE : nom de la table à créer.
- COLUMN : nom de la colonne de partitionnement.
- UNIT_TIME : type de partitionnement. Valeurs autorisées : DAY, HOUR, MONTH ou YEAR.
- START : valeur de début inclusive du partitionnement par plages.
- END : valeur de fin exclusive du partitionnement par plages.
- INTERVAL : largeur de chaque plage au sein de la partition.
- QUERY_STATEMENT : requête utilisée pour renseigner la table.
L'exemple suivant crée une table partitionnée suivant la colonne transaction_date, à l'aide du partitionnement mensuel.
```
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'exemple suivant crée une table partitionnée suivant la colonne customer_id, à l'aide du partitionnement par plages d'entiers.
```
bq query \
   --use_legacy_sql=false \
   --destination_table mydataset.newtable \
   --range_partitioning customer_id,0,100,10 \
   'SELECT * FROM mydataset.ponies'
```
Pour les tables partitionnées par date d'ingestion, vous pouvez également charger des données dans une partition spécifique à l'aide d'un décorateur de partition. L'exemple suivant crée une table partitionnée par date d'ingestion et charge des données dans la partition 20180201 (1er février 2018) :
```
bq query \
   --use_legacy_sql=false  \
   --time_partitioning_type=DAY \
   --destination_table='newtable$20180201' \
   'SELECT * FROM mydataset.mytable'
```

API

Pour enregistrer des résultats de requête dans une table partitionnée, appelez la méthode jobs.insert. Configurez une tâche query. Spécifiez la table de destination dans destinationTable. Spécifiez le partitionnement dans la propriété timePartitioning ou dans la propriété rangePartitioning.

Convertir des tables segmentées par date en tables partitionnées par date d'ingestion

Si vous avez déjà créé des tables segmentées par date, vous pouvez convertir l'ensemble des tables associées en une seule table partitionnée par date d'ingestion en exécutant la commande partition dans l'outil de ligne de commande 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

Remplacez les éléments suivants :

LOCATION : nom de votre emplacement. L'option --location est facultative.
PARTITION_TYPE : type de partition. Les valeurs possibles sont DAY, HOUR, MONTH ou YEAR.
INTEGER : délai d'expiration de la partition, en secondes. Il n'y a pas de valeur minimale. Le délai d'expiration correspond à la date UTC de la partition plus la valeur entière. L'option time_partitioning_expiration est facultative.
PROJECT_ID : ID de votre projet.
SOURCE_DATASET : ensemble de données contenant les tables segmentées par date.
SOURCE_TABLE : préfixe de vos tables segmentées par date.
DESTINATION_DATASET : ensemble de données pour la nouvelle table partitionnée.
DESTINATION_TABLE : nom de la table partitionnée à créer.

La commande partition ne fonctionne pas avec les options --label, --expiration, --add_tags ou --description. Vous pouvez ajouter des libellés, un délai d'expiration de la table, des tags et une description à la table après l'avoir créée.

Lorsque vous exécutez la commande partition, BigQuery crée une tâche de copie qui génère des partitions à partir des tables segmentées.

L'exemple suivant crée une table partitionnée par date d'ingestion nommée mytable_partitioned à partir d'un ensemble de tables segmentées par date avec le préfixe sourcetable_. La nouvelle table est partitionnée quotidiennement, avec un délai d'expiration de partitionnement de 259 200 secondes (trois jours).

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

Si les tables segmentées par date sont sourcetable_20180126 et sourcetable_20180127, cette commande crée les partitions suivantes : mydataset.mytable_partitioned$20180126 et mydataset.mytable_partitioned$20180127.

Sécurité des tables partitionnées

Le contrôle d'accès des tables partitionnées est identique à celui des tables standards. Pour plus d'informations, consultez la page Présentation des contrôles d'accès aux tables.

Étapes suivantes

Pour savoir comment gérer et mettre à jour des tables partitionnées, consultez la page Gérer des tables partitionnées.
Pour en savoir plus sur l'interrogation des tables partitionnées, consultez la page Interroger des tables partitionnées.