Créer des tables partitionnées

Console

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

   Accéder à BigQuery

2. Dans le volet Explorer, développez votre projet, puis sélectionnez un ensemble de données.
3. Dans la section Informations sur l'ensemble de données, cliquez sur add_box Créer une table.
4. Dans le panneau Créer une table, spécifiez les détails suivants :
1. Dans la section Source, sélectionnez Table vide dans la liste Créer une table à partir de.
2. 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.
3. 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 add_box Ajouter un champ et saisissez le schéma de la table. Spécifiez le nom, le type et le mode de chaque champ.
4. 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.
5. (Facultatif) Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Un filtre de partitionnement 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.
6. Sélectionnez le Type de partitionnement pour choisir le partitionnement quotidien, horaire, mensuel ou annuel.
7. 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é appartenant à Google et gérée par Google.
8. 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 :

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

   Accéder à BigQuery

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

3. Cliquez sur play_circle Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez 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

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

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.

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

1. Lancez Cloud Shell.

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

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

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

3. Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
4. Enregistrez les modifications.
5. 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

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

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

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

Accéder

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

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

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

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

Console

1. Ouvrez la page BigQuery dans la console Google Cloud.

   Accéder à BigQuery

2. Dans le panneau Explorer, développez votre projet et sélectionnez un ensemble de données.

3. Développez l'option more_vert Actions puis cliquez sur Ouvrir.

4. Dans le panneau de détails, cliquez sur Créer une tableadd_box.

5. Dans la section Source de la page Créer une table, sélectionnez Table vide.

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

7. Dans la section Schema (Schéma), saisissez la définition du schéma.

8. Dans la section Paramètres de partitionnement et de clustering, pour le champ Partitionnement, cliquez sur Partitionner par date d'ingestion.

9. (Facultatif) Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Exiger un filtre de partitionnement 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.

10. 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 :

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

   Accéder à BigQuery

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

3. Cliquez sur play_circle Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez 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

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

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.

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

1. Lancez Cloud Shell.

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

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

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

3. Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
4. Enregistrez les modifications.
5. 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

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

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

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

Console

1. Ouvrez la page BigQuery dans la console Google Cloud.

   Accéder à BigQuery

2. Dans le panneau Explorer, développez votre projet et sélectionnez un ensemble de données.

3. Développez l'option more_vert Actions puis cliquez sur Ouvrir.

4. Dans le panneau de détails, cliquez sur Créer une tableadd_box.

5. Dans la section Source de la page Créer une table, sélectionnez Table vide.

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

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

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

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

10. (Facultatif) Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Exiger un filtre de partitionnement 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.

11. 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 :

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

   Accéder à BigQuery

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

3. Cliquez sur play_circle Exécuter.

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

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

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.

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

1. Lancez Cloud Shell.

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

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

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

3. Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
4. Enregistrez les modifications.
5. 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

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

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

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

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 :

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

   Accéder à BigQuery

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

3. Cliquez sur play_circle Exécuter.

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

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