Caricamento dei dati JSON da Cloud Storage

Console

1. Nella console Trusted 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 add_box 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:
   1. Seleziona un file dal bucket Cloud Storage o inserisci l'URI Cloud Storage. Non puoi includere più URI nella Trusted Cloud console, ma i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nella stessa posizione del set di dati che contiene la tabella che vuoi creare, aggiungere o sovrascrivere.
   2. Per Formato file, seleziona JSONL (JSON delimitato da nuova riga).
2. Nella sezione Destinazione, specifica i seguenti dettagli:
   1. Per Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
   2. Nel campo Table (Tabella), inserisci il nome della tabella che vuoi creare.
   3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
3. Nella sezione Schema, inserisci la definizione dello schema. Per attivare il rilevamento automatico di uno schema, seleziona Rilevamento automatico. Puoi inserire manualmente le informazioni sullo schema utilizzando uno dei seguenti metodi:
   • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando lo stesso processo di creazione di un file schema JSON. Per visualizzare lo schema di una tabella esistente in formato JSON, inserisci il seguente comando:

         bq show --format=prettyjson dataset.table
         

   • Opzione 2: fai clic su add_box Aggiungi campo e inserisci lo schema della tabella. Specifica il nome, il tipo e la modalità di ogni campo.
4. (Facoltativo) Specifica le impostazioni di partizionamento e clustering. Per saperne di più, consulta Creare tabelle partizionate e Creare e utilizzare tabelle in cluster.
5. Fai clic su Opzioni avanzate e segui questi passaggi:
   • In Preferenza di scrittura, lascia selezionata l'opzione Scrivi se vuota. Questa opzione crea una nuova tabella e carica i dati al suo interno.
   • Per Numero di errori consentiti, accetta il valore predefinito di 0 o inserisci il numero massimo di righe contenenti errori che possono essere ignorate. Se il numero di righe con errori supera questo valore, il job restituirà un messaggio invalid e avrà esito negativo. Questa opzione si applica solo ai file CSV e JSON.
   • Per Fuso orario, inserisci il fuso orario predefinito che verrà applicato durante l'analisi dei valori timestamp che non hanno un fuso orario specifico. Controlla qui per altri nomi di fusi orari validi. Se questo valore non è presente, i valori timestamp senza un fuso orario specifico vengono analizzati utilizzando il fuso orario UTC predefinito. (Anteprima).
   • Per Formato data, inserisci gli elementi di formato che definiscono come vengono formattati i valori DATE nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, MM/DD/YYYY). Se questo valore è presente, questo formato è l'unico formato DATE compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna DATE in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo DATE viene analizzato con i formati predefiniti. (Anteprima).
   • Per Formato datetime, inserisci gli elementi di formato che definiscono come vengono formattati i valori DATETIME nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, MM/DD/YYYY HH24:MI:SS.FF3). Se questo valore è presente, questo formato è l'unico formato DATETIME compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna DATETIME in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo DATETIME viene analizzato con i formati predefiniti. (Anteprima).
   • Per Formato ora, inserisci gli elementi di formato che definiscono come vengono formattati i valori TIME nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, HH24:MI:SS.FF3). Se questo valore è presente, questo formato è l'unico formato TIME compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna TIME in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo TIME viene analizzato con i formati predefiniti. (Anteprima).
   • Per Formato timestamp, inserisci gli elementi di formato che definiscono come vengono formattati i valori TIMESTAMP nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, MM/DD/YYYY HH24:MI:SS.FF3). Se questo valore è presente, questo formato è l'unico TIMESTAMP compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna TIMESTAMP in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo TIMESTAMP viene analizzato con i formati predefiniti. (Anteprima).
   • Se vuoi ignorare i valori di una riga che non sono presenti nello schema della tabella, seleziona Valori sconosciuti.
   • Per la crittografia, fai clic su Chiave gestita dal cliente per utilizzare una chiave Cloud Key Management Service. Se lasci l'impostazione Google Cloud-powered key, BigQuery cripta i dati at rest.
6. Fai clic su Crea tabella.

SQL

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

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

   Vai a BigQuery

2. Nell'editor di 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 play_circle Esegui.

Per maggiori informazioni su come eseguire le query, consulta Eseguire una query interattiva.

bq

Utilizza il comando bq load, specifica NEWLINE_DELIMITED_JSON utilizzando 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 carattere jolly. Fornisci lo schema inline, in un file di definizione dello schema o utilizza il rilevamento automatico dello schema.

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

Altri flag facoltativi includono:

• --max_bad_records: un numero intero che specifica il numero massimo di record non validi consentiti prima che l'intero job non vada a buon fine. Il valore predefinito è 0. Vengono restituiti al massimo cinque errori di qualsiasi tipo, indipendentemente dal valore di --max_bad_records.
• --ignore_unknown_values: se specificato, consente e ignora valori extra e non riconosciuti nei dati CSV o JSON.
• --time_zone: (anteprima) un fuso orario predefinito facoltativo che verrà applicato durante l'analisi dei valori timestamp che non hanno un fuso orario specifico nei dati CSV o JSON.
• --date_format: (anteprima) una stringa personalizzata facoltativa che definisce come vengono formattati i valori DATE nei dati CSV o JSON.
• --datetime_format: (anteprima) una stringa personalizzata facoltativa che definisce il formato dei valori DATETIME nei dati CSV o JSON.
• --time_format: (anteprima) una stringa personalizzata facoltativa che definisce il formato dei valori TIME nei dati CSV o JSON.
• --timestamp_format: (anteprima) una stringa personalizzata facoltativa che definisce il formato dei valori TIMESTAMP nei dati CSV o JSON.
• --autodetect: se specificato, attiva il rilevamento automatico dello schema per i dati CSV e JSON.
• --time_partitioning_type: attiva il partizionamento basato sul 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 di una tabella esistente.
• --time_partitioning_expiration: un numero intero che specifica (in secondi) quando deve essere eliminata una partizione basata sul tempo. Il tempo di 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 è abilitato senza questo valore, viene creata una tabella partizionata per data di importazione.
• --require_partition_filter: se attivata, questa opzione richiede agli utenti di includere una clausola WHERE che specifica le partizioni da interrogare. Se il filtro di partizionamento è obbligatorio, i costi possono essere ridotti e le prestazioni migliorate. Per maggiori informazioni, consulta Richiedere un filtro di partizione nelle query.
• --clustering_fields: un elenco separato da virgole di massimo quattro nomi di colonne utilizzati per creare una tabella in cluster.

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

  Per ulteriori informazioni sulle tabelle partizionate, consulta:

  • Creazione di tabelle partizionate

  Per saperne di più sulle tabelle in cluster, consulta:

  • Creazione e utilizzo delle tabelle in cluster

  Per ulteriori informazioni sulla crittografia delle tabelle, vedi:

  • Protezione dei dati con le chiavi Cloud KMS

Per caricare i dati JSON in BigQuery, inserisci il seguente 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 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: NEWLINE_DELIMITED_JSON.
• DATASET: un set di dati esistente.
• TABLE: il nome della tabella in cui stai caricando i dati.
• PATH_TO_SOURCE: un URI Cloud Storage completo o un elenco di URI separati da virgole. Sono supportati anche i caratteri jolly.
• SCHEMA: uno schema valido. Lo schema può essere un file JSON locale oppure può essere digitato inline come parte del comando. Se utilizzi un file schema, non assegnargli un'estensione. Puoi anche utilizzare il flag --autodetect anziché fornire una definizione dello schema.

Esempi:

Il seguente comando carica i dati da gs://mybucket/mydata.json in una tabella denominata mytable in mydataset. Lo schema è definito in un file di schema locale 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 una nuova tabella partizionata per data di importazione denominata mytable in mydataset. Lo schema è definito in un file 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 una tabella partizionata denominata mytable in mydataset. La tabella è partizionata in base alla colonna mytimestamp. Lo schema è 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 una 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 una tabella denominata mytable in mydataset. Lo schema è definito inline nel 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

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. 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 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. 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 rimandi ai dati di origine in Cloud Storage.

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

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

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

5. Per controllare lo stato del job, chiama jobs.get(JOB_ID*), sostituendo JOB_ID con 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 è riuscita e l'oggetto include informazioni che descrivono cosa è andato storto. 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; tuttavia, potrebbero essersi verificati alcuni errori non fatali, ad esempio problemi durante l'importazione di alcune righe. Gli errori non irreversibili sono elencati nella proprietà status.errors dell'oggetto job restituito.

Note sull'API:

• I job di caricamento sono atomici e coerenti: se un job di caricamento non va a buon fine, nessuno dei dati è disponibile e se un job di caricamento va a buon fine, tutti i dati sono disponibili.

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

• La chiamata di jobs.insert su un determinato ID job è idempotente. Puoi riprovare tutte le volte che vuoi con lo stesso ID job e al massimo una di queste operazioni andrà a buon fine.

C#

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

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

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

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

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

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

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

Console

1. Nella console Trusted 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 add_box 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:
   1. Seleziona un file dal bucket Cloud Storage o inserisci l'URI Cloud Storage. Non puoi includere più URI nella Trusted Cloud console, ma i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nella stessa posizione del set di dati che contiene la tabella che vuoi creare, aggiungere o sovrascrivere.
   2. Per Formato file, seleziona JSONL (JSON delimitato da nuova riga).
2. Nella sezione Destinazione, specifica i seguenti dettagli:
   1. Per Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
   2. Nel campo Table (Tabella), inserisci il nome della tabella che vuoi creare.
   3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
3. Nella sezione Schema, inserisci la definizione dello schema. Per attivare il rilevamento automatico di uno schema, seleziona Rilevamento automatico. Puoi inserire manualmente le informazioni sullo schema utilizzando uno dei seguenti metodi:
   • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di array JSON. Quando utilizzi un array JSON, generi lo schema utilizzando lo stesso processo di creazione di un file schema JSON. Per visualizzare lo schema di una tabella esistente in formato JSON, inserisci il seguente comando:

         bq show --format=prettyjson dataset.table
         

   • Opzione 2: fai clic su add_box Aggiungi campo e inserisci lo schema della tabella. Specifica il nome, il tipo e la modalità di ogni campo.
4. (Facoltativo) Specifica le impostazioni di partizionamento e clustering. Per saperne di più, consulta Creare tabelle partizionate e Creare e utilizzare tabelle in cluster. Non puoi convertire una tabella in una tabella partizionata o in cluster aggiungendola o sovrascrivendola. La console Trusted Cloud non supporta l'aggiunta o la sovrascrittura di tabelle partizionate o in cluster in un job di caricamento.
5. Fai clic su Opzioni avanzate e segui questi passaggi:
   • In Preferenza di scrittura, scegli Aggiungi alla tabella o Sovrascrivi tabella.
   • Per Numero di errori consentiti, accetta il valore predefinito di 0 o inserisci il numero massimo di righe contenenti errori che possono essere ignorate. Se il numero di righe con errori supera questo valore, il job restituirà un messaggio invalid e avrà esito negativo. Questa opzione si applica solo ai file CSV e JSON.
   • Per Fuso orario, inserisci il fuso orario predefinito che verrà applicato durante l'analisi dei valori timestamp che non hanno un fuso orario specifico. Controlla qui per altri nomi di fusi orari validi. Se questo valore non è presente, i valori timestamp senza un fuso orario specifico vengono analizzati utilizzando il fuso orario UTC predefinito. (Anteprima).
   • Per Formato data, inserisci gli elementi di formato che definiscono come vengono formattati i valori DATE nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, MM/DD/YYYY). Se questo valore è presente, questo formato è l'unico formato DATE compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna DATE in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo DATE viene analizzato con i formati predefiniti. (Anteprima).
   • Per Formato datetime, inserisci gli elementi di formato che definiscono come vengono formattati i valori DATETIME nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, MM/DD/YYYY HH24:MI:SS.FF3). Se questo valore è presente, questo formato è l'unico formato DATETIME compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna DATETIME in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo DATETIME viene analizzato con i formati predefiniti. (Anteprima).
   • Per Formato ora, inserisci gli elementi di formato che definiscono come vengono formattati i valori TIME nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, HH24:MI:SS.FF3). Se questo valore è presente, questo formato è l'unico formato TIME compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna TIME in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo TIME viene analizzato con i formati predefiniti. (Anteprima).
   • Per Formato timestamp, inserisci gli elementi di formato che definiscono come vengono formattati i valori TIMESTAMP nei file di input. Questo campo prevede il formato degli stili SQL (ad esempio, MM/DD/YYYY HH24:MI:SS.FF3). Se questo valore è presente, questo formato è l'unico TIMESTAMP compatibile. Il rilevamento automatico dello schema determinerà anche il tipo di colonna TIMESTAMP in base a questo formato anziché a quello esistente. Se questo valore non è presente, il campo TIMESTAMP viene analizzato con i formati predefiniti. (Anteprima).
   • Se vuoi ignorare i valori di una riga che non sono presenti nello schema della tabella, seleziona Valori sconosciuti.
   • Per la crittografia, fai clic su Chiave gestita dal cliente per utilizzare una chiave Cloud Key Management Service. Se lasci l'impostazione Google Cloud-powered key, BigQuery cripta i dati at rest.
6. Fai clic su Crea tabella.

SQL

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

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

   Vai a BigQuery

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

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

3. Fai clic su play_circle Esegui.

Per maggiori informazioni su come eseguire le query, consulta Eseguire una query interattiva.

bq

Utilizza il comando bq load, specifica NEWLINE_DELIMITED_JSON utilizzando 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 carattere jolly.

Fornisci lo schema inline, in un file di definizione dello schema o utilizza il rilevamento automatico dello schema.

Specifica il flag --replace per sovrascrivere la tabella. Utilizza il flag --noreplace per aggiungere dati alla tabella. Se non viene specificato alcun flag, il comportamento predefinito è l'aggiunta dei dati.

È possibile modificare lo schema della tabella quando la accodi o la sovrascrivi. Per ulteriori informazioni sulle modifiche allo schema supportate durante un'operazione di caricamento, vedi Modifica degli schemi delle tabelle.

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

Altri flag facoltativi includono:

• --max_bad_records: un numero intero che specifica il numero massimo di record non validi consentiti prima che l'intero job non vada a buon fine. Il valore predefinito è 0. Vengono restituiti al massimo cinque errori di qualsiasi tipo, indipendentemente dal valore di --max_bad_records.
• --ignore_unknown_values: se specificato, consente e ignora valori extra e non riconosciuti nei dati CSV o JSON.
• --time_zone: (anteprima) un fuso orario predefinito facoltativo che verrà applicato durante l'analisi dei valori timestamp che non hanno un fuso orario specifico nei dati CSV o JSON.
• --date_format: (anteprima) una stringa personalizzata facoltativa che definisce come vengono formattati i valori DATE nei dati CSV o JSON.
• --datetime_format: (anteprima) una stringa personalizzata facoltativa che definisce il formato dei valori DATETIME nei dati CSV o JSON.
• --time_format: (anteprima) una stringa personalizzata facoltativa che definisce il formato dei valori TIME nei dati CSV o JSON.
• --timestamp_format: (anteprima) una stringa personalizzata facoltativa che definisce il formato dei valori TIMESTAMP nei dati CSV o JSON.
• --autodetect: se specificato, attiva il rilevamento automatico dello schema per i dati CSV e JSON.
• --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 \
SCHEMA

Sostituisci quanto segue:

• LOCATION: la tua posizione. 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 stai caricando i dati.
• PATH_TO_SOURCE: un URI Cloud Storage completo o un elenco di URI separati da virgole. Sono supportati anche i caratteri jolly.
• SCHEMA: uno schema valido. Lo schema può essere un file JSON locale oppure può essere digitato inline come parte del comando. Puoi anche utilizzare il flag --autodetect anziché fornire una definizione dello schema.

Esempi:

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

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

Il seguente comando carica i dati da gs://mybucket/mydata.json e aggiunge i dati a una tabella denominata mytable in mydataset. Lo schema è definito utilizzando 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 rimandi ai dati di origine in Cloud Storage.

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

3. La proprietà source URIs deve essere completa, nel formato gs://BUCKET/OBJECT. Puoi includere più URI come elenco separato da virgole. Sono supportati anche i caratteri jolly.

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

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

Vai

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

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

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 la proprietà LoadJobConfig.write_disposition sulla stringa WRITE_TRUNCATE.

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() su "WRITE_TRUNCATE".

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