Caricamento di dati in batch

Puoi caricare i dati in BigQuery da Cloud Storage o da un come operazione batch. I dati di origine possono essere in uno dei seguenti formati: formati:

  • Avro
  • Valori separati da virgola (CSV)
  • JSON (delimitato da nuova riga)
  • ORC
  • Parquet
  • Esportazioni di Datastore archiviate in Cloud Storage
  • Esportazioni Firestore archiviate in Cloud Storage

Puoi anche utilizzare BigQuery Data Transfer Service per impostare carichi ricorrenti da Cloud Storage a BigQuery.

Provalo

Se non hai mai utilizzato Google Cloud, crea un account per valutare in che modo BigQuery funziona nel mondo reale diversi scenari. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova BigQuery gratuitamente

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 e 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 uno qualsiasi dei seguenti Classi di archiviazione di Cloud Storage:

  • Standard
  • Nearline
  • Coldline
  • Archivia

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

Per scoprire come configurare un carico ricorrente da Cloud Storage a per BigQuery, consulta Trasferimenti dei rapporti di Cloud Storage.

Considerazioni sulla località

Quando carichi dati da Cloud Storage utilizzando una tabella esterna BigLake o non BigLake, i dati caricati devono essere collocati con il set di dati BigQuery.

  • Puoi caricare i dati da un bucket Cloud Storage situato in qualsiasi località se il tuo set di dati BigQuery si trova nell'area multiregionale US.

  • Bucket multiregionale: se Il bucket Cloud Storage da cui vuoi eseguire il caricamento si trova in un bucket multiregionale, Il set di dati BigQuery può trovarsi nello stesso bucket multiregionale o in una singola regione inclusa nello stesso bucket multiregionale. Ad esempio, se il bucket Cloud Storage si trova nella regione EU, il tuo set di dati BigQuery può trovarsi nella regione EU più regioni o una singola regione nel EU.

  • Bucket a due regioni: se Il bucket Cloud Storage da cui vuoi eseguire il caricamento si trova in un bucket a due regioni, Il set di dati BigQuery può trovarsi in regioni incluse nel bucket a due regioni, o in una località multiregionale che include due regioni. Ad esempio, se il tuo Cloud Storage Il bucket si trova nella regione EUR4, il set di dati BigQuery può trovarsi in Finlandia (europe-north1) regione singola, Paesi Bassi (europe-west4) una singola regione o EU.

    Per ulteriori informazioni, vedi Crea un bucket a due regioni.

  • Bucket a regione singola: se il tuo Il bucket Cloud Storage da cui vuoi eseguire il caricamento si trova in una singola regione, Il set di dati BigQuery può trovarsi nella stessa regione o in più regioni include la regione singola. Ad esempio, se il bucket Cloud Storage si trova in Finlandia, (europe-north1), il set di dati BigQuery può trovarsi in Finlandia o EU.

  • Un'eccezione è che se il set di dati BigQuery si trova nella regione asia-northeast1, allora il bucket Cloud Storage può trovarsi nella località multiregionale EU.

Per ulteriori informazioni sulle località di Cloud Storage, vedi Località dei bucket nella documentazione di Cloud Storage.

Non puoi modificare la località di un set di dati dopo averlo creato, ma puoi creare una copia del set di dati o spostarlo manualmente. Per ulteriori informazioni, vedi:

Recupero dell'URI Cloud Storage in corso...

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

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

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

Per recuperare il percorso della risorsa di Cloud Storage:

  1. Apri la console di Cloud Storage.

    Console Cloud Storage

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

  3. Fai clic sul nome dell'oggetto.

    Si apre 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 separati in più file, puoi utilizzare un asterisco (*) carattere jolly per selezionare più file. L'utilizzo del carattere jolly asterisco deve seguire queste regole:

  • L'asterisco può essere visualizzato all'interno del nome dell'oggetto o alla fine dell'oggetto .
  • L'uso 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 file con estensione .csv nella cartella denominata fed-samples e in eventuali sottocartelle di fed-samples:

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

  • L'esempio seguente mostra come selezionare file con un modello di denominazione 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 usi lo strumento a riga di comando bq, potresti dover inserire il carattere di escape in alcune piattaforme di terze parti.

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

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.

A seconda del formato dei dati di origine Cloud Storage, potrebbero essere limitazioni aggiuntive. Per ulteriori informazioni, vedi:

Caricamento di dati da file locali

Puoi caricare i dati da un'origine dati leggibile (ad esempio il tuo computer locale) utilizzando uno dei seguenti metodi:

  • Nella console Google Cloud
  • Il comando bq load dello strumento a riga di comando bq
  • L'API
  • Le librerie client

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

Per caricare i dati da un'origine dati locale:

Console

  1. Apri la pagina BigQuery nella console Google Cloud.

    Vai alla pagina di BigQuery

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

  3. Espandi Azioni e fai clic su Apri.

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

  5. Nella sezione Origine della pagina Crea tabella:

    • Per Crea tabella da, seleziona Carica.
    • In Seleziona file, fai clic su Sfoglia.
    • Individua il file e fai clic su Apri. I caratteri jolly mentre 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 sezione Destinazione della pagina Crea tabella:

    • 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 e la creazione in BigQuery.
    • Verifica che l'opzione Tipo di tabella sia impostata su Tabella nativa.

  7. Nella sezione Schema, inserisci lo schema. definizione di Kubernetes.

    • Per i file CSV e JSON, puoi selezionare l'opzione Rilevamento automatico per abilita il rilevamento automatico dello schema. Schema autodescritte nei dati di origine per altre informazioni tipi di file.

    • Puoi anche inserire le informazioni sullo schema manualmente:

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

      • Utilizza 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 le opzioni JSON.

  9. (Facoltativo) In Opzioni avanzate, scegli l'impostazione di scrittura:

    • Scrivi se vuoto: scrivi i dati solo se la tabella è vuota.
    • Aggiungi alla tabella: aggiungi i dati alla fine della tabella. Questo è l'impostazione predefinita.
    • Sovrascrivi tabella: cancella tutti i dati presenti nella tabella prima del giorno scrivere nuovi dati.

  10. Fai clic su Crea tabella.

bq

Usa il comando bq load, specifica il valore source_format e includi il percorso al file locale.

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

Se i dati vengono caricati 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 posizione. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery Regione di Tokyo, imposta il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando 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 ti trovi caricare i dati.
  • path_to_source: il percorso del file locale.
  • 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.

Inoltre, puoi aggiungere flag per opzioni che ti consentono di controllare BigQuery analizza i tuoi dati. Ad esempio, puoi utilizzare --skip_leading_rows per ignorare le righe di intestazione in un file CSV. Per ulteriori informazioni informazioni, vedi Opzioni CSV e le opzioni JSON.

Esempi:

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

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

Il comando seguente carica un file CSV locale (mydata.csv) in una tabella denominato 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 comando seguente carica un file CSV locale (mydata.csv) in una tabella denominato mytable in mydataset nel progetto predefinito. Lo schema è definiti mediante il rilevamento automatico dello schema.

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

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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato, utilizza la classe delle opzioni di aggiornamento per il formato appropriato dal 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 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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato, imposta il DataFormat di NewReaderSource nel 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 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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato, imposta il componente FormatOptions nel 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 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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato: imposta il parametro metadata del carica la funzione nel 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 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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato, imposta sourceFormat nel 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 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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato, imposta il valore LoadJobConfig.source_format proprietà nel 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 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.

Il seguente codice mostra come caricare un file CSV locale in un nuovo Tabella BigQuery. Per caricare un file locale di un altro formato: imposta il parametro format del Tabella#load_job al 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 può superare i 100 MB. Per i file di dimensioni maggiori, carica il file da Cloud Storage.
  • Per impostazione predefinita, i job di caricamento utilizzano un pool di slot condiviso. BigQuery non garantisce la capacità disponibile di questo pool condiviso o la velocità effettiva che vedrai. In alternativa, puoi acquistare slot dedicati per eseguire job di caricamento. Per ulteriori informazioni, consulta la sezione Prezzi dell'importazione dati.

Caricamento di dati compressi e non compressi

Per i formati Avro, Parquet e ORC, BigQuery supporta caricare file in cui i dati sono stati compressi utilizzando 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 file compressi e non compressi. Il caricamento dei dati Avro è più rapido perché è possibile leggerli in parallelo, anche quando i blocchi di dati sono compressi. Per un elenco dei codec di compressione supportati, consulta: Compressione Avro.

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

Il formato binario ORC offre vantaggi simili a quelli del Parquet formato. I dati nei file ORC si caricano rapidamente perché le strisce di dati possono essere letti parallelo. Le righe in ogni stripe di dati vengono caricate in sequenza. ottimizzare il carico utilizzare una dimensione dello stripe 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ò dei file non compressi molto più velocemente dei file compressi poiché i file non compressi possono essere letti in parallelo. Poiché i file non compressi vengono maggiore, il loro utilizzo può portare a limitazioni della larghezza di banda e a una maggiore per i dati in fasi in Cloud Storage prima di essere caricati in BigQuery. Ricorda che l'ordinamento delle righe non è garantito per i file compressi o non compressi. È importante valutare questi aspetti compromessi a seconda del 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 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 disponi 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 della query. Se lo schema dei dati non corrisponde a quello della tabella di destinazione o puoi aggiornare lo schema quando lo aggiungi o lo sovrascrivi.

Se aggiorni lo schema quando aggiungi dati, BigQuery consente per:

  • Aggiungi nuovi campi
  • Rilascia REQUIRED campi a NULLABLE

Se sovrascrivi una tabella, lo schema viene sempre sovrascritto. Aggiornamenti dello schema non sono limitate quando sovrascrivi una tabella.

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. Lo strumento a riga di comando bq e l'API includono le seguenti opzioni:

Opzione della console flag 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; if --replace non è specificato. Il valore predefinito è Aggiungi 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 sui criteri per le quote per il caricamento in batch dei dati, vedi 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 su un specificato per il periodo di tempo. Puoi confrontare il tuo utilizzo attuale con la quota per determinare l'utilizzo della quota per un particolare tipo di job. Le seguenti query di esempio utilizza la vista INFORMATION_SCHEMA.JOBS per elencare il numero esegui query, carica, estrai e copia i job in base al 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-eu`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE date(creation_time)= CURRENT_DATE()

Prezzi

Non è previsto alcun costo per il caricamento in batch di dati in BigQuery. Per ulteriori informazioni, vedi Prezzi di importazione dati di BigQuery.

Caso d'uso di esempio

Supponiamo che ci sia una pipeline di elaborazione batch notturna che deve devono essere completati entro una scadenza fissa. I dati devono essere disponibili entro questa scadenza per un'ulteriore elaborazione da parte di un altro processo batch per generare i report da inviare ente regolatore. Questo caso d'uso è comune in settori regolamentati come la finanza.

Caricamento in batch di dati con job di caricamento è l'approccio giusto per questo caso d'uso, perché la latenza non è un problema a condizione che la scadenza sia rispettata. Assicurati che i tuoi bucket Cloud Storage soddisfare i requisiti per le località per caricare i dati nel set di dati BigQuery.

Il risultato di un job di caricamento BigQuery è atomico, o tutti i record o non farlo. Come best practice, quando inserisci tutti i dati in un singolo un job di caricamento, crea una nuova tabella utilizzando l'istruzione WRITE_TRUNCATE di il JobConfigurationLoad risorsa. Questo è importante quando si ripete un job di caricamento non riuscito, in quanto il client potrebbe non sarà in grado di distinguere tra i job non riusciti e quelli non riusciti causata, ad esempio, dalla comunicazione dello stato di operazione riuscita al client.

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

È consigliabile che un job batch notturno non raggiunga il quota predefinita di 1500 caricamenti per tabella al giorno,anche con nuovi tentativi. Durante il caricamento dei dati in modo incrementale, la quota predefinita è sufficiente per eseguire un job di caricamento ogni 5 minuti e hanno una quota non consumata per almeno 1 nuovo tentativo per job in media.