Especificar un esquema

BigQuery te permite especificar el esquema de una tabla cuando cargas datos en ella y cuando creas una tabla vacía. También puedes usar la detección automática de esquemas para los formatos de datos admitidos.

Cuando cargas archivos de exportación de Avro, Parquet, ORC, Firestore o Datastore, el esquema se obtiene automáticamente de los datos de origen autodescriptivos.

Puede especificar el esquema de una tabla de las siguientes formas:

• Usa la consola Google Cloud .
• Usa la instrucción SQL CREATE TABLE.
• En línea con la herramienta de línea de comandos bq.
• Crea un archivo de esquema en formato JSON.
• Llama al método jobs.insert y configura la propiedad schema en la configuración de la tarea load.
• Llama al método tables.insert y configura el esquema en el recurso de tabla mediante la propiedad schema.

Después de cargar datos o crear una tabla vacía, puede modificar la definición del esquema de la tabla.

Componentes de esquema

Cuando especifique un esquema de tabla, deberá indicar el nombre y el tipo de datos de cada columna. También puedes proporcionar la descripción, el modo y el valor predeterminado de una columna.

Nombres de columna

El nombre de una columna puede contener letras (a-z, A-Z), números (0-9) o guiones bajos (_), y debe empezar por una letra o un guion bajo. Si usa nombres de columna flexibles, BigQuery permite que los nombres de columna empiecen por un número. Tenga cuidado al empezar los nombres de las columnas con un número, ya que el uso de nombres de columnas flexibles con la API Storage Read o la API Storage Write de BigQuery requiere un tratamiento especial. Para obtener más información sobre la compatibilidad con nombres de columna flexibles, consulta el artículo Nombres de columna flexibles.

Los nombres de las columnas tienen una longitud máxima de 300 caracteres. Los nombres de columna no pueden usar ninguno de los siguientes prefijos:

• _TABLE_
• _FILE_
• _PARTITION
• _ROW_TIMESTAMP
• __ROOT__
• _COLIDENTIFIER

No se permiten nombres de columna duplicados, aunque se distinga entre mayúsculas y minúsculas. Por ejemplo, una columna llamada Column1 se considera idéntica a una columna llamada column1. Para obtener más información sobre las reglas de nomenclatura de columnas, consulta Nombres de columna en la referencia de GoogleSQL.

Si el nombre de una tabla (por ejemplo, test) es el mismo que el de una de sus columnas (por ejemplo, test), la expresión SELECT interpreta la columna test como un STRUCT que contiene todas las demás columnas de la tabla. Para evitar esta colisión, utiliza uno de los siguientes métodos:

• No uses el mismo nombre para una tabla y sus columnas.

• Asigna otro alias a la tabla. Por ejemplo, la siguiente consulta asigna el alias de tabla t a la tabla project1.dataset.test:

  SELECT test FROM project1.dataset.test AS t;
  

• Incluya el nombre de la tabla cuando haga referencia a una columna. Por ejemplo:

  SELECT test.test FROM project1.dataset.test;
  

Nombres de columna flexibles

Ahora tiene más flexibilidad a la hora de asignar nombres a las columnas, incluido un acceso ampliado a caracteres de idiomas distintos del inglés, así como a símbolos adicionales. Asegúrate de usar el carácter de acento grave (`) para incluir los nombres de columna flexibles si son identificadores entre comillas.

Los nombres de columna flexibles admiten los siguientes caracteres:

• Cualquier letra de cualquier idioma, representada por la expresión regular Unicode \p{L}.
• Cualquier carácter numérico en cualquier idioma representado por la expresión regular Unicode \p{N}.
• Cualquier carácter de puntuación de conector, incluidos los guiones bajos, tal como se representa en la expresión regular Unicode \p{Pc}.
• Un guion o una raya representados por la expresión regular Unicode \p{Pd}.
• Cualquier marca que acompañe a otro carácter, tal como se representa en la expresión regular Unicode \p{M}. Por ejemplo, acentos, diéresis o recuadros.
• Los siguientes caracteres especiales:
  • Un ampersand (&) representado por la expresión regular Unicode \u0026.
  • El signo de porcentaje (%) representado por la expresión regular Unicode \u0025.
  • Un signo igual (=) representado por la expresión regular Unicode \u003D.
  • Un signo más (+) representado por la expresión regular Unicode \u002B.
  • Dos puntos (:) representados por la expresión regular Unicode \u003A.
  • Un apóstrofo (') representado por la expresión regular Unicode \u0027.
  • Signo menor que (<) representado por la expresión regular Unicode \u003C.
  • El signo mayor que (>) representado por la expresión regular Unicode \u003E.
  • Un signo de número (#) representado por la expresión regular Unicode \u0023.
  • Una línea vertical (|) representada por la expresión regular Unicode \u007c.
  • Espacio en blanco.

Los nombres de columna flexibles no admiten los siguientes caracteres especiales:

• Un signo de exclamación (!) representado por la expresión regular Unicode \u0021.
• Una comilla (") representada por la expresión regular Unicode \u0022.
• El símbolo del dólar ($) representado por la expresión regular Unicode \u0024.
• Un paréntesis de apertura (() representado por la expresión regular Unicode \u0028.
• Un paréntesis de cierre ()) representado por la expresión regular Unicode \u0029.
• Un asterisco (*) representado por la expresión regular Unicode \u002A.
• Una coma (,) representada por la expresión regular Unicode \u002C.
• Un punto (.) representado por la expresión regular Unicode \u002E. Los puntos no se sustituyen por guiones bajos en los nombres de las columnas de los archivos Parquet cuando se usa un mapa de caracteres de nombres de columna. Para obtener más información, consulta las limitaciones de las columnas flexibles.
• Una barra (/) representada por la expresión regular Unicode \u002F.
• Un punto y coma (;) representado por la expresión regular Unicode \u003B.
• Un signo de interrogación (?) representado por la expresión regular Unicode \u003F.
• Una arroba (@) representada por la expresión regular Unicode \u0040.
• Un corchete de apertura ([) representado por la expresión regular Unicode \u005B.
• Una barra invertida (\) representada por la expresión regular Unicode \u005C.
• Un corchete de cierre (]) representado por la expresión regular Unicode \u005D.
• Un acento circunflejo (^) representado por la expresión regular Unicode \u005E.
• Un acento grave (`) representado por la expresión regular Unicode \u0060.
• Una llave de apertura {{) representada por la expresión regular Unicode \u007B.
• Una llave de cierre (}) representada por la expresión regular Unicode \u007D.
• Una virgulilla (~) representada por la expresión regular Unicode \u007E.

Para obtener más directrices, consulta Nombres de columna.

La API Storage Read de BigQuery y la API Storage Write de BigQuery admiten los caracteres de columna ampliados. Para usar la lista ampliada de caracteres Unicode con la API Storage Read de BigQuery, debes definir una marca. Puede usar el atributo displayName para obtener el nombre de la columna. En el siguiente ejemplo se muestra cómo definir una marca con el cliente de Python:

from google.cloud.bigquery_storage import types
requested_session = types.ReadSession()

#set avro serialization options for flexible column.
options = types.AvroSerializationOptions()
options.enable_display_name_attribute = True
requested_session.read_options.avro_serialization_options = options

Para usar la lista ampliada de caracteres Unicode con la API Storage Write de BigQuery, debes proporcionar el esquema con la notación column_name, a menos que uses el objeto de escritura JsonStreamWriter. En el siguiente ejemplo se muestra cómo proporcionar el esquema:

syntax = "proto2";
package mypackage;
// Source protos located in github.com/googleapis/googleapis
import "google/cloud/bigquery/storage/v1/annotations.proto";

message FlexibleSchema {
  optional string item_name_column = 1
  [(.google.cloud.bigquery.storage.v1.column_name) = "name-列"];
  optional string item_description_column = 2
  [(.google.cloud.bigquery.storage.v1.column_name) = "description-列"];
}

En este ejemplo, item_name_column y item_description_column son nombres de marcadores de posición que deben cumplir la convención de nomenclatura de protocol buffer. Ten en cuenta que las anotaciones column_name siempre tienen prioridad sobre los nombres de los marcadores de posición.

Limitaciones

• No se admiten nombres de columna flexibles en las tablas externas.

Descripciones de las columnas

Cada columna puede incluir una descripción opcional. La descripción es una cadena con una longitud máxima de 1024 caracteres.

Valores predeterminados

El valor predeterminado de una columna debe ser un literal o una de las siguientes funciones:

• CURRENT_DATE
• CURRENT_DATETIME
• CURRENT_TIME
• CURRENT_TIMESTAMP
• GENERATE_UUID
• RAND
• SESSION_USER
• ST_GEOGPOINT

Tipos de datos de GoogleSQL

GoogleSQL te permite especificar los siguientes tipos de datos en tu esquema. El tipo de datos es obligatorio.

Para obtener más información sobre los tipos de datos de GoogleSQL, consulta Tipos de datos de GoogleSQL.

También puedes declarar un tipo de array al consultar datos. Para obtener más información, consulta Trabajar con arrays.

Modos

BigQuery admite los siguientes modos para las columnas. El modo es opcional. Si no se especifica el modo, la columna se define de forma predeterminada como NULLABLE.

Para obtener más información sobre los modos, consulta mode en la TableFieldSchema.

Modo de redondeo

Cuando una columna es de tipo NUMERIC o BIGNUMERIC, puede definir la opción de columna rounding_mode, que determina cómo se redondean los valores de esa columna cuando se escriben en la tabla. Puedes definir la opción rounding_mode en una columna de nivel superior o en un STRUCT campo. Se admiten los siguientes modos de redondeo:

• "ROUND_HALF_AWAY_FROM_ZERO": este modo (predeterminado) redondea los casos intermedios alejándolos del cero.
• "ROUND_HALF_EVEN": este modo redondea los casos intermedios al dígito par más cercano.

No puede definir la opción rounding_mode en una columna que no sea de tipo NUMERIC o BIGNUMERIC. Para obtener más información sobre estos tipos, consulta Tipos decimales.

En el siguiente ejemplo se crea una tabla y se insertan valores redondeados según el modo de redondeo de la columna:

CREATE TABLE mydataset.mytable (
  x NUMERIC(5,2) OPTIONS (rounding_mode='ROUND_HALF_EVEN'),
  y NUMERIC(5,2) OPTIONS (rounding_mode='ROUND_HALF_AWAY_FROM_ZERO')
);
INSERT mydataset.mytable (x, y)
VALUES (NUMERIC "1.025", NUMERIC "1.025"),
       (NUMERIC "1.0251", NUMERIC "1.0251"),
       (NUMERIC "1.035", NUMERIC "1.035"),
       (NUMERIC "-1.025", NUMERIC "-1.025");

La tabla mytable tendrá este aspecto:

+-------+-------+
| x     | y     |
+-------+-------+
| 1.02  | 1.03  |
| 1.03  | 1.03  |
| 1.04  | 1.04  |
| -1.02 | -1.03 |
+-------+-------+

Para obtener más información, consulta roundingMode en la TableFieldSchema.

Especificar esquemas

Cuando cargas datos o creas una tabla vacía, puedes especificar el esquema de la tabla mediante la Google Cloud consola o la herramienta de línea de comandos bq. Puedes especificar un esquema al cargar archivos CSV y JSON (delimitados por líneas nuevas). Cuando carga datos de exportación de Avro, Parquet, ORC, Firestore o Datastore, el esquema se obtiene automáticamente de los datos de origen autodescriptivos.

Para especificar un esquema de tabla, sigue estos pasos:

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

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

bq mk --table project_id:dataset.table schema

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

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 = loadJob.PollUntilCompleted().ThrowOnAnyError();  // 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}");
    }
}

using Google.Cloud.BigQuery.V2;

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

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
}

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
}

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

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

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

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

Especificar un archivo de esquema JSON

Si lo prefieres, puedes especificar el esquema mediante un archivo de esquema JSON en lugar de usar una definición de esquema insertada. Un archivo de esquema JSON consta de una matriz JSON que contiene lo siguiente:

• El nombre de la columna
• El tipo de datos de la columna
• Opcional: el modo de la columna (si no se especifica, el modo predeterminado es NULLABLE)
• Opcional: los campos de la columna si es de tipo STRUCT
• Opcional: la descripción de la columna
• Opcional: las etiquetas de política de la columna, que se usan para controlar el acceso a nivel de campo
• Opcional: longitud máxima de los valores de la columna para los tipos STRING o BYTES
• Opcional: la precisión de la columna para los tipos NUMERIC o BIGNUMERIC
• Opcional: la escala de la columna para los tipos NUMERIC o BIGNUMERIC
• Opcional: la colación de la columna para los tipos STRING
• Opcional: el valor predeterminado de la columna
• Opcional: el modo de redondeo de la columna, si la columna es de tipo NUMERIC o BIGNUMERIC

Crear un archivo de esquema JSON

Para crear un archivo de esquema JSON, introduce un TableFieldSchema para cada columna. Los campos name y type son obligatorios. Los demás campos son opcionales.

[
  {
    "name": string,
    "type": string,
    "mode": string,
    "fields": [
      {
        object (TableFieldSchema)
      }
    ],
    "description": string,
    "policyTags": {
      "names": [
        string
      ]
    },
    "maxLength": string,
    "precision": string,
    "scale": string,
    "collation": string,
    "defaultValueExpression": string,
    "roundingMode": string
  },
  {
    "name": string,
    "type": string,
    ...
  }
]

Si la columna es de tipo RANGE<T>, usa el campo rangeElementType para describir T, donde T debe ser DATE, DATETIME o TIMESTAMP.

[
  {
    "name": "duration",
    "type": "RANGE",
    "mode": "NULLABLE",
    "rangeElementType": {
      "type": "DATE"
    }
  }
]

La matriz JSON se indica con los corchetes de inicio y de cierre []. Cada entrada de columna debe estar separada por una coma: },.

Para escribir el esquema de una tabla en un archivo local, sigue estos pasos:

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

from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change the table_id variable to the full name of the
# table you want to get schema from.
table_id = "your-project.your_dataset.your_table_name"

# TODO(dev): Change schema_path variable to the path
# of your schema file.
schema_path = "path/to/schema.json"
table = client.get_table(table_id)  # Make an API request.

# Write a schema file to schema_path with the schema_to_json method.
client.schema_to_json(table.schema, schema_path)

with open(schema_path, "r", encoding="utf-8") as schema_file:
    schema_contents = schema_file.read()

# View table properties
print(f"Got table '{table.project}.{table.dataset_id}.{table.table_id}'.")
print(f"Table schema: {schema_contents}")

Puedes usar el archivo de salida como punto de partida para crear tu propio archivo de esquema JSON. Si utilizas este método, asegúrate de que el archivo solo contenga la matriz JSON que representa el esquema de la tabla.

Por ejemplo, la siguiente matriz JSON representa un esquema de tabla básico. Este esquema tiene tres columnas: qtr (REQUIRED STRING), rep (NULLABLE STRING) y sales (NULLABLE FLOAT).

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

Usar un archivo de esquema JSON

Una vez que hayas creado el archivo de esquema JSON, puedes especificarlo con la herramienta de línea de comandos bq. No puedes usar un archivo de esquema con la Google Cloud consola ni con la API.

Proporciona el archivo de esquema:

• Si vas a cargar datos, usa el comando bq load.
• Si vas a crear una tabla vacía, usa el comando bq mk.

Cuando proporciones un archivo de esquema JSON, debe almacenarse en una ubicación de lectura local. No puedes especificar un archivo de esquema JSON almacenado en Cloud Storage o Google Drive.

Especificar un archivo de esquema al cargar datos

Para cargar datos en una tabla mediante una definición de esquema JSON, sigue estos pasos:

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

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

from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change uri variable to the path of your data file.
uri = "gs://your-bucket/path/to/your-file.csv"
# TODO(dev): Change table_id to the full name of the table you want to create.
table_id = "your-project.your_dataset.your_table"
# TODO(dev): Change schema_path variable to the path of your schema file.
schema_path = "path/to/schema.json"
# To load a schema file use the schema_from_json method.
schema = client.schema_from_json(schema_path)

job_config = bigquery.LoadJobConfig(
    # To use the schema you loaded pass it into the
    # LoadJobConfig constructor.
    schema=schema,
    skip_leading_rows=1,
)

# Pass the job_config object to the load_table_from_file,
# load_table_from_json, or load_table_from_uri method
# to use the schema on a new table.
load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

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

destination_table = client.get_table(table_id)  # Make an API request.
print(f"Loaded {destination_table.num_rows} rows to {table_id}.")

Especificar un archivo de esquema al crear una tabla

Para crear una tabla vacía en un conjunto de datos que ya tengas con un archivo de esquema JSON, sigue estos pasos:

bq mk --table project_id:dataset.table path_to_schema_file

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

from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change table_id to the full name of the table you want to create.
table_id = "your-project.your_dataset.your_table_name"
# TODO(dev): Change schema_path variable to the path of your schema file.
schema_path = "path/to/schema.json"
# To load a schema file use the schema_from_json method.
schema = client.schema_from_json(schema_path)

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # API request
print(f"Created table {table_id}.")

Especificar un esquema en la API

Especifica un esquema de tabla con la API:

• Para especificar un esquema al cargar datos, llama al método jobs.insert y configura la propiedad schema en el recurso JobConfigurationLoad.

• Para especificar un esquema al crear una tabla, llama al método tables.insert y configura la propiedad schema en el recurso Table.

Especificar un esquema mediante la API es similar al proceso para crear un archivo de esquema JSON.

Seguridad de las tablas

Para controlar el acceso a las tablas de BigQuery, consulta el artículo sobre cómo controlar el acceso a los recursos con la gestión de identidades y accesos.

Siguientes pasos

• Consulta cómo especificar columnas anidadas y repetidas en una definición de esquema.
• Consulta información sobre la detección automática de esquemas.
• Consulta información sobre cómo cargar datos en BigQuery.
• Consulta información sobre cómo crear y usar tablas.