Caricamento dei dati Parquet da Cloud Storage

Questa pagina fornisce una panoramica del caricamento dei dati Parquet da Cloud Storage in BigQuery.

Parquet è un formato di dati open source orientato alle colonne ampiamente utilizzato nell'ecosistema Apache Hadoop.

Quando carichi dati Parquet da Cloud Storage, puoi caricarli in un nuova tabella o partizione oppure puoi aggiungere o sovrascrivere una tabella o della partizione di testo. Quando i dati vengono caricati in BigQuery, convertito in formato a colonne per Condensatore (formato di archiviazione di BigQuery).

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

Per informazioni sul caricamento dei dati Parquet da un file locale, vedi Caricamento di dati da file locali.

Limitazioni

Quando carichi i dati in BigQuery da un bucket di Cloud Storage, devi rispettare le seguenti limitazioni:

  • Se la posizione del set di dati è impostata su un valore diverso dall'area geografica multipla US, il bucket Cloud Storage deve trovarsi nella stessa regione o essere contenuto nella stessa area geografica multipla 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 un comportamento imprevisto.

  • BigQuery non supporta il controllo delle versioni degli oggetti Cloud Storage. Se includi un numero di generazione nell'URI di Cloud Storage, il job di caricamento non riesce.

  • Il caricamento dei dati Parquet segue convenzione di denominazione delle colonne e non Supportare nomi di colonna flessibili per impostazione predefinita. Per iscriverti a questa anteprima, completa il modulo di registrazione.

  • Non puoi utilizzare un carattere jolly nell'URI di Cloud Storage se uno dei file da caricare hanno schemi diversi. Qualsiasi differenza nella posizione le colonne vengono considerate uno schema diverso.

Requisiti dei file di input

Per evitare errori resourcesExceeded durante il caricamento dei file Parquet in BigQuery, segui queste linee guida:

  • Mantieni le dimensioni delle righe fino a 50 MB o inferiori.
  • Se i dati di input contengono più di 100 colonne, valuta la possibilità di ridurre il numero di pagine inferiore a quello predefinito della pagina (1 * 1024 * 1024 byte). Questo è particolarmente utile se utilizzi una compressione significativa.

Prima di iniziare

Concedi i ruoli IAM (Identity and Access Management) che forniscono agli utenti le autorizzazioni necessarie per eseguire ogni attività in questo documento e crea un set di dati 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 dati in BigQuery

Per caricare dati in una nuova tabella o partizione BigQuery o per accodare o sovrascrivere una tabella o partizione esistente, sono necessarie le 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 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 Amministratore archiviazione (roles/storage.admin) nel bucket. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

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

Autorizzazioni obbligatorie

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

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

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

Crea un set di dati

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

Schemi Parquet

Quando carichi i file Parquet in BigQuery, lo schema della tabella viene recuperato automaticamente dai dati di origine autodescrittivi. Quando BigQuery recupera lo schema dai dati di origine, viene utilizzato l'ultimo file in ordine alfabetico.

Ad esempio, in Cloud Storage sono presenti i seguenti file Parquet:

gs://mybucket/00/
  a.parquet
  z.parquet
gs://mybucket/01/
  b.parquet

L'esecuzione di questo comando nello strumento a riga di comando bq carica tutti i file (come elenco separato da virgole) e lo schema deriva da mybucket/01/b.parquet:

bq load \
--source_format=PARQUET \
dataset.table \
"gs://mybucket/00/*.parquet","gs://mybucket/01/*.parquet"

Quando carichi più file Parquet con schemi diversi, Le colonne specificate in più schemi devono avere la stessa modalità in ogni definizione dello schema.

Quando BigQuery rileva lo schema, alcuni tipi di dati Parquet vengono convertiti in tipi di dati BigQuery per renderli compatibili con la sintassi di GoogleSQL. Per ulteriori informazioni, vedi Conversioni di Parquet.

Per fornire uno schema di tabella per la creazione di tabelle esterne, imposta la proprietà referenceFileSchemaUri nell'API BigQuery o il parametro
--reference_file_schema_uri nello strumento a riga di comando bq sull'URL del file di riferimento.

Ad esempio, --reference_file_schema_uri="gs://mybucket/schema.parquet".

Compressione Parquet

BigQuery supporta i seguenti codec di compressione per i contenuti dei file Parquet:

  • GZip
  • LZO_1C
  • LZO_1X
  • LZ4_RAW
  • Snappy
  • ZSTD

Caricamento di dati Parquet in una nuova tabella

Puoi caricare i dati Parquet in una nuova tabella in uno dei seguenti modi:

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

Caricare dati Parquet da Cloud Storage in un nuovo BigQuery tabella:

Console

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

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
  3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
  4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
    1. Nella sezione Origine, seleziona Google Cloud Storage nell'elenco Crea tabella da. Poi:
      1. Seleziona un file dal bucket Cloud Storage o inserisci URI Cloud Storage. Non puoi includere più URI nella console Google Cloud, ma con i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nella stessa posizione del set di dati contenente la tabella che vuoi creare, aggiungere o sovrascrivere. seleziona il file di origine per creare una tabella BigQuery
      2. In Formato file, seleziona Parquet.
    2. Nella sezione Destinazione, specifica i seguenti dettagli:
      1. In Set di dati, seleziona il set di dati in cui creare il tabella.
      2. Nel campo 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 non è necessaria alcuna azione. Lo schema è che si autodefinisce nei file Parquet.
    4. (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, consulta Creare tabelle partizionate e Creare e utilizzare tabelle in cluster.
    5. Fai clic su Opzioni avanzate e segui questi passaggi:
      • Per Preferenza di scrittura, lascia selezionata l'opzione Scrivere se vuota. Questo crea una nuova tabella e carica i dati al suo interno.
      • Se vuoi ignorare i valori di una riga che non sono presenti nello schema della tabella, seleziona Valori sconosciuti.
      • In Crittografia, fai clic su Chiave gestita dal cliente per utilizzare una Chiave Cloud Key Management Service. Se lasci l'impostazione Chiave gestita da Google, BigQuery cripta i dati at-rest.
    6. Fai clic su Crea tabella.

SQL

Utilizza la LOAD DATA Istruzione DDL. L'esempio seguente carica un file Parquet nella nuova tabella mytable:

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

    Vai a BigQuery

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

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

  3. Fai clic su Esegui.

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

bq

Utilizza il comando bq load, specifica PARQUET 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.

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

Altri flag facoltativi includono:

  • --time_partitioning_type: attiva il partizionamento in base al tempo in una tabella e imposta il tipo di partizione. I valori possibili sono HOUR, DAY, MONTH e YEAR. Questo flag è facoltativo quando crei una tabella partizionata in base a una colonna DATE, DATETIME o TIMESTAMP. La il tipo di partizione predefinito per il partizionamento basato sul tempo è DAY. Non puoi modificare la specifica di partizione di una tabella esistente.
  • --time_partitioning_expiration: un numero intero che specifica (in secondi) quando deve essere eliminata una partizione basata sul tempo. Data e ora di scadenza restituisce la data UTC della partizione più il valore intero.
  • --time_partitioning_field: la colonna DATE o TIMESTAMP utilizzata per una tabella partizionata. Se il partizionamento basato sul tempo è abilitato senza viene creata una tabella partizionata per data di importazione.
  • --require_partition_filter: se abilitata, questa opzione richiede agli utenti di includere una clausola WHERE che specifichi le partizioni su cui eseguire query. Se il filtro di partizionamento è obbligatorio, i costi possono essere ridotti e le prestazioni migliorate. Per ulteriori informazioni, vedi Esecuzione di query su tabelle partizionate.
  • --clustering_fields: un elenco separato da virgole di massimo quattro nomi di colonna utilizzati per creare una tabella raggruppata.
  • --destination_kms_key: la chiave Cloud KMS per la crittografia dei file e i dati della tabella.

  • --column_name_character_map: definisce l'ambito e la gestione dei caratteri nei nomi delle colonne, con la possibilità di attivare i nomi delle colonne flessibili. Per ulteriori informazioni, vedi load_option_list

    Per saperne di più sulle tabelle partizionate, consulta:

    Per ulteriori informazioni sulle tabelle cluster, consulta:

    Per ulteriori informazioni sulla crittografia delle tabelle, consulta:

Per caricare i dati Parquet in BigQuery, inserisci il comando seguente:

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

Sostituisci quanto segue:

  • LOCATION: la tua posizione. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la posizione utilizzando il file .bigqueryrc.
  • FORMAT: PARQUET.
  • DATASET: un set di dati esistente.
  • TABLE: il nome della tabella in cui ti trovi caricare i dati.
  • PATH_TO_SOURCE: un URI Cloud Storage completo o un elenco di URI separati da virgole. Sono supportati anche i caratteri jolly.

Esempi:

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

    bq load \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

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

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

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

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

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'espressione caratteri jolly.

    bq load \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata*.parquet

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

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

API

  1. Crea un job load che indichi i dati di origine in Cloud Storage.

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

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

  4. Specifica il formato dei dati Parquet impostando la proprietà sourceFormat su PARQUET.

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

    • Se status.state = DONE, il job è stato completato correttamente.
    • Se la proprietà status.errorResult è presente, la richiesta non è riuscita e l'oggetto include informazioni che descrivono il problema. 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 essere stati rilevati alcuni errori non fatali, ad esempio problemi di 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 riesce, nessuno dei dati e, se un job di caricamento ha esito positivo, saranno disponibili tutti i dati.

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

  • La chiamata a 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.

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client. 

import (
	"context"
	"fmt"

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

// importParquet demonstrates loading Apache Parquet data from Cloud Storage into a table.
func importParquet(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.parquet")
	gcsRef.SourceFormat = bigquery.Parquet
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)

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

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le 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. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;
import java.math.BigInteger;

public class LoadParquet {

  public static void runLoadParquet() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    loadParquet(datasetName);
  }

  public static void loadParquet(String datasetName) {
    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();

      String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.parquet";
      TableId tableId = TableId.of(datasetName, "us_states");

      LoadJobConfiguration configuration =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.parquet())
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      // Load the table
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to load the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }

      // Check number of rows loaded into the table
      BigInteger numRows = bigquery.getTable(tableId).getNumRows();
      System.out.printf("Loaded %d rows. \n", numRows);

      System.out.println("GCS parquet loaded successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("GCS Parquet was not loaded. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client. 

// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the Parquet file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.parquet
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.parquet';

async function loadTableGCSParquet() {
  // Imports a GCS file into a table with Parquet source format.

  /**
   * 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: 'PARQUET',
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);

  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

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

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client. 

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

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

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

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

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

Utilizza la Client.load_table_from_uri() per avviare un job di caricamento da Cloud Storage. Per usare Parquet, imposta il campo LoadJobConfig.source_format proprietà alla stringa PARQUET e passa la configurazione del job come job_config al metodo load_table_from_uri(). 
from google.cloud import bigquery

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

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

job_config = bigquery.LoadJobConfig(
    source_format=bigquery.SourceFormat.PARQUET,
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.parquet"

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

Aggiunta o sovrascrittura di una tabella con dati Parquet

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

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

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

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

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

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

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

Per accodare o sovrascrivere una tabella con dati Parquet:

Console

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

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
  3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
  4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
    1. Nella sezione Origine, seleziona Google Cloud Storage nell'elenco Crea tabella da. Poi:
      1. Seleziona un file dal bucket Cloud Storage o inserisci l'URI Cloud Storage. Non puoi includere più URI nella console Google Cloud, ma sono supportati i caratteri jolly. Il bucket Cloud Storage deve trovarsi nello stesso posizione come il set di dati che contiene la tabella da creare, aggiungere o sovrascrivere. seleziona il file di origine per creare una tabella BigQuery
      2. In Formato file, seleziona Parquet.
    2. Nella sezione Destinazione, specifica i seguenti dettagli:
      1. In Set di dati, seleziona il set di dati in cui creare il tabella.
      2. Nel campo 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, non è necessaria alcuna azione. Lo schema è autodescritto nei file Parquet.
    4. (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, consulta Creare tabelle partizionate e Creare e utilizzare tabelle in cluster. Non puoi convertire una tabella in una tabella partizionata o raggruppata aggiungendovi elementi o sovrascrivendola. La console Google Cloud non supporta aggiungendo o sovrascrivendo tabelle partizionate o in cluster in un job di caricamento.
    5. Fai clic su Opzioni avanzate e segui questi passaggi:
      • Per Preferenza di scrittura, scegli Aggiungi alla tabella o Sostituisci tabella.
      • Se vuoi ignorare i valori di una riga che non sono presenti nello schema della tabella, seleziona Valori sconosciuti.
      • Per Crittografia, fai clic su Chiave gestita dal cliente per utilizzare una chiave Cloud Key Management Service. Se lasci l'impostazione Chiave gestita da Google, BigQuery cripta i dati at-rest.
    6. Fai clic su Crea tabella.

SQL

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

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

    Vai a BigQuery

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

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

  3. Fai clic su Esegui.

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

bq

Inserisci il comando bq load con il flag --replace per sovrascrivere tabella. Utilizza il flag --noreplace per aggiungere dati alla tabella. Se non viene specificato alcun flag, per impostazione predefinita i dati vengono aggiunti alla fine. Fornisci il flag --source_format e impostalo su PARQUET. Perché gli schemi Parquet vengono recuperati automaticamente dai dati di origine autodescrittivi, non è necessario fornire uno schema definizione di Kubernetes.

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

Altri flag facoltativi sono:

  • --destination_kms_key: la chiave Cloud KMS per la crittografia dei dati della tabella.
bq --location=LOCATION load \
--[no]replace \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE

Sostituisci quanto segue:

  • location: la tua posizione. Il flag --location è facoltativo. Puoi impostare un valore predefinito per posizione utilizzando file.bigqueryrc.
  • format: PARQUET.
  • 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.

Esempi:

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

    bq load \
    --replace \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

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

    bq load \
    --noreplace \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

Per informazioni su come accodare e sovrascrivere le tabelle partizionate utilizzando lo strumento a riga di comando bq, consulta Aggiunta e sovrascrittura dei dati delle tabelle partizionate.

API

  1. Crea un job load che indichi i dati di origine in Cloud Storage.

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

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

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

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

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

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

import (
	"context"
	"fmt"

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

// importParquetTruncate demonstrates loading Apache Parquet data from Cloud Storage into a table
// and overwriting/truncating existing data in the table.
func importParquetTruncate(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.parquet")
	gcsRef.SourceFormat = bigquery.Parquet
	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

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client. 


import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;
import java.math.BigInteger;

public class LoadParquetReplaceTable {

  public static void runLoadParquetReplaceTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    loadParquetReplaceTable(datasetName);
  }

  public static void loadParquetReplaceTable(String datasetName) {
    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();

      // Imports a GCS file into a table and overwrites table data if table already exists.
      // This sample loads CSV file at:
      // https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
      String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.parquet";
      TableId tableId = TableId.of(datasetName, "us_states");

      // For more information on LoadJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/LoadJobConfiguration.Builder.html
      LoadJobConfiguration configuration =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.parquet())
              // Set the write disposition to overwrite existing table data.
              .setWriteDisposition(WriteDisposition.WRITE_TRUNCATE)
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      // Load the table
      Job job = bigquery.create(JobInfo.of(configuration));

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to load into the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }

      // Check number of rows loaded into the table
      BigInteger numRows = bigquery.getTable(tableId).getNumRows();
      System.out.printf("Loaded %d rows. \n", numRows);

      System.out.println("GCS parquet overwrote existing table successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

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

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client. 

// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.parquet';

async function loadParquetFromGCSTruncate() {
  /**
   * 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: 'PARQUET',
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

Prima di provare questo esempio, segui le istruzioni di configurazione PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client. 

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

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

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

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.parquet';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('PARQUET')->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

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.

Per sostituire le righe in una tabella esistente, imposta LoadJobConfig.write_disposition proprietà al 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.PARQUET,
)

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

Caricamento dei dati Parquet partizionati in hive

BigQuery supporta il caricamento dei dati Parquet partizionati Hive archiviati su Cloud Storage e compila le colonne di partizione Hive come colonne nella tabella gestita BigQuery di destinazione. Per ulteriori informazioni, vedi Caricamento di dati partizionati esternamente.

Conversioni Parquet

Questa sezione descrive in che modo BigQuery analizza vari tipi di dati durante il caricamento dei dati Parquet.

Alcuni tipi di dati Parquet (ad esempio INT32, INT64, BYTE_ARRAY e FIXED_LEN_BYTE_ARRAY) possono essere convertiti in più tipi di dati BigQuery. Per assicurarti che BigQuery converta correttamente i tipi di dati Parquet, specifica il tipo di dati appropriato nel file Parquet.

Ad esempio, per convertire il tipo di dati Parquet INT32 nel tipo di dati BigQuery DATE, specifica quanto segue:

optional int32 date_col (DATE);

BigQuery converte i tipi di dati Parquet nel Tipi di dati di BigQuery descritti nelle sezioni seguenti.

Conversioni di tipo

Tipo di parquet Tipi logici del Parquet Tipo di dati BigQuery
BOOLEAN Nessuno BOOLEANO
INT32 Nessuno, INTEGER (UINT_8, UINT_16, UINT_32, INT_8, INT_16, INT_32) INT64
INT32 DECIMALE NUMERIC, BIGNUMERIC o STRING
INT32 DATE DATA
INT64 Nessuno, INTEGER (UINT_64, INT_64) INT64
INT64 DECIMALE NUMERIC, BIGNUMERIC o STRING
INT64 TIMESTAMP, precision=MILLIS (TIMESTAMP_MILLIS) TIMESTAMP
INT64 TIMESTAMP e precision=MICROS (TIMESTAMP_MICROS) TIMESTAMP
INT96 Nessuno TIMESTAMP
FLOAT Nessuno FLOAT64
DOUBLE Nessuno FLOAT64
BYTE_ARRAY Nessuno BYTES
BYTE_ARRAY STRING (UTF8) STRING
FIXED_LEN_BYTE_ARRAY DECIMALE NUMERIC, BIGNUMERIC o STRING
FIXED_LEN_BYTE_ARRAY Nessuno BYTES

I gruppi nidificati vengono convertiti in STRUCT. Non sono supportate altre combinazioni di tipi Parquet e tipi convertiti.

Tipi logici non firmati

I tipi UINT_8, UINT_16, UINT_32 e UINT_64 di Parquet non sono firmati. BigQuery tratterà i valori con questi tipi come non firmati durante il caricamento in una colonna INTEGER firmata di BigQuery. Nel caso di UINT_64, verrà restituito un errore se il valore senza segno supera il valore massimo di INTEGER pari a 9.223.372.036.854.775.807.

Tipo logico decimale

I tipi logici Decimal possono essere convertiti in tipi NUMERIC, BIGNUMERIC o STRING. Il tipo convertito dipende dai parametri di precisione e scala del tipo logico decimal e dai tipi di target decimali specificati. Specifica il tipo di target decimale come segue:

Tipo logico di enum

I tipi logici Enum possono essere convertiti in STRING o BYTES. Specifica il tipo di target convertito come segue:

Elenca tipo logico

Puoi attivare l'inferenza dello schema per i tipi logici LIST di Parquet. BigQuery verifica se il nodo LIST si trova formato standard o in uno dei formati descritti dalle regole di compatibilità con le versioni precedenti:

// standard form
<optional | required> group <name> (LIST) {
  repeated group list {
    <optional | required> <element-type> element;
  }
}

In questo caso, il campo corrispondente per il nodo LIST nello schema convertito viene trattato come se il nodo avesse lo schema seguente:

repeated <element-type> <name>

L'elenco dei nodi e "elemento" vengono omessi.

Dati geospaziali

Puoi caricare file parquet contenenti WKT, WKB con codifica esadecimale o GeoJSON in una colonna STRING o WKB in una colonna BYTE_ARRAY specificando uno schema BigQuery con il tipo GEOGRAPHY. Consulta Caricare i dati geospaziali.

Conversioni dei nomi di colonna

Il nome di una colonna può contenere lettere (a-z, A-Z), numeri (0-9) o trattini bassi (_) e deve iniziare con una lettera o un trattino basso. Se utilizzi la colonna flessibile , BigQuery supporta l'inizio del nome della colonna con un numero. Fai attenzione quando inizi le colonne con un numero, poiché l'utilizzo di nomi di colonne flessibili con l'API BigQuery Storage di lettura o con l'API BigQuery Storage Write richiede una gestione speciale. Per ulteriori informazioni supporto flessibile per nomi di colonna, consulta nomi delle colonne flessibili.

I nomi delle colonne hanno una lunghezza massima di 300 caratteri. I nomi delle colonne non possono contenere nessuno dei seguenti prefissi:

  • _TABLE_
  • _FILE_
  • _PARTITION
  • _ROW_TIMESTAMP
  • __ROOT__
  • _COLIDENTIFIER

Non sono consentiti nomi di colonna duplicati, anche se le lettere maiuscole e minuscole sono diverse. Ad esempio, un una colonna denominata Column1 è considerata identica a una colonna denominata column1. Per scoprire di più sulle regole di denominazione delle colonne, consulta Nomi colonna nella documentazione di GoogleSQL.

Se il nome di una tabella (ad esempio test) corrisponde al nome di una delle sue colonne (ad esempio, test), l'espressione SELECT interpreta la colonna test come un STRUCT contenente tutte le altre colonne della tabella. Per evitare questa collisione, utilizza uno dei seguenti metodi:

  • Evita di utilizzare lo stesso nome per una tabella e le sue colonne.

  • Assegna alla tabella un alias diverso. Ad esempio, la seguente query assegna un alias di tabella t per la tabella project1.dataset.test:

    SELECT test FROM project1.dataset.test AS t;

  • Includi il nome della tabella quando fai riferimento a una colonna. Ad esempio:

    SELECT test.test FROM project1.dataset.test;

Nomi di colonne flessibili

Hai maggiore flessibilità nel assegnare un nome alle colonne, incluso l'accesso esteso ai caratteri in lingue diverse dall'inglese nonché a simboli aggiuntivi.

I nomi di colonna flessibili supportano i seguenti caratteri:

  • Qualsiasi lettera in qualsiasi lingua, come rappresentata dall'espressione regolare Unicode \p{L}.
  • Qualsiasi carattere numerico in qualsiasi lingua, come rappresentato dall'espressione regolare Unicode \p{N}.
  • Qualsiasi carattere di punteggiatura del connettore, inclusi i trattini bassi, così come rappresentato dall'espressione regolare Unicode \p{Pc}
  • Un trattino o un trattino come rappresentato dall'espressione regolare Unicode. \p{Pd}
  • Qualsiasi marchio destinato ad accompagnare un altro carattere, come rappresentato dal Espressione regolare Unicode \p{M} Ad esempio, accenti, dieresi o contenuti che includono riquadri.
  • I seguenti caratteri speciali:
    • Una e commerciale (&) rappresentata dall'espressione regolare Unicode \u0026.
    • Un segno di percentuale (%) come rappresentato dall'espressione regolare Unicode \u0025.
    • Un segno di uguale (=) come rappresentato dalla regola Unicode dell'espressione \u003D.
    • Un segno più (+) rappresentato dalla regola Unicode dell'espressione \u002B.
    • Un due punti (:) come rappresentato dall'espressione regolare Unicode \u003A.
    • Un apostrofo (') come rappresentato dalla regola Unicode dell'espressione \u0027.
    • Un segno di minore (<) rappresentato dall'espressione regolare Unicode \u003C.
    • Un segno di maggiore (>) come rappresentato dall'espressione regolare Unicode \u003E.
    • Un segno numerico (#) come rappresentato dalla regola Unicode dell'espressione \u0023.
    • Una linea verticale (|) rappresentata dalla barra Unicode regolare dell'espressione \u007c.
    • Spazio vuoto.

I nomi delle colonne flessibili non supportano i seguenti caratteri speciali:

  • Un punto esclamativo (!) rappresentato dall'espressione regolare Unicode \u0021.
  • Una virgola (") rappresentata dall'espressione regolare Unicode \u0022.
  • Un simbolo del dollaro ($) rappresentato dall'espressione regolare Unicode \u0024.
  • Una parentesi aperta (() rappresentata dall'espressione regolare Unicode \u0028.
  • Una parentesi destra ()) rappresentata dall'espressione regolare Unicode \u0029.
  • Un asterisco (*) come rappresentato dall'espressione regolare Unicode \u002A.
  • Una virgola (,) come rappresentata dal valore regolare Unicode dell'espressione \u002C.
  • Un punto (.) come rappresentato dalla regola Unicode dell'espressione \u002E.
  • Una barra (/) rappresentata dalla barra Unicode regolare dell'espressione \u002F.
  • Un punto e virgola (;) rappresentato dall'espressione regolare Unicode \u003B.
  • Un punto interrogativo (?) come rappresentato dalla regola Unicode dell'espressione \u003F.
  • Una chiocciola (@) come rappresentata dalla forma regolare Unicode dell'espressione \u0040.
  • Una parentesi quadra aperta ([) rappresentata dalla barra Unicode regolare dell'espressione \u005B.
  • Una barra (\) rappresentata dall'espressione regolare Unicode \u005C.
  • Una parentesi quadra chiusa (]) come rappresentata dalla regolare Unicode dell'espressione \u005D.
  • Un accento circonflesso (^) come rappresentato dall'espressione regolare Unicode \u005E.
  • Un accento grave (`) come rappresentato dall'espressione regolare Unicode \u0060.
  • Una parentesi graffa aperta {{) rappresentata dall'espressione regolare Unicode \u007B.
  • Una parentesi graffa chiusa (}) rappresentata dalla regola Unicode dell'espressione \u007D.
  • Una tilde (~) rappresentata dall'espressione regolare Unicode \u007E.

Per ulteriori linee guida, vedi Nomi delle colonne.

I caratteri delle colonne espansi sono supportati sia dall'API BigQuery Storage Read sia dall'API BigQuery Storage Write. Per utilizzare l'elenco espanso di caratteri Unicode con l'API BigQuery Storage Read, devi impostare un flag. Puoi utilizzare l'attributo displayName per recuperare il nome della colonna. L'esempio seguente illustra come impostare un flag con il client Python:

from google.cloud.bigquery_storage import types
requested_session = types.ReadSession()

#set avro serialization options for flexible column.
options = types.AvroSerializationOptions()
options.enable_display_name_attribute = True
requested_session.read_options.avro_serialization_options = options

Per usare l'elenco espanso di caratteri Unicode con l'API BigQuery StorageWrite, devi fornire lo schema con la notazione column_name, a meno che non utilizzi l'oggetto writer JsonStreamWriter. L'esempio seguente mostra come indica lo schema:

syntax = "proto2";
package mypackage;
// Source protos located in github.com/googleapis/googleapis
import "google/cloud/bigquery/storage/v1/annotations.proto";

message FlexibleSchema {
  optional string item_name_column = 1
  [(.google.cloud.bigquery.storage.v1.column_name) = "name-列"];
  optional string item_description_column = 2
  [(.google.cloud.bigquery.storage.v1.column_name) = "description-列"];
}

In questo esempio, item_name_column e item_description_column sono nomi segnaposto che devono essere conformi alla convenzione di denominazione del buffer del protocollo. Tieni presente che le annotazioni column_name hanno sempre la precedenza sui nomi dei segnaposto.

Limitazioni

I nomi di colonna flessibili non sono supportati con tabelle esterne.

Non puoi caricare file Parquet contenenti colonne con un punto (.) nel nome della colonna.

Se il nome di una colonna Parquet contiene altri caratteri (a parte un punto), questi caratteri vengono sostituiti con trattini bassi. Puoi aggiungere trattini bassi finali ai nomi delle colonne per evitare conflitti. Ad esempio, se un file Parquet contiene 2 colonne Column1 e column1, le colonne vengono caricate come Column1 e rispettivamente column1_.

Eseguire il debug del file Parquet

Se i job di caricamento non riescono a causa di errori nei dati, puoi utilizzare PyArrow per verificare se i file di dati Parquet sono danneggiati. Se PyArrow non riesce a leggere i file, questi ultimi verranno probabilmente rifiutati dal job di caricamento BigQuery. L'esempio riportato di seguito mostra come leggere i contenuti di un file Parquet utilizzando PyArrow:

from pyarrow import parquet as pq

# Read the entire file
pq.read_table('your_sample_file.parquet')
# Read specific columns
pq.read_table('your_sample_file.parquet',columns=['some_column', 'another_column'])
# Read the metadata of specific columns
file_metadata=pq.read_metadata('your_sample_file.parquet')
for col in file_metadata.row_group(0).to_dict()['columns']:
    print col['column_path_in_schema']
    print col['num_values']

Per ulteriori informazioni, consulta la documentazione di PyArrow.