Caricamento dei dati Avro da Cloud Storage

Console

1. Nella console Google Cloud, apri la pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Espandi l'opzione more_vert Azioni e fai clic su Apri.

4. Nel riquadro dei dettagli, fai clic su Crea tabella add_box.

5. Nella sezione Origine della pagina Crea tabella:

   • Per Crea tabella da, seleziona Google Cloud Storage.

   • Nel campo di origine, vai all'URI Cloud Storage o inseriscilo. Tieni presente che nella console Google Cloud non puoi includere più URI, ma sono supportati i caratteri jolly. Il bucket Cloud Storage deve trovarsi nella stessa località del set di dati che contiene la tabella che stai creando.

     

   • Per Formato file, seleziona Avro.

6. Nella sezione Destinazione della pagina Crea tabella:

   • In Nome set di dati, scegli il set di dati appropriato.
   • Verifica che l'opzione Tipo di tabella sia impostata su Tabella nativa.
   • Nel campo Nome tabella, inserisci il nome della tabella che stai creando in BigQuery.

7. Nella sezione Schema non è necessaria alcuna azione. Lo schema è autodescritto nei file Avro.

8. (Facoltativo) Per eseguire il partizionamento della tabella, scegli le opzioni nelle Impostazioni di partizionamento e clustering. Per maggiori informazioni, consulta Creazione di tabelle partizionate.

9. (Facoltativo) Per Filtro di partizionamento, fai clic sulla casella Richiedi filtro di partizionamento per richiedere agli utenti di includere una clausola WHERE che specifichi le partizioni su cui eseguire la query. La richiesta di un filtro di partizionamento può ridurre i costi e migliorare le prestazioni. Per maggiori informazioni, consulta Esecuzione di query su tabelle partizionate. Questa opzione non è disponibile se è selezionata l'opzione Nessun partizionamento.

10. (Facoltativo) Per eseguire il cluster della tabella, nella casella Ordine di clustering, inserisci da uno a quattro nomi di campo.

11. (Facoltativo) Fai clic su Opzioni avanzate.

    • In Write preference (Preferenza di scrittura), lascia selezionata l'opzione Write if empty (Scrivi se vuoto). Questa opzione crea una nuova tabella e carica i dati al suo interno.
    • Per Valori sconosciuti, lascia deselezionata l'opzione Ignora valori sconosciuti. Questa opzione si applica solo ai file CSV e JSON.
    • In Crittografia, fai clic su Chiave gestita dal cliente per utilizzare una chiave Cloud Key Management Service. Se lasci l'impostazione Chiave gestita da Google, BigQuery cripta i dati at-rest.

12. Fai clic su Crea tabella.

SQL

Utilizza l'istruzione DDL LOAD DATA. L'esempio seguente carica un file Avro nella nuova tabella mytable:

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

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

3. Fai clic su play_circle Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Utilizza il comando bq load, specifica AVRO con il flag --source_format e includi un URI Cloud Storage. Puoi includere un singolo URI, un elenco di URI separati da virgole o un URI contenente un caratteri jolly.

(Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

Altri flag facoltativi includono:

• --time_partitioning_type: abilita il partizionamento in base al tempo in una tabella e imposta il tipo di partizione. I valori possibili sono HOUR, DAY, MONTH e YEAR. Questo flag è facoltativo quando crei una tabella partizionata in base a una colonna DATE, DATETIME o TIMESTAMP. Il tipo di partizione predefinito per il partizionamento basato sul tempo è DAY. Non puoi modificare la specifica di partizionamento su una tabella esistente.
• --time_partitioning_expiration: un numero intero che specifica (in secondi) quando deve essere eliminata una partizione basata sul tempo. La scadenza corrisponde alla data UTC della partizione più il valore intero.
• --time_partitioning_field: la colonna DATE o TIMESTAMP utilizzata per creare una tabella partizionata. Se il partizionamento basato sul tempo viene abilitato senza questo valore, viene creata unatabella partizionata per data di importazionee.
• --require_partition_filter: quando abilitata, questa opzione richiede agli utenti di includere una clausola WHERE che specifichi le partizioni su cui eseguire la query. La richiesta di un filtro di partizionamento può ridurre i costi e migliorare le prestazioni. Per saperne di più, consulta Esecuzione di query su tabelle partizionate.
• --clustering_fields: un elenco separato da virgole di massimo quattro nomi di colonna utilizzati per creare una tabella in cluster.

• --destination_kms_key: la chiave Cloud KMS per la crittografia dei dati della tabella.

  Per saperne di più sulle tabelle partizionate, consulta:

  • Creazione di tabelle partizionate

  Per ulteriori informazioni sulle tabelle in cluster, consulta:

  • Creazione e utilizzo di tabelle in cluster

  Per ulteriori informazioni sulla crittografia delle tabelle, consulta:

  • Protezione dei dati con le chiavi Cloud KMS

Per caricare dati Avro in BigQuery, inserisci il comando seguente:

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

Sostituisci quanto segue:

• location è la tua posizione. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando il file.bigqueryrc.
• format è pari a AVRO.
• dataset è un set di dati esistente.
• table è il nome della tabella in cui vengono caricati i dati.
• path_to_source è un URI Cloud Storage completo o un elenco di URI separati da virgole. Sono supportati anche i caratteri jolly.

Esempi:

Il seguente comando carica i dati da gs://mybucket/mydata.avro in una tabella denominata mytable in mydataset.

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

Il seguente comando carica i dati da gs://mybucket/mydata.avro in una tabella partizionata per data di importazione denominata mytable in mydataset.

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

Il seguente comando carica i dati da gs://mybucket/mydata.avro in una nuova tabella partizionata denominata mytable in mydataset. La tabella è partizionata nella colonna mytimestamp.

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

Il seguente comando carica i dati da più file in gs://mybucket/ in una tabella denominata mytable in mydataset. L'URI Cloud Storage utilizza un carattere jolly.

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

Il seguente comando carica i dati da più file in gs://mybucket/ in una tabella denominata mytable in mydataset. Il comando include un elenco separato da virgole di URI di Cloud Storage con caratteri jolly.

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

API

1. Crea un job load che punti ai dati di origine in Cloud Storage.

2. (Facoltativo) Specifica la tua località nella proprietà location nella sezione jobReference della risorsa job.

3. La proprietà source URIs deve essere completa, nel formato gs://bucket/object. Ogni URI può contenere un carattere jolly '*'.

4. Specifica il formato dei dati Avro impostando la proprietà sourceFormat su AVRO.

5. Per controllare lo stato del job, chiama jobs.get(job_id*), dove job_id è l'ID del job restituito dalla richiesta iniziale.

   • Se status.state = DONE, il job è stato completato correttamente.
   • Se è presente la proprietà status.errorResult, la richiesta non è andata a buon fine e l'oggetto includerà le informazioni che descrivono l'errore. Quando una richiesta non va a buon fine, non viene creata alcuna tabella e non vengono caricati dati.
   • Se status.errorResult non è presente, il job è stato completato correttamente, anche se potrebbero essersi verificati alcuni errori non irreversibili, come problemi nell'importazione di alcune righe. Gli errori non irreversibili sono elencati nella proprietà status.errors dell'oggetto job restituito.

Note API:

• I job di caricamento sono atomici e coerenti. Se un job di caricamento non riesce, nessuno dei dati è disponibile e, se un job di caricamento ha esito positivo, sono disponibili tutti i dati.

• Come best practice, genera un ID univoco e passalo come jobReference.jobId quando chiami jobs.insert per creare un job di caricamento. Questo approccio è più efficace per gli errori di rete perché il client può eseguire il polling o riprovare sull'ID job noto.

• Chiamare jobs.insert su un determinato ID job è idempotente. Puoi riprovare tutte le volte che vuoi per lo stesso ID job e al massimo una di queste operazioni avrà esito positivo.

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

Console

1. Nella console Google Cloud, apri la pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Espandi l'opzione more_vert Azioni e fai clic su Apri.

4. Nel riquadro dei dettagli, fai clic su Crea tabella add_box.

5. Nella sezione Origine della pagina Crea tabella:

   • Per Crea tabella da, seleziona Cloud Storage.

   • Nel campo di origine, vai all'URI Cloud Storage o inseriscilo. Tieni presente che non puoi includere più URI nella console Google Cloud, ma sono supportati i caratteri jolly. Il bucket Cloud Storage deve trovarsi nella stessa località del set di dati che contiene la tabella che stai aggiungendo o sovrascrivendo.

     

   • Per Formato file, seleziona Avro.

6. Nella sezione Destinazione della pagina Crea tabella:

   • In Nome set di dati, scegli il set di dati appropriato.

     

   • Nel campo Nome tabella, inserisci il nome della tabella che stai aggiungendo o sovrascrivendo in BigQuery.

   • Verifica che l'opzione Tipo di tabella sia impostata su Tabella nativa.

7. Nella sezione Schema non è necessaria alcuna azione. Lo schema è autodescritto nei file Avro.

8. In Impostazioni di partizionamento e clustering, lascia i valori predefiniti. Non puoi convertire una tabella in una tabella partizionata o in cluster aggiungendola o sovrascrivendola e la console Google Cloud non supporta l'aggiunta o la sovrascrittura di tabelle partizionate o in cluster in un job di caricamento.

9. Fai clic su Opzioni avanzate.

   • In Preferenza di scrittura, scegli Aggiungi alla tabella o Sovrascrivi tabella.
   • Per Valori sconosciuti, lascia deselezionata l'opzione Ignora valori sconosciuti. Questa opzione si applica solo ai file CSV e JSON.
   • In Crittografia, fai clic su Chiave gestita dal cliente per utilizzare una chiave Cloud Key Management Service. Se lasci l'impostazione Chiave gestita da Google, BigQuery cripta i dati at-rest.

10. Fai clic su Crea tabella.

SQL

Utilizza l'istruzione DDL LOAD DATA. L'esempio seguente aggiunge un file Avro alla tabella mytable:

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

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

3. Fai clic su play_circle Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Inserisci il comando bq load con il flag --replace per sovrascrivere la tabella. Utilizza il flag --noreplace per aggiungere dati alla tabella. Se non viene specificato nessun flag, il valore predefinito è l'aggiunta di dati. Fornisci il flag --source_format e impostalo su AVRO. Poiché gli schemi Avro vengono recuperati automaticamente dai dati di origine autodescrittivi, non è necessario fornire una definizione dello schema.

(Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

Altri flag facoltativi includono:

• --destination_kms_key: la chiave Cloud KMS per la crittografia dei dati della tabella.

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

Sostituisci quanto segue:

• location è la tua località. Il flag --location è facoltativo. Puoi impostare un valore predefinito per la località utilizzando il file.bigqueryrc.
• format è pari a AVRO.
• dataset è un set di dati esistente.
• table è il nome della tabella in cui vengono caricati i dati.
• path_to_source è un URI Cloud Storage completo o un elenco di URI separati da virgole. Sono supportati anche i caratteri jolly.

Esempi:

Il seguente comando carica i dati da gs://mybucket/mydata.avro e sovrascrive una tabella denominata mytable in mydataset.

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

Il seguente comando carica i dati da gs://mybucket/mydata.avro e accoda i dati a una tabella denominata mytable in mydataset.

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

Per informazioni sull'aggiunta e la sovrascrittura delle tabelle partizionate mediante lo strumento a riga di comando bq, consulta: Aggiunta e sovrascrittura di tabella partizionata partizionate.

API

1. Crea un job load che punti ai dati di origine in Cloud Storage.

2. (Facoltativo) Specifica la tua località nella proprietà location nella sezione jobReference della risorsa job.

3. La proprietà source URIs deve essere completa, nel formato gs://bucket/object. Puoi includere più URI sotto forma di elenco separato da virgole. Tieni presente che sono supportati anche i caratteri jolly.

4. Specifica il formato dei dati impostando la proprietà configuration.load.sourceFormat su AVRO.

5. Specifica la preferenza di scrittura impostando la proprietà configuration.load.writeDisposition su WRITE_TRUNCATE o WRITE_APPEND.

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