Spécifier un schéma

BigQuery vous permet de spécifier le schéma d'une table lorsque vous chargez des données dans une table et lorsque vous créez une table vide. Vous pouvez également utiliser la détection automatique de schéma pour les formats de données compatibles.

Lorsque vous chargez des fichiers d'exportation Avro, Parquet, ORC, Firestore ou Datastore, le schéma est automatiquement extrait des données sources auto-descriptives.

Vous pouvez spécifier le schéma d'une table de l'une des manières suivantes :

  • Spécifiez le schéma manuellement :
    • à l'aide de Cloud Console ;
    • à l'aide de l'UI Web classique de BigQuery ;
    • de façon intégrée à l'aide de l'interface de ligne de commande.
  • Créez un fichier de schéma au format JSON.
  • Appelez la méthode jobs.insert et configurez la propriété schema dans la configuration de la tâche load.
  • Appelez la méthode tables.insert et configurez le schéma dans la ressource de table à l'aide de la propriété schema.

Une fois les données chargées ou une table vide créée, vous pouvez modifier la définition de schéma de la table.

Composants du schéma

Lorsque vous spécifiez un schéma de table, vous devez fournir le nom et le type de données de chaque colonne. Vous pouvez éventuellement fournir la description et le mode d'une colonne.

Noms de colonne

Un nom de colonne ne doit contenir que des lettres (a-z, A-Z), des chiffres (0-9) et des traits de soulignement (_), et il doit commencer par une lettre ou un trait de soulignement. Sa longueur maximale est de 128 caractères. Un nom de colonne ne peut utiliser aucun des préfixes suivants :

  • _TABLE_
  • _FILE_
  • _PARTITION

Les noms de colonnes en double ne sont pas autorisés, même si la casse est différente. Par exemple, la colonne Column1 est considérée comme identique à la colonne column1.

Descriptions de colonne

Chaque colonne peut inclure une description facultative. La description est une chaîne qui ne doit pas contenir plus de 1 024 caractères.

Types de données du langage SQL standard

Le langage SQL standard de BigQuery vous permet de spécifier les types de données suivants dans votre schéma. Le type de données est un champ obligatoire.

Nom Type de données Description
Entier INT64 Valeurs numériques sans composants fractionnaires
Virgule flottante FLOAT64 Valeurs numériques approximatives avec composants fractionnaires
Numérique NUMERIC Valeurs numériques exactes avec composants fractionnaires
Booléen BOOL TRUE ou FALSE (non sensible à la casse)
Chaîne STRING Données de type caractères de longueur variable (Unicode)
Octets BYTES Données binaires de longueur variable
Date DATE Date de calendrier logique
Date/Heure DATETIME Année, mois, jour, heure, minute, seconde et milliseconde
Time TIME Heure indépendante d'une date précise
Temporel TIMESTAMP Point absolu dans le temps avec spécification de la microseconde
Type "Struct (Record)" STRUCT Conteneur de champs triés ayant chacun un type (obligatoire) et un nom de champ (facultatif)
Géographie GEOGRAPHY Ensemble de points sur la surface de la Terre (ensemble de points, de lignes et de polygones sur le sphéroïde de référence WGS84 avec des arêtes géodésiques)

Pour plus d'informations sur les types de données en langage SQL standard, consultez la page Types de données du langage SQL standard.

Vous pouvez également spécifier un type de tableau lorsque vous interrogez des données. Pour plus d'informations, consultez la section Utiliser des tableaux.

Modes

BigQuery accepte les modes suivants pour les colonnes. Le mode est un champ facultatif. Si le mode n'est pas spécifié, la valeur par défaut de la colonne est NULLABLE.

Mode Description
Nullable Colonne autorisant les valeurs NULL (paramètre par défaut)
Obligatoire Valeurs NULL non autorisées
Répété Colonne contenant un tableau de valeurs du type spécifié

Pour en savoir plus sur les modes, consultez la section mode sur la page TableFieldSchema.

Spécifier les schémas manuellement

Lorsque vous chargez des données ou créez une table vide, vous pouvez spécifier manuellement le schéma de la table à l'aide de Cloud Console, de l'UI Web classique de BigQuery ou de l'outil de ligne de commande. La spécification manuelle d'un schéma est acceptée pour le chargement des fichiers CSV et JSON (délimités par un retour à la ligne). Lorsque vous chargez des données d'exportation Avro, Parquet, ORC, Firestore ou Datastore, le schéma est automatiquement extrait des données sources auto-descriptives.

Pour spécifier manuellement un schéma de table, procédez comme suit :

Console

Dans Cloud Console, vous pouvez spécifier un schéma à l'aide de l'option Ajouter un champ ou de l'option Modifier sous forme de texte.

  1. Ouvrez l'UI Web de BigQuery dans Cloud Console.
    Accéder à Cloud Console

  2. Sélectionnez un jeu de données dans la section Ressources du panneau de navigation.

  3. Cliquez sur Créer une table dans la partie droite de la fenêtre.

    Créer une table

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

  5. Dans la section Destination de la page Créer une table :

    • Sous Nom de l'ensemble de données, sélectionnez l'ensemble de données approprié.

      Sélectionner un ensemble de données

    • Dans le champ Nom de la table, saisissez le nom de la table que vous créez.

    • Vérifiez que Table type (Type de table) est défini sur Native table (Table native).

  6. Dans la section Schéma, saisissez la définition du schéma.

    • Option 1 : Cliquez sur Ajouter un champ, puis définissez les valeurs Nom, Type et Mode de chaque champ. Dans Cloud Console, vous ne pouvez pas ajouter de description de champ lorsque vous utilisez l'option Ajouter un champ. Toutefois, vous pouvez ajouter des descriptions de champ manuellement dans l'interface utilisateur une fois vos données chargées.
    • Option 2 : 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.
  7. Cliquez sur Créer une table.

UI classique

Dans l'interface utilisateur Web classique de BigQuery, vous pouvez spécifier un schéma à l'aide de l'option Ajouter un champ ou de l'option Modifier sous forme de texte

  1. Accédez à l'UI Web de BigQuery.

    Accéder à l'UI Web de BigQuery

  2. Dans le volet de navigation, cliquez sur la flèche vers le bas Flèche vers le bas à côté du nom de l'ensemble de données, puis sur Créer une table.

  3. Sur la page Créer une table :

    • Dans la section Source data (Données sources), cliquez sur Create from source (Créer à partir de la source) si vous chargez des données ou cliquez sur Create empty table (Créer une table vide).
    • Dans la section Table de destination, choisissez votre ensemble de données et entrez le nom de la table dans le champ Nom de la table de destination.
    • Dans la section Schema (Schéma), choisissez l'une des options suivantes pour spécifier un schéma manuellement :

      • Option 1 : Cliquez sur Add Field (Ajouter un champ), puis définissez les valeurs Name (Nom), Type et Mode de chaque champ. Dans l'UI Web de BigQuery, vous ne pouvez pas ajouter de description de champ lorsque vous utilisez l'option Ajouter un champ. Toutefois, vous pouvez ajouter des descriptions de champ manuellement dans l'interface utilisateur une fois vos données chargées.

        Ajouter un schéma à l'aide de l'option d'ajout de champs

      • Option 2 : Cliquez sur Edit as text (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.

        Ajouter un schéma en tant que tableau JSON

    • Cliquez sur Créer une table.

bq

Fournissez manuellement le schéma intégré au format field:data_type,field:data_type à l'aide des commandes suivantes :

  • Commande load si vous chargez des données
  • Commande mk si vous créez une table vide

Lorsque vous spécifiez le schéma sur la ligne de commande, vous ne pouvez pas inclure de type RECORD (STRUCT) ni de description de colonne. Vous ne pouvez pas non plus spécifier le mode de la colonne. Tous les modes par défaut sont définis comme NULLABLE. Pour inclure des descriptions, des modes et des types RECORD, fournissez plutôt un fichier de schéma JSON.

Pour charger des données dans une table à l'aide d'une définition de schéma intégrée, entrez la commande load et spécifiez le format de données à l'aide de l'option --source_format. Si vous chargez des données dans une table d'un projet autre que votre projet par défaut, ajoutez l'ID du projet au format suivant : project_id:dataset.table_name.

(Facultatif) Spécifiez l'option --location et définissez la valeur correspondant à votre emplacement.

bq --location=location load \
--source_format=format \
project_id:dataset.table_name \
path_to_source \
schema

Remplacez les éléments suivants :

  • location : nom de votre emplacement. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
  • format : NEWLINE_DELIMITED_JSON ou CSV.
  • project_id:dataset.table_name : ID de votre projet.
  • project_id:dataset.table_name : ensemble de données contenant la table dans laquelle vous chargez des données.
  • project_id:dataset.table_name : nom de la table dans laquelle vous chargez des données.
  • path_to_source : emplacement du fichier de données CSV ou JSON sur votre ordinateur local ou dans Cloud Storage.
  • schema : définition de schéma intégrée.

Exemple :

Saisissez la commande suivante pour charger des données à partir d'un fichier CSV local nommé myfile.csv dans mydataset.mytable dans le projet par défaut. Le schéma est spécifié manuellement de façon intégrée :

bq load \
--source_format=CSV \
mydataset.mytable \
./myfile.csv \
qtr:STRING,sales:FLOAT,year:STRING

Pour plus d'informations sur le chargement des données dans BigQuery, consultez la page intitulée Présentation du chargement de données.

Pour spécifier une définition de schéma intégrée lorsque vous créez une table vide, saisissez la commande mk avec l'option --table ou -t. Si vous créez une table dans un projet autre que votre projet par défaut, ajoutez l'ID du projet à la commande au format suivant : project_id:dataset.table.

bq mk --table project_id:dataset.table schema

Remplacez les éléments suivants :

  • project_id : ID de votre projet.
  • dataset : un ensemble de données de votre projet.
  • table : nom de la table que vous créez.
  • schema : une définition de schéma intégrée.

Par exemple, la commande suivante crée une table vide nommée mytable dans votre projet par défaut. Le schéma est spécifié manuellement de façon intégrée.

bq mk --table mydataset.mytable qtr:STRING,sales:FLOAT,year:STRING

Pour plus d'informations sur la création d'une table vide, consultez la section Créer une table vide à l'aide d'une définition de schéma.

C#

Pour spécifier le schéma d'une table lorsque vous chargez des données dans une table :


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsJson
{
    public void LoadTableGcsJson(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.NewlineDelimitedJson
        };
        // Create and run job
        BigQueryJob loadJob = client.CreateLoadJob(
            sourceUri: gcsURI, destination: destinationTableRef,
            schema: schema, options: jobOptions);
        loadJob.PollUntilCompleted();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

Pour spécifier un schéma lorsque vous créez une table vide :


using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Go

Pour spécifier le schéma d'une table lorsque vous chargez des données dans une table :

import (
	"context"
	"fmt"

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

// importJSONExplicitSchema demonstrates loading newline-delimited JSON data from Cloud Storage
// into a BigQuery table and providing an explicit schema for the data.
func importJSONExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
	}
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty

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

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

Pour spécifier un schéma lorsque vous créez une table vide :

import (
	"context"
	"fmt"
	"time"

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

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(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: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

Python

Pour spécifier le schéma d'une table lorsque vous chargez des données dans une table, configurez la propriété LoadJobConfig.schema.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
]
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    dataset_ref.table("us_states"),
    location="US",  # Location must match that of the destination dataset.
    job_config=job_config,
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

destination_table = client.get_table(dataset_ref.table("us_states"))
print("Loaded {} rows.".format(destination_table.num_rows))

Pour spécifier un schéma lorsque vous créez une table vide, configurez la propriété Table.schema.

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", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

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

Spécifier un fichier de schéma JSON

Si vous préférez ne pas spécifier le schéma manuellement, vous pouvez créer un fichier de schéma JSON à utiliser avec l'interface de ligne de commande. Un fichier de schéma JSON consiste en un tableau JSON contenant les éléments suivants :

  • (Facultatif) Description de la colonne
  • Nom de la colonne
  • Type de données de la colonne
  • (Facultatif) Mode de la colonne (si aucune valeur n'est spécifiée, le mode par défaut est NULLABLE)

Créer un fichier de schéma JSON

Pour créer un fichier de schéma JSON, entrez les informations suivantes à l'aide d'un éditeur de texte approprié :

[
 {
   "description": "[DESCRIPTION]",
   "name": "[NAME]",
   "type": "[TYPE]",
   "mode": "[MODE]"
 },
 {
   "description": "[DESCRIPTION]",
   "name": "[NAME]",
   "type": "[TYPE]",
   "mode": "[MODE]"
 }
]

Le tableau JSON est indiqué par les crochets de début et de fin []. Chaque entrée de colonne doit être séparée par une virgule "},".

Vous pouvez écrire un schéma de table existant dans un fichier local en saisissant la commande suivante :

bq show \
--schema \
--format=prettyjson \
project_id:dataset.table > path_to_file

Vous pouvez utiliser le fichier de sortie comme point de départ pour votre propre fichier de schéma JSON. Si vous utilisez cette approche, assurez-vous que le fichier ne contient que le tableau JSON qui représente le schéma de la table.

Par exemple, le tableau JSON suivant représente un schéma de table de base. Ce schéma comporte trois colonnes : qtr (REQUIRED STRING), rep (NULLABLE STRING) et sales (NULLABLE FLOAT).

[
  {
    "description": "quarter",
    "mode": "REQUIRED",
    "name": "qtr",
    "type": "STRING"
  },
  {
    "description": "sales representative",
    "mode": "NULLABLE",
    "name": "rep",
    "type": "STRING"
  },
  {
    "description": "total sales",
    "mode": "NULLABLE",
    "name": "sales",
    "type": "FLOAT"
  }
]

Utiliser un fichier de schéma JSON

Une fois le fichier de schéma JSON créé, vous pouvez le spécifier sur la ligne de commande. Vous ne pouvez pas utiliser un fichier de schéma avec Cloud Console, l'UI Web classique de BigQuery ou l'API.

Fournissez le fichier de schéma manuellement à l'aide des éléments suivants :

  • Commande load si vous chargez des données
  • Commande mk si vous créez une table vide

Lorsque vous fournissez un fichier de schéma JSON, il doit être stocké dans un emplacement local accessible en lecture. Vous ne pouvez pas spécifier un fichier de schéma JSON stocké dans Cloud Storage ou Drive.

Spécifier un fichier de schéma lors du chargement de données

La commande suivante charge des données dans une table à l'aide de la définition de schéma d'un fichier JSON :

bq --location=location load \
--source_format=format \
project_id:dataset.table \
path_to_data_file \
path_to_schema_file

Remplacez les éléments suivants :

  • location : nom de votre emplacement. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement à l'aide du fichier .bigqueryrc.
  • format : NEWLINE_DELIMITED_JSON ou CSV.
  • project_id : ID de votre projet.
  • dataset : ensemble de données contenant la table dans laquelle vous chargez des données.
  • table : nom de la table dans laquelle vous chargez des données.
  • path_to_data_file : emplacement du fichier de données CSV ou JSON sur votre ordinateur local ou dans Cloud Storage.
  • path_to_schema_file : chemin d'accès du fichier de schéma sur votre ordinateur local.

Exemple :

Saisissez la commande suivante pour charger des données à partir d'un fichier CSV local nommé myfile.csv dans mydataset.mytable dans le projet par défaut. Le schéma est spécifié dans myschema.json.

bq load --source_format=CSV mydataset.mytable ./myfile.csv ./myschema.json

Spécifier un fichier de schéma lors de la création d'une table

La commande suivante crée une table vide dans un ensemble de données existant en utilisant la définition de schéma d'un fichier JSON :

bq mk --table project_id:dataset.table path_to_schema_file

Remplacez les éléments suivants :

  • project_id : ID de votre projet.
  • dataset : un ensemble de données de votre projet.
  • table : nom de la table que vous créez.
  • path_to_schema_file : chemin d'accès du fichier de schéma sur votre ordinateur local.

Par exemple, la commande suivante crée une table nommée mytable dans mydataset dans votre projet par défaut. Le schéma est spécifié dans myschema.json :

bq mk --table mydataset.mytable ./myschema.json

Spécifier un schéma dans l'API

Pour spécifier un schéma de table à l'aide de l'API, procédez comme suit :

  • Pour spécifier un schéma lorsque vous chargez des données, appelez la méthode jobs.insert et configurez la propriété schema dans la ressource JobConfigurationLoad.

  • Pour spécifier un schéma lorsque vous créez une table, appelez la méthode tables.insert et configurez la propriété schema dans la ressource Table.

La spécification d'un schéma à l'aide de l'API est similaire au processus de création d'un fichier de schéma JSON.

Étapes suivantes