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 des manières suivantes :

Spécifiez le schéma manuellement :
- à l'aide de Cloud Console ;
- de façon intégrée à l'aide de l'outil de ligne de commande bq.
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 également 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
BigNumeric (aperçu)	`BIGNUMERIC`	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 en savoir plus sur les types de données en SQL standard, consultez la page Types de données en 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 ligne mode de la section 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 ou de l'outil de ligne de commande bq. La spécification manuelle d'un schéma est acceptée pour le chargement des fichiers CSV et JSON (délimité par une nouvelle 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.

Ouvrez la page BigQuery dans Cloud Console.

Accéder à BigQuery
Dans le panneau Explorateur, développez votre projet et sélectionnez un ensemble de données.

Remarque : L'expérience par défaut est l'aperçu de Cloud Console. Si vous avez cliqué sur Hide preview features (Masquer les fonctionnalités d'aperçu) pour accéder à la page Disponibilité générale de Cloud Console, procédez comme suit : dans le panneau de navigation, dans la section Ressources, développez votre projet et sélectionnez un ensemble de données.
Dans le panneau de détails, cliquez sur Create table (Créer une table).
Dans la section Source de la page Créer une table, sélectionnez Table vide.
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é.
- 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).
Dans la section Schema (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 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.
Cliquez sur Create table (Créer une table).

bq

Fournissez manuellement le schéma intégré au format field:data_type,field:data_type en utilisant l'une des commandes suivantes :

Si vous chargez des données, utilisez la commande bq load.
Si vous créez une table vide, utilisez la commande bq mk.

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 l'élément suivant :

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 : ID de votre projet.
dataset : ensemble de données contenant la table dans laquelle vous chargez des données.
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 en savoir plus sur le chargement de données dans BigQuery, consultez la page Présentation du chargement des données.

Pour spécifier une définition de schéma intégrée lorsque vous créez une table vide, saisissez la commande bq 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 en savoir plus sur la création d'une table vide, consultez la section Créer une table vide avec 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 :

Afficher sur GitHub


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 :

Afficher sur GitHub


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 :

Afficher sur GitHub

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 :

Afficher sur GitHub

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
}

Java

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

Afficher sur GitHub

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.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to load JSON data from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCS {

  public static void runLoadJsonFromGCS() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadJsonFromGCS(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCS(
      String datasetName, String tableName, String sourceUri, 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);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              .setSchema(schema)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Json from GCS successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

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

Afficher sur GitHub

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.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // 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("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(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);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

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

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.

Afficher sur GitHub

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"

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
    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,
    table_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

destination_table = client.get_table(table_id)
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.

Afficher sur GitHub

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'outil de ligne de commande bq. 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 à l'aide de l'outil de ligne de commande bq. Vous ne pouvez pas utiliser de fichier de schéma avec Cloud Console ou l'API.

Fournissez manuellement le fichier de schéma :

Si vous chargez des données, utilisez la commande bq load.
Si vous créez une table vide, utilisez la commande bq mk.

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 l'élément suivant :

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 :

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

Spécifiez un schéma de table à l'aide de l'API :

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

Découvrez comment spécifier des colonnes imbriquées et répétées dans une définition de schéma.
Consultez la section sur la détection automatique de schéma.
Découvrez comment charger des données dans BigQuery.
Découvrez comment créer et utiliser des tables.