Carica i dati in batch

Il caricamento in batch di BigQuery consente di importare i dati da Cloud Storage o da un file locale in una tabella nuova o esistente in un singolo job di caricamento. Puoi caricare file Avro, valori separati da virgola (CSV), JSON delimitato da nuova riga, ORC o Parquet, nonché esportazioni di Datastore e Firestore archiviate in Cloud Storage. Per automatizzare i caricamenti ricorrenti da Cloud Storage in BigQuery, puoi utilizzare BigQuery Data Transfer Service.

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di BigQuery in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

Prova BigQuery senza costi

Prima di iniziare

Concedi i ruoli Identity and Access Management (IAM) che forniscono agli utenti le autorizzazioni necessarie per eseguire ogni attività in questo documento e crea un set di dati per archiviare i tuoi dati.

Autorizzazioni obbligatorie

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

Autorizzazioni per caricare i dati in BigQuery

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

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

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

  • 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 saperne di più sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Ruoli e autorizzazioni 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 il ruolo IAM Storage Admin (roles/storage.admin) sul bucket. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per caricare i dati da un bucket Cloud Storage. Per vedere quali sono esattamente le autorizzazioni richieste, 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 ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Crea un set di dati

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

Caricamento dei dati da Cloud Storage

BigQuery supporta il caricamento di dati da una delle seguenti classi di archiviazione di Cloud Storage:

  • Standard
  • Nearline
  • Coldline
  • Archivia

Per scoprire come caricare i dati in BigQuery, consulta la pagina relativa al tuo formato dei dati:

Per scoprire come configurare un caricamento ricorrente da Cloud Storage in BigQuery, consulta Trasferimenti da Cloud Storage.

Considerazioni sulla località

Non puoi modificare la località di un set di dati dopo la sua creazione, ma puoi crearne una copia o spostarlo manualmente. Per saperne di più, vedi:

Recupero dell'URI Cloud Storage

Per caricare i dati da un'origine dati Cloud Storage, devi fornire l'URI Cloud Storage.

Il percorso della risorsa Cloud Storage contiene il nome del bucket e l'oggetto (nome file). Ad esempio, se il bucket Cloud Storage si chiama mybucket e il file di dati si chiama myfile.csv, il percorso della risorsa sarà gs://mybucket/myfile.csv.

BigQuery non supporta i percorsi delle risorse Cloud Storage che includono più barre consecutive dopo la doppia barra iniziale. I nomi degli oggetti Cloud Storage possono contenere più barre ("/") consecutive. Tuttavia, BigQuery converte più barre consecutive in una singola barra. Ad esempio, il seguente percorso della risorsa, sebbene valido in Cloud Storage, non funziona in BigQuery: gs://bucket/my//object//name.

Per recuperare il percorso della risorsa Cloud Storage:

  1. Apri la console Cloud Storage.

    Console Cloud Storage

  2. Sfoglia fino alla posizione dell'oggetto (file) che contiene i dati di origine.

  3. Fai clic sul nome dell'oggetto.

    Viene visualizzata la pagina Dettagli oggetto.

  4. Copia il valore fornito nel campo URI gsutil, che inizia con gs://.

Per le esportazioni di Google Datastore, è possibile specificare un solo URI, che deve terminare con .backup_info o .export_metadata.

Supporto dei caratteri jolly per gli URI Cloud Storage

Se i dati sono suddivisi in più file, puoi utilizzare un carattere jolly asterisco (*) per selezionare più file. L'utilizzo del carattere jolly asterisco deve seguire queste regole:

  • L'asterisco può apparire all'interno del nome dell'oggetto o alla fine del nome dell'oggetto.
  • L'utilizzo di più asterischi non è supportato. Ad esempio, il percorso gs://mybucket/fed-*/temp/*.csv non è valido.
  • L'utilizzo di un asterisco con il nome del bucket non è supportato.

Esempi:

  • L'esempio seguente mostra come selezionare tutti i file in tutte le cartelle che iniziano con il prefisso gs://mybucket/fed-samples/fed-sample:

    gs://mybucket/fed-samples/fed-sample*

  • L'esempio seguente mostra come selezionare solo i file con estensione .csv nella cartella denominata fed-samples e in tutte le sottocartelle di fed-samples:

    gs://mybucket/fed-samples/*.csv

  • L'esempio seguente mostra come selezionare i file con un pattern di denominazione di fed-sample*.csv nella cartella denominata fed-samples. Questo esempio non seleziona i file nelle sottocartelle di fed-samples.

    gs://mybucket/fed-samples/fed-sample*.csv

Quando utilizzi lo strumento a riga di comando bq, potrebbe essere necessario eseguire l'escape dell'asterisco su alcune piattaforme.

Non puoi utilizzare un carattere jolly asterisco quando carichi i dati di esportazione di Datastore o Firestore da Cloud Storage.

Limitazioni

Quando carichi dati in BigQuery da un bucket Cloud Storage, si applicano le seguenti limitazioni:

  • BigQuery non garantisce la coerenza dei dati per le origini dati esterne. Le modifiche ai dati sottostanti durante l'esecuzione di una query possono causare comportamenti imprevisti.
  • BigQuery non supporta il controllo delle versioni degli oggetti di Cloud Storage. Se includi un numero di generazione nell'URI Cloud Storage, il job di caricamento non va a buon fine.

A seconda del formato dei dati di origine di Cloud Storage, potrebbero essere applicate limitazioni aggiuntive. Per saperne di più, vedi:

Caricamento dei dati dai file locali

Puoi caricare i dati da un'origine dati leggibile (ad esempio la tua macchina locale) utilizzando uno dei seguenti metodi:

  • La console Google Cloud
  • Il comando bq load dello strumento a riga di comando bq
  • L'API
  • Librerie client

Quando carichi i dati utilizzando la console Google Cloud o lo strumento a riga di comando bq, viene creato automaticamente un job di caricamento.

Per caricare i dati da un'origine dati locale:

Console

  1. Apri la pagina BigQuery nella console Google Cloud .

    Vai alla pagina BigQuery

  2. Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

    Pulsante evidenziato per il riquadro Spazio di esplorazione.

    Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.

  3. Nel riquadro Explorer, espandi il progetto, fai clic su Set di dati, quindi seleziona un set di dati.

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

  5. Nella pagina Crea tabella, nella sezione Origine:

    • In Crea tabella da, seleziona Carica.
    • In Seleziona file, fai clic su Sfoglia.
    • Sfoglia fino al file e fai clic su Apri. Tieni presente che i caratteri jolly e gli elenchi separati da virgole non sono supportati per i file locali.
    • In Formato file, seleziona CSV, JSON (delimitato da nuova riga), Avro, Parquet o ORC.

  6. Nella pagina Crea tabella, nella sezione Destinazione:

    • In Progetto, scegli il progetto appropriato.
    • In Set di dati, scegli il set di dati appropriato.
    • Nel campo Tabella, inserisci il nome della tabella che stai creando in BigQuery.
    • Verifica che Tipo di tabella sia impostato su Tabella nativa.

  7. Nella sezione Schema, inserisci la definizione dello schema.

    • Per i file CSV e JSON, puoi selezionare l'opzione Rilevamento automatico per attivare il rilevamento automatico dello schema. Le informazioni sullo schema sono autodescritte nei dati di origine per altri tipi di file supportati.

    • Puoi anche inserire manualmente le informazioni sullo schema:

      • Fai clic su Modifica come testo e inserisci lo schema della tabella come array JSON:

      • Utilizzando Aggiungi campo per inserire manualmente lo schema.

  8. Seleziona gli elementi applicabili nella sezione Opzioni avanzate. Per informazioni sulle opzioni disponibili, consulta Opzioni CSV e Opzioni JSON.

  9. (Facoltativo) Nella sezione Opzioni avanzate, scegli la disposizione di scrittura:

    • Scrivi se vuota: scrive i dati solo se la tabella è vuota.
    • Aggiungi alla tabella: aggiungi i dati alla fine della tabella. Questa è l'impostazione predefinita.
    • Sovrascrivi tabella: cancella tutti i dati esistenti nella tabella prima di scrivere i nuovi dati.

  10. Fai clic su Crea tabella.

bq

Utilizza il comando bq load, specifica source_format e includi il percorso del file locale.

(Facoltativo) Specifica il flag --location e imposta il valore sulla tua località.

Se carichi i dati in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: PROJECT_ID:DATASET.

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

Sostituisci quanto segue:

  • LOCATION: la tua località. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, imposta il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando il file .bigqueryrc.
  • FORMAT: CSV, AVRO, PARQUET, ORC o NEWLINE_DELIMITED_JSON.
  • project_id: il tuo ID progetto.
  • dataset: un set di dati esistente.
  • table: il nome della tabella in cui stai caricando i dati.
  • path_to_source: il percorso del file locale.
  • schema: uno schema valido. Lo schema può essere un file JSON locale o può essere digitato in linea come parte del comando. Puoi anche utilizzare il flag --autodetect anziché fornire una definizione dello schema.

Inoltre, puoi aggiungere flag per le opzioni che ti consentono di controllare il modo in cui BigQuery analizza i dati. Ad esempio, puoi utilizzare il flag --skip_leading_rows per ignorare le righe di intestazione in un file CSV. Per saperne di più, consulta Opzioni CSV e Opzioni JSON.

Esempi:

Il seguente comando carica un file JSON locale delimitato da nuova riga (mydata.json) in una tabella denominata mytable in mydataset nel progetto predefinito. Lo schema è definito in un file di schema locale denominato myschema.json.

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

Il seguente comando carica un file CSV locale (mydata.csv) in una tabella denominata mytable in mydataset in myotherproject. Lo schema è definito in linea nel formato FIELD:DATA_TYPE, FIELD:DATA_TYPE.

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

Il seguente comando carica un file CSV locale (mydata.csv) in una tabella denominata mytable in mydataset nel progetto predefinito. Lo schema viene definito utilizzando il rilevamento automatico dello schema.

    bq load \
    --autodetect \
    --source_format=CSV \
    mydataset.mytable \
    ./mydata.csv

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery C#.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale di un altro formato, utilizza la classe delle opzioni di aggiornamento per il formato appropriato dalla classe base JobCreationOptions anziché UploadCsvOptions.


using Google.Cloud.BigQuery.V2;
using System;
using System.IO;

public class BigQueryLoadFromFile
{
    public void LoadFromFile(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id",
        string filePath = "path/to/file.csv"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Create job configuration
        var uploadCsvOptions = new UploadCsvOptions()
        {
            SkipLeadingRows = 1,  // Skips the file headers
            Autodetect = true
        };
        using (FileStream stream = File.Open(filePath, FileMode.Open))
        {
            // Create and run job
            // Note that there are methods available for formats other than CSV
            BigQueryJob job = client.UploadCsv(
                datasetId, tableId, null, stream, uploadCsvOptions);
            job = job.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.

            // Display the number of rows uploaded
            BigQueryTable table = client.GetTable(datasetId, tableId);
            Console.WriteLine(
                $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
        }
    }
}

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Go.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale di un altro formato, imposta la proprietà DataFormat di NewReaderSource sul formato appropriato.

import (
	"context"
	"fmt"
	"os"

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

// importCSVFromFile demonstrates loading data into a BigQuery table using a file on the local filesystem.
func importCSVFromFile(projectID, datasetID, tableID, filename 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()

	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	source := bigquery.NewReaderSource(f)
	source.AutoDetect = true   // Allow BigQuery to determine schema.
	source.SkipLeadingRows = 1 // CSV has a single header line.

	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(source)

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale di un altro formato, imposta FormatOptions sul formato appropriato.

TableId tableId = TableId.of(datasetName, tableName);
WriteChannelConfiguration writeChannelConfiguration =
    WriteChannelConfiguration.newBuilder(tableId).setFormatOptions(FormatOptions.csv()).build();
// The location must be specified; other fields can be auto-detected.
JobId jobId = JobId.newBuilder().setLocation(location).build();
TableDataWriteChannel writer = bigquery.writer(jobId, writeChannelConfiguration);
// Write data to writer
try (OutputStream stream = Channels.newOutputStream(writer)) {
  Files.copy(csvPath, stream);
}
// Get load job
Job job = writer.getJob();
job = job.waitFor();
LoadStatistics stats = job.getStatistics();
return stats.getOutputRows();

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale di un altro formato, imposta il parametro metadata della funzione load sul formato appropriato.

// Imports the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function loadLocalFile() {
  // Imports a local file into a table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const filename = '/path/to/file.csv';
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Load data from a local file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(filename);

  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 di configurazione di PHP nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery PHP.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale in un altro formato, imposta sourceFormat sul formato appropriato.

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';
// $source     = 'The path to the CSV source file to import';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
// create the import job
$loadConfig = $table->load(fopen($source, 'r'))->sourceFormat('CSV');

$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    printf('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 di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale in un altro formato, imposta la proprietà LoadJobConfig.source_format sul formato appropriato.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.LoadJobConfig(
    source_format=bigquery.SourceFormat.CSV, skip_leading_rows=1, autodetect=True,
)

with open(file_path, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_id, job_config=job_config)

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

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

Ruby

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Ruby.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Il seguente codice mostra come caricare un file CSV locale in una nuova tabella BigQuery. Per caricare un file locale di un altro formato, imposta il parametro format del metodo Table#load_job sul formato appropriato.

require "google/cloud/bigquery"

def load_from_file dataset_id = "your_dataset_id",
                   file_path  = "path/to/file.csv"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "new_table_id"

  # Infer the config.location based on the location of the referenced dataset.
  load_job = dataset.load_job table_id, file_path do |config|
    config.skip_leading = 1
    config.autodetect   = true
  end
  load_job.wait_until_done! # Waits for table load to complete.

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

Limitazioni

Il caricamento dei dati da un'origine dati locale è soggetto alle seguenti limitazioni:

  • I caratteri jolly e gli elenchi separati da virgole non sono supportati quando carichi file da un'origine dati locale. I file devono essere caricati singolarmente.
  • Quando utilizzi la console Google Cloud , i file caricati da un'origine dati locale non possono superare i 100 MB. Per i file di dimensioni maggiori, caricali da Cloud Storage.

Capacità dei job di caricamento

Analogamente alla modalità on demand per le query, per impostazione predefinita i job di caricamento utilizzano un pool di slot condiviso. Se un job di caricamento utilizza il pool condiviso, la prenotazione default-pipeline viene visualizzata nei dettagli del job. BigQuery non garantisce la capacità disponibile di questo pool condiviso o la velocità effettiva del job di caricamento.

Per aumentare il throughput o controllare in modo prevedibile la capacità dei job di caricamento, puoi creare una prenotazione di slot e assegnare slot PIPELINE dedicati per eseguire i job di caricamento. Per saperne di più, consulta Assegnazioni delle prenotazioni.

Caricamento di dati compressi e non compressi

Per i formati Avro, Parquet e ORC, BigQuery supporta il caricamento di file in cui i dati sono stati compressi utilizzando un codec supportato. Tuttavia, BigQuery non supporta il caricamento di file in questi formati che sono stati compressi, ad esempio utilizzando l'utilità gzip.

Il formato binario Avro è il formato preferito per il caricamento di dati compressi e non compressi. I dati Avro vengono caricati più velocemente perché possono essere letti in parallelo, anche quando i data block sono compressi. Per un elenco dei codec di compressione supportati, consulta Compressione Avro.

Anche il formato binario Parquet è una buona scelta perché la codifica efficiente per colonna di Parquet si traduce in genere in un rapporto di compressione migliore e in file più piccoli. I file Parquet sfruttano anche tecniche di compressione che consentono di caricare i file in parallelo. Per un elenco dei codec di compressione supportati, consulta Compressione Parquet.

Il formato binario ORC offre vantaggi simili a quelli del formato Parquet. I dati nei file ORC vengono caricati rapidamente perché gli stripe di dati possono essere letti in parallelo. Le righe di ogni stripe di dati vengono caricate in sequenza. Per ottimizzare il tempo di caricamento, utilizza una dimensione della sezione di dati di circa 256 MB o inferiore. Per un elenco dei codec di compressione supportati, consulta Compressione ORC.

Per altri formati di dati, come CSV e JSON, BigQuery può caricare i file non compressi molto più velocemente di quelli compressi, perché i file non compressi possono essere letti in parallelo. Poiché i file non compressi sono più grandi, il loro utilizzo può comportare limitazioni della larghezza di banda e costi di Cloud Storage più elevati per i dati gestiti temporaneamente in Cloud Storage prima di essere caricati in BigQuery. Tieni presente che l'ordine delle righe non è garantito per i file compressi o non compressi. È importante valutare questi compromessi in base al tuo caso d'uso.

In generale, se la larghezza di banda è limitata, comprimi i file CSV e JSON utilizzando gzip prima di caricarli su Cloud Storage. gzip è l'unico tipo di compressione dei file supportato per i file CSV e JSON durante il caricamento dei dati in BigQuery. Se la velocità di caricamento è importante per la tua app e hai molta larghezza di banda per caricare i dati, lascia i file non compressi.

Aggiunta o sovrascrittura di una tabella

Puoi caricare dati aggiuntivi in una tabella dai file di origine o aggiungendo i risultati delle query. Se lo schema dei dati non corrisponde allo schema della tabella di destinazione o della partizione, puoi aggiornare lo schema quando lo aggiungi o lo sovrascrivi.

Se aggiorni lo schema quando aggiungi dati, BigQuery ti consente di:

  • Aggiungi nuovi campi
  • Rilassa REQUIRED campi in NULLABLE

Se sovrascrivi una tabella, lo schema viene sempre sovrascritto. Gli aggiornamenti dello schema non sono limitati quando sovrascrivi una tabella.

Nella console Google Cloud , utilizza l'opzione Preferenza di scrittura per specificare l'azione da intraprendere quando carichi i dati da un file di origine o da un risultato di una query. Lo strumento a riga di comando bq e l'API includono le seguenti opzioni:

Opzione della console flag dello strumento bq Proprietà API BigQuery Descrizione
Scrivi se vuota Nessuno WRITE_EMPTY Scrive i dati solo se la tabella è vuota.
Aggiungi a tabella --noreplace o --replace=false; se --replace non è specificato, il valore predefinito è append WRITE_APPEND (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.

Criteri per le quote

Per informazioni sulla policy sulle quote per il caricamento dei dati in batch, consulta Job di caricamento nella pagina Quote e limiti.

Visualizza l'utilizzo attuale della quota

Puoi visualizzare l'utilizzo attuale dei job di query, caricamento, estrazione o copia eseguendo una query INFORMATION_SCHEMA per visualizzare i metadati relativi ai job eseguiti in un periodo di tempo specificato. Puoi confrontare l'utilizzo attuale con il limite della quota per determinare l'utilizzo della quota per un tipo di job specifico. La seguente query di esempio utilizza la vista INFORMATION_SCHEMA.JOBS per elencare il numero di job di query, caricamento, estrazione e copia per progetto:

SELECT
  sum(case  when job_type="QUERY" then 1 else 0 end) as QRY_CNT,
  sum(case  when job_type="LOAD" then 1 else 0 end) as LOAD_CNT,
  sum(case  when job_type="EXTRACT" then 1 else 0 end) as EXT_CNT,
  sum(case  when job_type="COPY" then 1 else 0 end) as CPY_CNT
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE date(creation_time)= CURRENT_DATE()

Prezzi

Il caricamento dei dati in batch in BigQuery utilizzando il pool di slot condivisi non prevede costi. Per saperne di più, consulta Prezzi dell'importazione dati di BigQuery.

Se tenti di caricare dati da un bucket Cloud Storage che si trova in una località diversa rispetto al set di dati BigQuery di destinazione, vengono applicati addebiti per il trasferimento di dati.

Caso d'uso di esempio

Supponiamo che esista una pipeline di elaborazione batch notturna che deve essere completata entro una scadenza fissa. I dati devono essere disponibili entro questa scadenza per un'ulteriore elaborazione batch da parte di un altro processo batch per generare report da inviare a un'autorità di regolamentazione. Questo caso d'uso è comune nei settori regolamentati come quello finanziario.

Il caricamento in batch dei dati con job di caricamento è l'approccio giusto per questo caso d'uso, perché la latenza non è un problema, a condizione che la scadenza possa essere rispettata. Assicurati che i bucket Cloud Storage soddisfino i requisiti per le località per il caricamento dei dati nel set di dati BigQuery.

Il risultato di un job di caricamento BigQuery è atomico: vengono inseriti tutti i record o nessuno. Come best practice, quando inserisci tutti i dati in un singolo job di caricamento, crea una nuova tabella utilizzando la disposizione WRITE_TRUNCATE della risorsa JobConfigurationLoad. Questo è importante quando si riprova un job di caricamento non riuscito, poiché il client potrebbe non essere in grado di distinguere tra i job non riusciti e l'errore causato, ad esempio, dalla comunicazione dello stato di esito positivo al client.

Supponendo che i dati da importare siano già stati copiati correttamente in Cloud Storage, per risolvere gli errori di importazione è sufficiente riprovare con il backoff esponenziale.

È consigliabile che un job batch notturno non raggiunga la quota predefinita di 1500 caricamenti per tabella al giorno,anche con i nuovi tentativi. Quando carichi i dati in modo incrementale, la quota predefinita è sufficiente per eseguire un job di caricamento ogni 5 minuti e avere una quota non utilizzata per almeno un nuovo tentativo per job in media.