Caricamento di dati JSON da Cloud Storage

Puoi caricare dati JSON delimitati da nuova riga da Cloud Storage in una nuova tabella o partizione, oppure aggiungere o sovrascrivere una tabella o una partizione esistente. Quando vengono caricati in BigQuery, vengono convertiti in formato a colonne per Condensatore (formato di archiviazione di BigQuery).

Quando carichi i dati da Cloud Storage in una tabella BigQuery, il set di dati che contiene la tabella deve trovarsi nella stessa regione regionale come bucket Cloud Storage.

Il formato JSON delimitato da nuova riga è lo stesso del Righe JSON.

Limitazioni

Quando carichi dati in: BigQuery da un bucket Cloud Storage:

• Se la località del set di dati è impostata su un valore diverso dall'area multiregionale US, il bucket Cloud Storage deve trovarsi nella stessa regione o contenuto nella stessa località (multiregionale) del set di dati.
• BigQuery non garantisce la coerenza dei dati esterni fonti. Le modifiche ai dati sottostanti durante l'esecuzione di una query possono comportare comportamenti imprevisti.
• BigQuery non supporta Controllo delle versioni degli oggetti Cloud Storage. Se includi un numero di generazione nell'URI di Cloud Storage, il job di caricamento non riesce.

Quando carichi file JSON in BigQuery, tieni presente quanto segue:

• I dati JSON devono essere delimitati da nuova riga. Ogni oggetto JSON deve trovarsi in una riga del file.
• Se usi gzip compressione, BigQuery non può leggere i dati in parallelo. Caricamento compresso I dati JSON in BigQuery sono più lenti rispetto al caricamento dei dati non compressi e i dati di Google Cloud.
• Non puoi includere file compressi e non compressi nello stesso caricamento un lavoro.
• La dimensione massima di un file gzip è 4 GB.

• BigQuery supporta il tipo JSON anche se le informazioni sullo schema sono non nota al momento dell'importazione. Un campo dichiarato come tipo JSON vengono caricati con i valori JSON non elaborati.

• Se utilizzi l'API BigQuery per caricare un numero intero al di fuori dell'intervallo di [-2⁵³+1, 2⁵³-1] (solitamente questo significa maggiore di 9.007.199.254.740.991 in un numero intero (INT64) , trasmettila come stringa per evitare il danneggiamento dei dati. Questo problema è causata da una limitazione della dimensione dei numeri interi in JSON/ECMAScript. Per maggiori informazioni le informazioni, vedi la sezione Numeri di RFC 7159.

• Quando carichi dati CSV o JSON, i valori nelle colonne DATE devono utilizzare il trattino (-) e la data devono avere il seguente formato: YYYY-MM-DD (anno-mese-giorno).
• Quando carichi dati JSON o CSV, i valori nelle colonne TIMESTAMP deve utilizzare un trattino (-) o una barra (/) per la parte relativa alla data dell' timestamp e la data deve essere in uno dei seguenti formati: YYYY-MM-DD (anno-mese-giorno) o YYYY/MM/DD (anno/mese/giorno). La parte hh:mm:ss (ora-minuti/secondi) del timestamp deve utilizzare i due punti (:).

• I file devono rispettare i limiti di dimensione dei file JSON descritti in limiti dei job di caricamento.

Prima di iniziare

Concedi ruoli IAM (Identity and Access Management) che concedono agli utenti le risorse necessarie autorizzazioni per eseguire ogni attività in questo documento e creare per archiviare i dati.

Autorizzazioni obbligatorie

Per caricare dati in BigQuery, devi disporre delle autorizzazioni IAM per eseguire un job di caricamento e caricare i dati nelle tabelle e nelle partizioni BigQuery. Se carichi dati da Cloud Storage, devi disporre anche delle autorizzazioni IAM per accedere al bucket che contiene i dati.

Autorizzazioni per caricare i dati in BigQuery

Per caricare i dati in una nuova tabella o partizione BigQuery oppure per aggiungere o sovrascrivere una tabella o una partizione esistente, devi disporre delle seguenti autorizzazioni IAM:

• bigquery.tables.create
• bigquery.tables.updateData
• bigquery.tables.update
• bigquery.jobs.create

Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per caricare i dati in una tabella o una partizione BigQuery:

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin (include l'autorizzazione bigquery.jobs.create)
• bigquery.user (include l'autorizzazione bigquery.jobs.create)
• bigquery.jobUser (include l'autorizzazione bigquery.jobs.create)

Inoltre, se disponi dell'autorizzazione bigquery.datasets.create, puoi creare e aggiornare le tabelle utilizzando un job di caricamento nei set di dati che crei.

Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, vedi Autorizzazioni e ruoli predefiniti.

Autorizzazioni per caricare i dati da Cloud Storage

Per ottenere le autorizzazioni necessarie per caricare i dati da un bucket Cloud Storage, chiedi all'amministratore di concederti Ruolo IAM Storage Admin (roles/storage.admin) nel bucket. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Questo ruolo predefinito contiene le autorizzazioni necessarie per caricare i dati da un bucket Cloud Storage. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per caricare i dati da un bucket Cloud Storage, sono necessarie le seguenti autorizzazioni:

• storage.buckets.get
• storage.objects.get
• storage.objects.list (required if you are using a URI wildcard)

Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.

Crea un set di dati

Crea un set di dati BigQuery per archiviare i tuoi dati.

Compressione JSON

Puoi utilizzare l'utilità gzip per comprimere i file JSON. Tieni presente che gzip esegue compressione completa dei file, a differenza della compressione di compressione per altri formati file, ad esempio Avro. Utilizzo di gzip per la compressione potrebbe avere un impatto sulle prestazioni; per ulteriori informazioni sui compromessi, vedi Caricamento di dati compressi e non compressi.

Caricamento di dati JSON in una nuova tabella

Per caricare dati JSON da Cloud Storage in un nuovo BigQuery tabella:

Console

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

   Vai a BigQuery

2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
1. Nella sezione Origine, seleziona Google Cloud Storage nell'elenco Crea tabella da. Poi segui questi passaggi:
   1. Seleziona un file dal bucket Cloud Storage o inserisci URI Cloud Storage. Non puoi includere più URI nella console Google Cloud, ma con i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nello stesso posizione come il set di dati che contiene la tabella da creare, aggiungere o sovrascrivere.
   2. In Formato file, seleziona JSONL (JSON delimitato da nuova riga).
2. Nella sezione Destinazione, specifica i seguenti dettagli:
   .
   1. In Set di dati, seleziona il set di dati in cui creare il tabella.
   2. Nel campo Tabella, inserisci il nome della tabella da creare.
   3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
3. Nella sezione Schema, inserisci lo schema. definizione di Kubernetes. Per attivare il rilevamento automatico di uno schema: Seleziona Rilevamento automatico. Puoi inserire le informazioni sullo schema manualmente utilizzando uno dei seguenti utilizza i seguenti metodi:
   • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di un array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando è la stessa procedura utilizzata per la creazione di un file di schema JSON. Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo quanto segue: :

         bq show --format=prettyjson dataset.table
         

   • Opzione 2: fai clic su Aggiungi campo e inserisci lo schema della tabella. Specifica il Nome di ogni campo, Tipo, e Modalità.
4. (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, vedi Creazione di tabelle partizionate e Creazione e utilizzo di tabelle in cluster.
5. Fai clic su Opzioni avanzate ed esegui le seguenti operazioni:
   .
   • In Write preference (Preferenza di scrittura), lascia selezionata l'opzione Write if empty (Scrivi se vuoto). Questo crea una nuova tabella e carica i dati al suo interno.
   • In Numero di errori consentiti, accetta il valore predefinito 0 oppure inserisci il numero massimo di righe contenenti errori che possono essere ignorati. Se il numero di righe con errori supera questo valore, il job restituiscono un messaggio invalid e l'operazione non riesce. Questa opzione si applica solo ai file CSV e JSON.
   • Se vuoi ignorare i valori in una riga che non sono presenti nello schema della tabella: Seleziona Valori sconosciuti.
   • 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.
6. Fai clic su Crea tabella.

Nota: quando carichi i dati in una tabella vuota utilizzando il metodo Console Google Cloud, non puoi aggiungere etichette, descrizioni e tabelle o alla scadenza della partizione.

Dopo aver creato la tabella, puoi aggiornarne la scadenza, descrizione ed etichette, ma non puoi aggiungere una scadenza per la partizione dopo viene creata usando la console Google Cloud. Per ulteriori informazioni, vedi Gestire le tabelle.

SQL

Utilizza la LOAD DATA Istruzione DDL. L'esempio seguente carica un file JSON 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
   (x INT64,y STRING)
   FROM FILES (
     format = 'JSON',
     uris = ['gs://bucket/path/file.json']);
   

3. Fai clic su Esegui.

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

bq

Usa il comando bq load, specifica NEWLINE_DELIMITED_JSON tramite il --source_format e includi un URI Cloud Storage. Puoi includere un singolo URI, un elenco di URI separati da virgole o un URI che contengono un carattere jolly. Fornisci lo schema in linea, in un file di definizione dello schema, oppure utilizza rilevamento automatico dello schema.

(Facoltativo) Fornisci il flag --location e imposta il valore su località.

Altri flag facoltativi includono:

• --max_bad_records: un numero intero che specifica il numero massimo di errori consentiti prima dell'esito negativo dell'intero job. Il valore predefinito è 0. Alle ore vengono restituiti cinque errori di qualsiasi tipo, indipendentemente dal Valore --max_bad_records.
• --ignore_unknown_values: se specificato, consente e ignora gli extra, valori non riconosciuti nei dati CSV o JSON.
• --autodetect: se specificato, attiva il rilevamento automatico dello schema per CSV e Dati JSON.
• --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 partizionata in base a una colonna DATE, DATETIME o TIMESTAMP. La 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 occorre eliminare una partizione temporale. La scadenza valuta con la data UTC della partizione più il valore intero.
• --time_partitioning_field: la colonna DATE o TIMESTAMP utilizzata per una tabella partizionata. Se il partizionamento basato sul tempo è abilitato senza viene creata una tabella partizionata per data di importazione.
• --require_partition_filter: quando è abilitata, questa opzione richiede agli utenti per 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 utilizzato per creare una tabella in cluster.

• --destination_kms_key: la chiave Cloud KMS per la crittografia dei file e i 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 JSON in BigQuery, inserisci questo comando:

bq --location=LOCATION load \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Sostituisci quanto segue:

• LOCATION: la tua posizione. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery Regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi imposta un valore predefinito per la località utilizzando file.bigqueryrc.
• FORMAT: NEWLINE_DELIMITED_JSON.
• DATASET: un set di dati esistente.
• TABLE: il nome della tabella in cui ti trovi caricare i dati.
• PATH_TO_SOURCE: un nome completo URI Cloud Storage oppure un elenco di URI separati da virgole. Caratteri jolly sono supportate.
• SCHEMA: uno schema valido. Lo schema può essere un cluster JSON o può essere digitato in linea come parte del comando. Se utilizzi un di schema, non specificarne un'estensione. Puoi anche usa il flag --autodetect anziché fornire una definizione dello schema.

Esempi:

Il seguente comando carica i dati da gs://mybucket/mydata.json in un tabella denominata mytable in mydataset. Lo schema è definito in un ambiente file di schema denominato myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

Il seguente comando carica i dati da gs://mybucket/mydata.json in un nuovo tabella partizionata per data di importazione denominata mytable in mydataset. Lo schema è definito in un file di schema locale denominato myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    --time_partitioning_type=DAY \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

Il seguente comando carica i dati da gs://mybucket/mydata.json in un tabella partizionata denominata mytable in mydataset. La tabella è partizionata nella colonna mytimestamp. Lo schema viene definito in un file di schema locale denominato myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    --time_partitioning_field mytimestamp \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

Il seguente comando carica i dati da gs://mybucket/mydata.json in un tabella denominata mytable in mydataset. Lo schema viene rilevato automaticamente.

    bq load \
    --autodetect \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json

Il seguente comando carica i dati da gs://mybucket/mydata.json in un tabella denominata mytable in mydataset. Lo schema è definito in linea formato FIELD:DATA_TYPE, FIELD:DATA_TYPE.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    qtr:STRING,sales:FLOAT,year:STRING

Nota: quando specifichi lo schema utilizzando lo strumento bq, non puoi se includi un tipo RECORD (STRUCT), non puoi includere un descrizione del campo e non puoi specificare la modalità del campo. Tutti i campi le modalità predefinite sono NULLABLE. Per includere descrizioni dei campi, modalità e RECORD tipi, fornisci un file di schema JSON

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

    bq load \
    --autodetect \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata*.json

Il seguente comando carica dati da più file in gs://mybucket/ in una tabella denominata mytable in mydataset. Il comando include una virgola elenco separato di URI di Cloud Storage con caratteri jolly. Lo schema è definito in un file di schema locale denominato myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    "gs://mybucket/00/*.json","gs://mybucket/01/*.json" \
    ./myschema

API

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

2. (Facoltativo) Specifica la tua località in la proprietà location nella sezione jobReference di risorse di lavoro.

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

4. Specifica il formato dei dati JSON impostando la proprietà sourceFormat su NEWLINE_DELIMITED_JSON.

5. Per controllare lo stato del lavoro, chiama jobs.get(JOB_ID*), sostituendo JOB_ID con l'ID del job restituito da la richiesta iniziale.

   • Se status.state = DONE, il job è stato completato correttamente.
   • Se è presente la proprietà status.errorResult, la richiesta non è riuscita. e include informazioni che descrivono cosa non ha funzionato. 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 importando alcune righe. Gli errori non irreversibili sono elencati nel job restituito dell'oggetto status.errors.

Note API:

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

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

• Chiamare jobs.insert su un determinato ID job è idempotente. Puoi riprovare come tutte le volte che desideri per lo stesso ID job e, al massimo, uno di questi operazioni eseguite correttamente.

C#

Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API C# BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Utilizza la BigQueryClient.CreateLoadJob() per avviare un job di caricamento da Cloud Storage. Per utilizzare JSON delimitato da nuova riga, crea un'istanza CreateLoadJobOptions e impostarne uno SourceFormat in FileFormat.NewlineDelimitedJson

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

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Utilizza la LoadJobConfiguration.builder(tableId, sourceUri) per avviare un job di caricamento da Cloud Storage. Per utilizzare JSON delimitato da nuova riga, utilizza LoadJobConfiguration.setFormatOptions(FormatOptions.json()).

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

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

// 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 json file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCS() {
  // Imports a GCS file into a table with manually defined schema.

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    location: 'US',
  };

  // 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), metadata);
  // 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;
  }
}

PHP

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table('us_states');

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
$schema = [
    'fields' => [
        ['name' => 'name', 'type' => 'string'],
        ['name' => 'post_abbr', 'type' => 'string']
    ]
];
$loadConfig = $table->loadFromStorage($gcsUri)->schema($schema)->sourceFormat('NEWLINE_DELIMITED_JSON');
$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Utilizza la Client.load_table_from_uri() per avviare un job di caricamento da Cloud Storage. Per utilizzare JSON delimitato da nuova riga, imposta il valore LoadJobConfig.source_format proprietà alla stringa NEWLINE_DELIMITED_JSON e passa la configurazione del job come job_config al metodo load_table_from_uri().

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

Ruby

Prima di provare questo esempio, segui le istruzioni per la configurazione di Ruby nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Ruby BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Utilizza la Dataset.load_job() per avviare un job di caricamento da Cloud Storage. Per utilizzare JSON delimitato da nuova riga, imposta il parametro format su "json".

require "google/cloud/bigquery"

def load_table_gcs_json dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
  table_id = "us_states"

  load_job = dataset.load_job table_id, gcs_uri, format: "json" do |schema|
    schema.string "name"
    schema.string "post_abbr"
  end
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done! # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end

Caricamento di dati JSON nidificati e ripetuti

BigQuery supporta il caricamento dati ripetuti provenienti da formati di origine che supportano schemi basati su oggetti, come JSON, Avro, ORC, Parquet, Firestore e Datastore.

Un oggetto JSON, inclusi eventuali campi nidificati/ripetuti, devono apparire su ogni riga.

L'esempio seguente mostra dati nidificati/ripetuti di esempio. Questa tabella contiene informazioni sulle persone. Comprende i seguenti campi:

• id
• first_name
• last_name
• dob (data di nascita)
• addresses (un campo nidificato e ripetuto)
  • addresses.status (attuale o precedente)
  • addresses.address
  • addresses.city
  • addresses.state
  • addresses.zip
  • addresses.numberOfYears (anni all'indirizzo)

Il file di dati JSON sarà simile al seguente. Nota che il campo dell'indirizzo contiene un array di valori (indicato da [ ]).

{"id":"1","first_name":"John","last_name":"Doe","dob":"1968-01-22","addresses":[{"status":"current","address":"123 First Avenue","city":"Seattle","state":"WA","zip":"11111","numberOfYears":"1"},{"status":"previous","address":"456 Main Street","city":"Portland","state":"OR","zip":"22222","numberOfYears":"5"}]}
{"id":"2","first_name":"Jane","last_name":"Doe","dob":"1980-10-16","addresses":[{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"},{"status":"previous","address":"321 Main Street","city":"Hoboken","state":"NJ","zip":"44444","numberOfYears":"3"}]}

Lo schema per questa tabella sarà il seguente:

[
    {
        "name": "id",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "first_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "last_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "dob",
        "type": "DATE",
        "mode": "NULLABLE"
    },
    {
        "name": "addresses",
        "type": "RECORD",
        "mode": "REPEATED",
        "fields": [
            {
                "name": "status",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "address",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "city",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "state",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "zip",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "numberOfYears",
                "type": "STRING",
                "mode": "NULLABLE"
            }
        ]
    }
]

Per informazioni su come specificare uno schema nidificato e ripetuto, consulta Specifica dei campi nidificati e ripetuti.

Caricamento di dati JSON semistrutturati

BigQuery supporta il caricamento di dati semistrutturati, in cui un campo può assumere valori di tipi diversi. L'esempio seguente mostra dati simili a il precedente dati JSON nidificati e ripetuti esempio, tranne per il fatto che il campo address può essere STRING, STRUCT o ARRAY:

{"id":"1","first_name":"John","last_name":"Doe","dob":"1968-01-22","address":"123 First Avenue, Seattle WA 11111"}

{"id":"2","first_name":"Jane","last_name":"Doe","dob":"1980-10-16","address":{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"}}

{"id":"3","first_name":"Bob","last_name":"Doe","dob":"1982-01-10","address":[{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"}, "321 Main Street Hoboken NJ 44444"]}

Puoi caricare questi dati in BigQuery utilizzando: schema:

[
    {
        "name": "id",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "first_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "last_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "dob",
        "type": "DATE",
        "mode": "NULLABLE"
    },
    {
        "name": "address",
        "type": "JSON",
        "mode": "NULLABLE"
    }
]

Il campo address è stato caricato in una colonna di tipo JSON che consente per tenere i tipi misti dell'esempio. Puoi importare dati come JSON contengono tipi misti o meno. Ad esempio, puoi specificare JSON anziché STRING come tipo per il campo first_name. Per ulteriori informazioni, vedi Utilizzo dei dati JSON in GoogleSQL.

Aggiunta o sovrascrittura di una tabella con dati JSON

Puoi caricare dati aggiuntivi in una tabella dai file di origine o aggiungendo i risultati della query.

Nella console Google Cloud, utilizza l'opzione Preferenza di scrittura per specificare quale azione eseguire quando carichi i dati da un file di origine o da una query o il risultato finale.

Quando carichi dati aggiuntivi in una tabella, hai a disposizione le seguenti opzioni:

Opzione della console	flag strumento bq	Proprietà API BigQuery	Descrizione
Scrivi se vuota	Non supportata	WRITE_EMPTY	Scrive i dati solo se la tabella è vuota.
Aggiungi a tabella	--noreplace o --replace=false; se --[no]replace non è specificato. Il valore predefinito è Aggiungi	WRITE_APPEND	(valore predefinito) Aggiunge i dati alla fine della tabella.
Sovrascrivi tabella	--replace o --replace=true	WRITE_TRUNCATE	Cancella tutti i dati esistenti in una tabella prima di scrivere i nuovi dati. Questa azione elimina anche lo schema della tabella, la sicurezza a livello di riga e rimuove eventuali Chiave Cloud KMS.

Se carichi i dati in una tabella esistente, il job di caricamento può aggiungere i dati o sovrascrivere la tabella.

Puoi aggiungere o sovrascrivere una tabella utilizzando uno dei seguenti elementi:

• Nella console Google Cloud
• Il comando bq load dello strumento a riga di comando bq
• Il metodo API jobs.insert e la configurazione di un job load
• Le librerie client

Nota: questa pagina non riguarda l'aggiunta o la sovrascrittura di tabelle partizionate. Per informazioni sull'aggiunta e la sovrascrittura delle tabelle partizionate, consulta: Aggiunta e sovrascrittura di tabella partizionata partizionate.

Console

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

   Vai a BigQuery

2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
1. Nella sezione Origine, seleziona Google Cloud Storage nell'elenco Crea tabella da. Poi segui questi passaggi:
   1. Seleziona un file dal bucket Cloud Storage o inserisci URI Cloud Storage. Non puoi includere più URI nella console Google Cloud, ma con i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nello stesso posizione come il set di dati che contiene la tabella da creare, aggiungere o sovrascrivere.
   2. In Formato file, seleziona JSONL (JSON delimitato da nuova riga).
Nota: è possibile modificare lo schema della tabella quando aggiungi o sovrascriverla. Per ulteriori informazioni sulle modifiche allo schema supportate durante operazione di caricamento, consulta l'articolo Modifica degli schemi delle tabelle.
2. Nella sezione Destinazione, specifica i seguenti dettagli:
   .
   1. In Set di dati, seleziona il set di dati in cui creare il tabella.
   2. Nel campo Tabella, inserisci il nome della tabella da creare.
   3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
3. Nella sezione Schema, inserisci lo schema. definizione di Kubernetes. Per attivare il rilevamento automatico di uno schema: Seleziona Rilevamento automatico. Puoi inserire le informazioni sullo schema manualmente utilizzando uno dei seguenti utilizza i seguenti metodi:
   • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di un array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando è la stessa procedura utilizzata per la creazione di un file di schema JSON. Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo quanto segue: :

         bq show --format=prettyjson dataset.table
         

   • Opzione 2: fai clic su Aggiungi campo e inserisci lo schema della tabella. Specifica il Nome di ogni campo, Tipo, e Modalità.
   Nota: è possibile modificare lo schema della tabella quando aggiungi o sovrascriverla. Per ulteriori informazioni sulle modifiche allo schema supportate durante dell'operazione di caricamento, vedi Modifica degli schemi delle tabelle.
4. (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, vedi Creazione di tabelle partizionate e Creazione e utilizzo di tabelle in cluster. Tu impossibile convertire una tabella in una tabella partizionata o in cluster aggiungendo o sovrascriverlo. La console Google Cloud non supporta aggiungendo o sovrascrivendo tabelle partizionate o in cluster in un job di caricamento.
5. Fai clic su Opzioni avanzate ed esegui le seguenti operazioni:
   .
   • In Preferenza di scrittura, scegli Aggiungi alla tabella o Sovrascrivi dalla tabella.
   • In Numero di errori consentiti, accetta il valore predefinito 0 oppure inserisci il numero massimo di righe contenenti errori che possono essere ignorati. Se il numero di righe con errori supera questo valore, il job restituiscono un messaggio invalid e l'operazione non riesce. Questa opzione si applica solo ai file CSV e JSON.
   • Se vuoi ignorare i valori in una riga che non sono presenti nello schema della tabella: Seleziona Valori sconosciuti.
   • 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.
6. Fai clic su Crea tabella.

SQL

Utilizza la LOAD DATA Istruzione DDL. L'esempio seguente aggiunge un file JSON 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 = 'JSON',
     uris = ['gs://bucket/path/file.json']);
   

3. Fai clic su Esegui.

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

bq

Usa il comando bq load, specifica NEWLINE_DELIMITED_JSON tramite il --source_format e includi un URI Cloud Storage. Puoi includere un singolo URI, un elenco di URI separati da virgole o un URI che contengono un carattere jolly.

Fornisci lo schema in linea, in un file di definizione dello schema, oppure utilizza rilevamento automatico dello schema.

Specifica il flag --replace per sovrascrivere tabella. Utilizza il flag --noreplace per aggiungere dati alla tabella. Se non è presente alcun flag specificato, il valore predefinito è l'aggiunta di dati.

È possibile modificare lo schema della tabella quando aggiungi o sovrascriverla. Per ulteriori informazioni sulle modifiche allo schema supportate durante un caricamento consulta l'articolo Modifica degli schemi delle tabelle.

(Facoltativo) Fornisci il flag --location e imposta il valore su località.

Altri flag facoltativi includono:

• --max_bad_records: un numero intero che specifica il numero massimo di errori consentiti prima dell'esito negativo dell'intero job. Il valore predefinito è 0. Alle ore vengono restituiti cinque errori di qualsiasi tipo, indipendentemente dal Valore --max_bad_records.
• --ignore_unknown_values: se specificato, consente e ignora gli extra, valori non riconosciuti nei dati CSV o JSON.
• --autodetect: se specificato, attiva il rilevamento automatico dello schema per CSV e Dati JSON.
• --destination_kms_key: la chiave Cloud KMS per la crittografia dei file e i dati della tabella.

bq --location=LOCATION load \
--[no]replace \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Sostituisci quanto segue:

• LOCATION: il tuo località. Il flag --location è facoltativo. Puoi impostare un valore predefinito per la località utilizzando il file.bigqueryrc.
• FORMAT: NEWLINE_DELIMITED_JSON.
• DATASET: un set di dati esistente.
• TABLE: il nome della tabella in cui ti trovi caricare i dati.
• PATH_TO_SOURCE: un nome completo URI Cloud Storage oppure un elenco di URI separati da virgole. Caratteri jolly sono supportate.
• SCHEMA: uno schema valido. Lo schema può essere un cluster JSON o può essere digitato in linea come parte del comando. Puoi anche usa il flag --autodetect anziché fornire una definizione dello schema.

Esempi:

Il comando seguente carica i dati da gs://mybucket/mydata.json e sovrascrive una tabella denominata mytable in mydataset. Lo schema è definito mediante il rilevamento automatico degli schemi.

    bq load \
    --autodetect \
    --replace \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json

Il comando seguente carica i dati da gs://mybucket/mydata.json e accoda dati a una tabella denominata mytable in mydataset. Lo schema è definita mediante un file di schema JSON: myschema.

    bq load \
    --noreplace \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

API

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

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

3. La proprietà source URIs devono essere pienamente qualificati, nel formato gs://BUCKET/OBJECT. Puoi Includere più URI sotto forma di elenco separato da virgole. La caratteri jolly sono .

4. Specifica il formato dei dati impostando il parametro configuration.load.sourceFormat a NEWLINE_DELIMITED_JSON.

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

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

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

// importJSONTruncate demonstrates loading data from newline-delimeted JSON data in Cloud Storage
// and overwriting/truncating data in the existing table.
func importJSONTruncate(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.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	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.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 overwrite the BigQuery table data by loading a JSON file from GCS
public class LoadJsonFromGCSTruncate {

  public static void runLoadJsonFromGCSTruncate() {
    // 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));
    loadJsonFromGCSTruncate(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCSTruncate(
      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())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_TRUNCATE)
              .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("Table is successfully overwritten by JSON 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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

// 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 JSON file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCSTruncate() {
  /**
   * 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 = "my_table";

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    // Set the write disposition to overwrite existing table data.
    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), metadata);
  // 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;
  }
}

PHP

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableID = 'The BigQuery table ID';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$table = $bigQuery->dataset($datasetId)->table($tableId);

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('NEWLINE_DELIMITED_JSON')->writeDisposition('WRITE_TRUNCATE');
$job = $table->runJob($loadConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});

// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

Per sostituire le righe in una tabella esistente, imposta il valore Proprietà LoadJobConfig.write_disposition alla stringa WRITE_TRUNCATE.

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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.NEWLINE_DELIMITED_JSON,
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
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))

Ruby

Per sostituire le righe in una tabella esistente, imposta il parametro write di Table.load_job() a "WRITE_TRUNCATE".

Prima di provare questo esempio, segui le istruzioni per la configurazione di Ruby nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Ruby BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

require "google/cloud/bigquery"

def load_table_gcs_json_truncate dataset_id = "your_dataset_id",
                                 table_id   = "your_table_id"

  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

  load_job = dataset.load_job table_id,
                              gcs_uri,
                              format: "json",
                              write:  "truncate"
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done! # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end

Caricamento di dati JSON partizionati in hive

BigQuery supporta il caricamento di dati JSON partizionati hive archiviati su Cloud Storage e compila le colonne di partizionamento hive come colonne in nella tabella gestita da BigQuery di destinazione. Per ulteriori informazioni, vedi Caricamento di dati partizionati esternamente.

Dettagli del caricamento dei dati JSON

Questa sezione descrive come BigQuery analizza i vari tipi di dati quando caricamento dei dati JSON.

Tipi di dati

Booleano: BigQuery può analizzare una qualsiasi delle seguenti coppie per Dati booleani: 1 o 0, vero o falso, t o f, sì o no oppure y o n (tutte le maiuscole insensibile). Rilevamento automatico dello schema automaticamente uno qualsiasi di questi, tranne 0 e 1.

Byte. Le colonne con tipi BYTES devono essere codificate come Base64.

Data: Le colonne di tipo DATE devono essere nel formato YYYY-MM-DD.

Data e ora. Le colonne con tipo DATETIME devono essere nel formato YYYY-MM-DD HH:MM:SS[.SSSSSS].

Area geografica. Le colonne con tipo GEOGRAPHY devono contenere stringhe in uno dei seguenti formati:

• Testo noto (WKT)
• WKB (Ben noto) binario.
• GeoJSON

Se utilizzi WKB, il valore deve essere codificato in formato esadecimale.

Il seguente elenco mostra esempi di dati validi:

• Durata: POINT(1 2)
• GeoJSON: { "type": "Point", "coordinates": [1, 2] }
• WKB con codifica esadecimale: 0101000000feffffffffffef3f0000000000000040

Prima di caricare i dati GEOGRAPHY, leggi anche Caricamento di dati geospaziali.

Intervallo. Le colonne con tipi INTERVAL devono essere in Formato ISO 8601 PYMDTHMS, dove:

• P = Designatore che indica che il valore rappresenta una durata. Devi lo includi sempre.
• Y = anno
• M = mese
• D = giorno
• T = Designatore che indica la parte della durata relativa al tempo. Devi lo includi sempre.
• H = ora
• M = minuto
• S = secondo. I secondi possono essere indicati come valori interi o frazionari di un massimo di sei cifre, con una precisione in microsecondi.

Puoi indicare un valore negativo anteponendo un trattino (-).

Il seguente elenco mostra esempi di dati validi:

• P-10000Y0M-3660000DT-87840000H0M0S
• P0Y0M0DT0H0M0.000001S
• P10000Y0M3660000DT87840000H0M0S

Per caricare dati INTERVAL, devi usare il comando bq load e poi --schema per specificare uno schema. Non puoi caricare dati INTERVAL tramite la console.

Ora. Le colonne con tipi TIME devono essere nel formato HH:MM:SS[.SSSSSS].

Timestamp: BigQuery accetta vari formati di timestamp. Il timestamp deve includere una parte relativa alla data e una all'ora.

• La parte della data può essere formattata come YYYY-MM-DD o YYYY/MM/DD.

• La parte del timestamp deve essere formattata nel formato HH:MM[:SS[.SSSSSS]] (secondi e le frazioni di secondo sono facoltative).

• Data e ora devono essere separate da uno spazio o da una "T".

• Facoltativamente, la data e l'ora possono essere seguite da una differenza dal fuso orario UTC o dal fuso orario UTC indicatore (Z). Per ulteriori informazioni, vedi Fusi orari:

Ad esempio, uno qualsiasi dei seguenti valori di timestamp è valido:

• 19-08-2018 12:11
• 2018-08-19 12:11:35
• 19-08-2018 12:11:35.22
• 19/08/2018 12:11
• 12:54:00 UTC 2018-07-05
• 19-08-2018 07:11:35.220 -05:00
• 2018-08-19T12:11:35.220Z

Se fornisci uno schema, BigQuery accetta anche il tempo di epoca Unix per i valori di timestamp. Tuttavia, il rilevamento automatico dello schema non rileva questo caso. considera il valore come un tipo numerico o stringa.

Esempi di valori di timestamp dell'epoca Unix:

• 1534680695
• 1,534680695e11

Array (campo ripetuto). Il valore deve essere un array JSON o null. JSON null viene convertito in SQL NULL. L'array stesso non può contenere null e i relativi valori.

Rilevamento automatico dello schema

In questa sezione viene descritto il comportamento rilevamento automatico dello schema durante il caricamento di file JSON.

Campi JSON nidificati e ripetuti

BigQuery deduce i campi nidificati e ripetuti nei file JSON. Se è un oggetto JSON, BigQuery carica la colonna come Tipo di RECORD. Se il valore di un campo è un array, BigQuery carica la colonna come colonna ripetuta. Per un esempio di dati JSON con elementi di dati ripetuti, consulta Caricamento di dati JSON nidificati e ripetuti.

Conversione stringa

Se abiliti il rilevamento automatico dello schema, BigQuery converte stringhe in tipi booleani, numerici o di data/ora, se possibile. Ad esempio: Utilizzando i seguenti dati JSON, il rilevamento automatico dello schema converte il campo id in una colonna INTEGER:

{ "name":"Alice","id":"12"}
{ "name":"Bob","id":"34"}
{ "name":"Charles","id":"45"}

Tipi di codifica

BigQuery si aspetta che i dati JSON siano codificati in UTF-8. Se disponi File JSON con altri tipi di codifica supportati, devi specificare esplicitamente la codifica utilizzando il flag --encoding in modo che BigQuery converte i dati in UTF-8.

BigQuery supporta i seguenti tipi di codifica per i file JSON:

• UTF-8
• ISO-8859-1
• UTF-16BE (UTF-16 Big Endian)
• UTF-16LE (UTF-16 Little Endian)
• UTF-32BE (UTF-32 Big Endian)
• UTF-32LE (UTF-32 Little Endian)

Opzioni JSON

Per modificare il modo in cui BigQuery analizza i dati JSON, specifica nella console Google Cloud, nello strumento a riga di comando bq, nell'API o nel client librerie.

Opzione JSON	Opzione della console	flag strumento bq	Proprietà API BigQuery	Descrizione
Numero di record non validi consentiti	Numero di errori consentiti	--max_bad_records	maxBadRecords (Java, Python)	(Facoltativo) Il numero massimo di record non validi che BigQuery può da ignorare quando esegui il job. Se il numero di record non validi supera questo , nel risultato del job viene restituito un errore non valido. Il valore predefinito è "0", che richiede che tutti i record siano validi.
Valori sconosciuti	Ignora valori sconosciuti	--ignore_unknown_values	ignoreUnknownValues (Java, Python)	(Facoltativo) Indica se BigQuery deve consentire valori aggiuntivi che non sono rappresentati nello schema della tabella. Se true, i valori aggiuntivi vengono ignorati. Se il valore è false, i record con colonne aggiuntive vengono considerati non validi. record; se sono presenti troppi record non validi, viene restituito un errore non valido restituito nel risultato del job. Il valore predefinito è false. Il formato "sourceFormat" determina quello che BigQuery considera un valore aggiuntivo: CSV: colonne finali, JSON: valori denominati che non corrispondono ad alcuna colonna i nomi degli utenti.
Codifica	Nessuno	-E o --encoding	encoding (Python)	(Facoltativo) La codifica dei caratteri dei dati. I valori supportati sono UTF-8, ISO-8859-1, UTF-16BE, UTF-16LE, UTF-32BE o UTF-32LE. Il valore predefinito è UTF-8.

Passaggi successivi

• Per informazioni sul caricamento di dati JSON da un file locale, vedi Caricamento di dati da file locali.
• Per ulteriori informazioni su come creare, importare ed eseguire query sui dati JSON, vedi Utilizzo dei dati JSON in GoogleSQL.