Cargar datos Avro desde Cloud Storage

Consola

1. En la Google Cloud consola, abre la página de BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

3. Abre la opción more_vert Acciones y haz clic en Abrir.

4. En el panel de detalles, haz clic en Crear tabla add_box.

5. En la página Crear tabla, ve a la sección Fuente:

   • En Crear tabla a partir de, selecciona Google Cloud Storage.

   • En el campo de origen, busca o introduce el URI de Cloud Storage. Ten en cuenta que no puedes incluir varias URIs en la Google Cloud consola, pero se admiten comodines. El segmento de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que vas a crear.

     

   • En Formato de archivo, selecciona Avro.

6. En la página Crear tabla, ve a la sección Destino:

   • En Nombre del conjunto de datos, elige el conjunto de datos adecuado.
   • Verifica que el Tipo de tabla sea Tabla nativa.
   • En el campo Nombre de la tabla, introduce el nombre de la tabla que vas a crear en BigQuery.

7. En la sección Esquema, no es necesario que haga nada. El esquema se describe automáticamente en los archivos Avro.

8. (Opcional) Para crear particiones en la tabla, elige las opciones que quieras en Configuración de particiones y clústeres. Para obtener más información, consulta el artículo Crear tablas particionadas.

9. (Opcional) En Filtro de partición, marque la casilla Requerir filtro de partición para que los usuarios incluyan una cláusula WHERE que especifique las particiones que se van a consultar. Si usas este filtro, es posible que rebajes los costes y mejores el rendimiento. Para obtener más información, consulta Requerir un filtro de partición en las consultas. Esta opción no está disponible si se selecciona Sin partición.

10. (Opcional) Para agrupar la tabla, en el cuadro Orden de agrupación, introduzca entre uno y cuatro nombres de campo.

11. (Opcional) Haz clic en Opciones avanzadas.

    • En Write preference (Preferencia de escritura), deja seleccionada la opción Write if empty (Escribir si está vacía). Esta opción crea una tabla y carga los datos en ella.
    • En Valores desconocidos, deje desactivada la opción Ignorar valores desconocidos. Esta opción solo se aplica a los archivos CSV y JSON.
    • En Encriptado, haz clic en Clave gestionada por el cliente para usar una clave de Cloud Key Management Service. Si dejas activado el ajuste Google-managed key, BigQuery cifra los datos en reposo.

12. Haz clic en Crear tabla.

SQL

Usa la LOAD DATA instrucción DDL. En el siguiente ejemplo se carga un archivo Avro en la nueva tabla mytable:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   LOAD DATA OVERWRITE mydataset.mytable
   FROM FILES (
     format = 'avro',
     uris = ['gs://bucket/path/file.avro']);

3. Haz clic en play_circle Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

Usa el comando bq load, especifica AVRO con la marca --source_format e incluye un URI de Cloud Storage. Puede incluir un solo URI, una lista de URIs separados por comas o un URI que contenga un comodín.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

Otras marcas opcionales son:

• --time_partitioning_type: habilita la creación de particiones basadas en el tiempo en una tabla y define el tipo de partición. Los valores posibles son HOUR, DAY, MONTH y YEAR. Esta marca es opcional cuando se crea una tabla con particiones en una columna DATE, DATETIME o TIMESTAMP. El tipo de partición predeterminado para la partición basada en tiempo es DAY. No puedes cambiar la especificación de partición de una tabla que ya tengas.
• --time_partitioning_expiration: número entero que especifica (en segundos) cuándo se debe eliminar una partición basada en el tiempo. El tiempo de caducidad se calcula como la fecha UTC de la partición más el valor entero.
• --time_partitioning_field: columna DATE o TIMESTAMP que se usa para crear una tabla con particiones. Si se habilita la creación de particiones basadas en tiempo sin este valor, se creará una tabla con particiones por hora de ingestión.
• --require_partition_filter: cuando se habilita esta opción, los usuarios deben incluir una cláusula WHERE que especifique las particiones que se van a consultar. Si usas este filtro, es posible que rebajes los costes y mejores el rendimiento. Para obtener más información, consulta Requerir un filtro de partición en las consultas.
• --clustering_fields: lista separada por comas de hasta cuatro nombres de columna que se usa para crear una tabla agrupada en clústeres.

• --destination_kms_key: la clave de Cloud KMS para cifrar los datos de la tabla.

  Para obtener más información sobre las tablas con particiones, consulta los siguientes artículos:

  • Crear tablas con particiones

  Para obtener más información sobre las tablas agrupadas en clústeres, consulta los siguientes enlaces:

  • Crear y usar tablas agrupadas en clústeres

  Para obtener más información sobre el cifrado de tablas, consulta los siguientes artículos:

  • Proteger datos con claves de Cloud KMS

Para cargar datos Avro en BigQuery, introduce el siguiente comando:

bq --location=location load \
--source_format=format \
dataset.table \
path_to_source

Haz los cambios siguientes:

• location es tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes definir el valor de la marca como asia-northeast1. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
• format es AVRO.
• dataset es un conjunto de datos.
• table es el nombre de la tabla en la que se cargan los datos.
• path_to_source es un URI de Cloud Storage completo o una lista de URIs separados por comas. También se admiten comodines.

Ejemplos:

El siguiente comando carga datos de gs://mybucket/mydata.avro en una tabla llamada mytable en mydataset.

    bq load \
    --source_format=AVRO \
    mydataset.mytable \
    gs://mybucket/mydata.avro

El siguiente comando carga datos de gs://mybucket/mydata.avro en una tabla con particiones por tiempo de ingestión llamada mytable en mydataset.

    bq load \
    --source_format=AVRO \
    --time_partitioning_type=DAY \
    mydataset.mytable \
    gs://mybucket/mydata.avro

El siguiente comando carga datos de gs://mybucket/mydata.avro en una tabla particionada nueva llamada mytable en mydataset. que cuenta con particiones por la columna mytimestamp.

    bq load \
    --source_format=AVRO \
    --time_partitioning_field mytimestamp \
    mydataset.mytable \
    gs://mybucket/mydata.avro

El siguiente comando carga datos de varios archivos de gs://mybucket/ en una tabla llamada mytable de mydataset. El URI de Cloud Storage usa un comodín.

    bq load \
    --source_format=AVRO \
    mydataset.mytable \
    gs://mybucket/mydata*.avro

El siguiente comando carga datos de varios archivos de gs://mybucket/ en una tabla llamada mytable de mydataset. El comando incluye una lista de URIs de Cloud Storage separados por comas con comodines.

    bq load \
    --source_format=AVRO \
    mydataset.mytable \
    "gs://mybucket/00/*.avro","gs://mybucket/01/*.avro"

API

1. Crea una tarea load que apunte a los datos de origen en Cloud Storage.

2. (Opcional) Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de empleo.

3. La propiedad source URIs debe estar totalmente cualificada y tener el formato gs://bucket/object. Cada URI puede contener un carácter comodín "*".

4. Para especificar el formato de datos Avro, asigna el valor AVRO a la propiedad sourceFormat.

5. Para comprobar el estado del trabajo, llama a jobs.get(job_id*), donde job_id es el ID del trabajo devuelto por la solicitud inicial.

   • Si status.state = DONE, el trabajo se ha completado correctamente.
   • Si la propiedad status.errorResult está presente, significa que se ha producido un error en la solicitud y que el objeto incluirá información que describe lo que ha fallado. Si una solicitud falla, no se crea ninguna tabla y no se cargan datos.
   • Si no aparece status.errorResult, significa que el trabajo se ha completado correctamente, aunque es posible que se hayan producido algunos errores no graves, como problemas al importar algunas filas. Los errores no críticos se indican en la propiedad status.errors del objeto de trabajo devuelto.

Notas sobre la API:

• Las tareas de carga son atómicas y coherentes: si una tarea de carga falla, no habrá datos disponibles, y si se completa correctamente, todos los datos estarán disponibles.

• Como práctica recomendada, genera un ID único y pásalo como jobReference.jobId al llamar a jobs.insert para crear un trabajo de carga. Este enfoque es más sólido ante fallos de red, ya que el cliente puede sondear o volver a intentar la operación con el ID de trabajo conocido.

• Llamar a jobs.insert en un ID de trabajo determinado es idempotente. Puedes volver a intentarlo tantas veces como quieras con el mismo ID de trabajo y, como máximo, una de esas operaciones se completará correctamente.

Go

import (
	"context"
	"fmt"

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

// importAvro demonstrates loading Apache Avro data from Cloud Storage into a table.
func importAvro(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.avro")
	gcsRef.SourceFormat = bigquery.Avro
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)

	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
}

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
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.TableId;

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

  public static void runLoadAvroFromGCS() {
    // 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.avro";
    loadAvroFromGCS(datasetName, tableName, sourceUri);
  }

  public static void loadAvroFromGCS(String datasetName, String tableName, String sourceUri) {
    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.of(tableId, sourceUri, FormatOptions.avro());

      // Load data from a GCS Avro 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("Avro 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());
    }
  }
}

Node.js

// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the Avro file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.avro
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.avro';

async function loadTableGCSAvro() {
  // Imports a GCS file into a table with Avro source format.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'us_states';

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const jobConfigurationLoad = {
    load: {sourceFormat: 'AVRO'},
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), jobConfigurationLoad);

  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

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

job_config = bigquery.LoadJobConfig(source_format=bigquery.SourceFormat.AVRO)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.avro"

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)
print("Loaded {} rows.".format(destination_table.num_rows))

Consola

1. En la Google Cloud consola, abre la página de BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

3. Abre la opción more_vert Acciones y haz clic en Abrir.

4. En el panel de detalles, haz clic en Crear tabla add_box.

5. En la página Crear tabla, ve a la sección Fuente:

   • En Crear tabla a partir de, selecciona Cloud Storage.

   • En el campo de origen, busca o introduce el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios URIs en la consola Google Cloud , pero sí comodines. El segmento de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que vas a añadir o sobrescribir.

     

   • En Formato de archivo, selecciona Avro.

6. En la página Crear tabla, ve a la sección Destino:

   • En Nombre del conjunto de datos, elige el conjunto de datos adecuado.

     

   • En el campo Nombre de la tabla, introduzca el nombre de la tabla que quiera añadir o sobrescribir en BigQuery.

   • Verifica que el Tipo de tabla sea Tabla nativa.

7. En la sección Esquema, no es necesario que haga nada. El esquema se describe automáticamente en los archivos Avro.

8. En Configuración de partición y clúster, deja los valores predeterminados. No puedes convertir una tabla en una tabla con particiones o agrupada en clústeres añadiendo o sobrescribiendo datos, y la consola Google Cloud no admite la adición ni la sobrescritura de datos en tablas con particiones o agrupadas en clústeres en una tarea de carga.

9. Haz clic en Advanced options (Opciones avanzadas).

   • En Preferencia de escritura, elija Añadir a la tabla o Sobrescribir tabla.
   • En Valores desconocidos, deje desactivada la opción Ignorar valores desconocidos. Esta opción solo se aplica a los archivos CSV y JSON.
   • En Encriptado, haz clic en Clave gestionada por el cliente para usar una clave de Cloud Key Management Service. Si dejas activado el ajuste Google-owned and managed key, BigQuery cifra los datos en reposo.

10. Haz clic en Crear tabla.

SQL

Usa la LOAD DATA instrucción DDL. En el siguiente ejemplo se añade un archivo Avro a la tabla mytable:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   LOAD DATA INTO mydataset.mytable
   FROM FILES (
     format = 'avro',
     uris = ['gs://bucket/path/file.avro']);

3. Haz clic en play_circle Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

Introduce el comando bq load con la marca --replace para sobrescribir la tabla. Usa la marca --noreplace para añadir datos a la tabla. Si no se especifica ninguna marca, el valor predeterminado es añadir datos. Proporciona la marca --source_format y asígnala a AVRO. Como los esquemas Avro se obtienen automáticamente de los datos de origen autodescriptivos, no es necesario que proporcione una definición de esquema.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

Otras marcas opcionales son:

• --destination_kms_key: la clave de Cloud KMS para cifrar los datos de la tabla.

bq --location=location load \
--[no]replace \
--source_format=format \
dataset.table \
path_to_source

Haz los cambios siguientes:

• location es tu ubicación. La marca --location es opcional. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
• format es AVRO.
• dataset es un conjunto de datos.
• table es el nombre de la tabla en la que se cargan los datos.
• path_to_source es un URI de Cloud Storage completo o una lista de URIs separados por comas. También se admiten comodines.

Ejemplos:

El siguiente comando carga datos de gs://mybucket/mydata.avro y sobrescribe una tabla llamada mytable en mydataset.

    bq load \
    --replace \
    --source_format=AVRO \
    mydataset.mytable \
    gs://mybucket/mydata.avro

El siguiente comando carga datos de gs://mybucket/mydata.avro y añade datos a una tabla llamada mytable en mydataset.

    bq load \
    --noreplace \
    --source_format=AVRO \
    mydataset.mytable \
    gs://mybucket/mydata.avro

Para obtener información sobre cómo añadir y sobrescribir tablas con particiones mediante la herramienta de línea de comandos bq, consulta el artículo Añadir y sobrescribir datos de tablas con particiones.

API

1. Crea una tarea load que apunte a los datos de origen en Cloud Storage.

2. (Opcional) Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de empleo.

3. La propiedad source URIs debe estar completa y tener el formato gs://bucket/object. Puedes incluir varios URIs en una lista separada por comas. Ten en cuenta que también se admiten comodines.

4. Especifica el formato de los datos asignando el valor AVRO a la propiedad configuration.load.sourceFormat.

5. Especifica la preferencia de escritura asignando el valor WRITE_TRUNCATE o WRITE_APPEND a la propiedad configuration.load.writeDisposition.

Go

import (
	"context"
	"fmt"

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

// importAvroTruncate demonstrates loading Apache Avro data from Cloud Storage into a table
// and overwriting/truncating existing data in the table.
func importAvroTruncate(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.avro")
	gcsRef.SourceFormat = bigquery.Avro
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	// Default for import jobs is to append data to a table.  WriteTruncate
	// specifies that existing data should instead be replaced/overwritten.
	loader.WriteDisposition = bigquery.WriteTruncate

	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
}

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
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.TableId;

// Sample to overwrite the BigQuery table data by loading a AVRO file from GCS
public class LoadAvroFromGCSTruncate {

  public static void runLoadAvroFromGCSTruncate() {
    // 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.avro";
    loadAvroFromGCSTruncate(datasetName, tableName, sourceUri);
  }

  public static void loadAvroFromGCSTruncate(
      String datasetName, String tableName, String sourceUri) {
    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.avro())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_TRUNCATE)
              .build();

      // Load data from a GCS Avro 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("Table is successfully overwritten by AVRO file loaded from GCS");
      } 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());
    }
  }
}

Node.js

// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the Avro file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.avro
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.avro';

async function loadTableGCSAvroTruncate() {
  /**
   * Imports a GCS file into a table and overwrites
   * table data if table already exists.
   */

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'us_states';

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const jobConfigurationLoad = {
    load: {
      sourceFormat: 'AVRO',
      writeDisposition: 'WRITE_TRUNCATE',
    },
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), jobConfigurationLoad);

  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

Python

import io

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"),
    ],
)

body = io.BytesIO(b"Washington,WA")
client.load_table_from_file(body, table_id, job_config=job_config).result()
previous_rows = client.get_table(table_id).num_rows
assert previous_rows > 0

job_config = bigquery.LoadJobConfig(
    write_disposition=bigquery.WriteDisposition.WRITE_TRUNCATE,
    source_format=bigquery.SourceFormat.AVRO,
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.avro"
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)
print("Loaded {} rows.".format(destination_table.num_rows))