Caricamento di dati ORC da Cloud Storage

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

ORC è un formato di dati open source orientato a colonne, ampiamente usato in Apache Hadoop all'interno dell'ecosistema Google Cloud.

Quando carichi dati ORC da Cloud Storage, puoi caricarli in un nuovo 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 ORC da un file locale, vedi Caricare dati in BigQuery da un'origine dati locale.

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.

Prima di iniziare

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

Autorizzazioni obbligatorie

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

Autorizzazioni per caricare i dati in BigQuery

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

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

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

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

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

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

Autorizzazioni per caricare i dati da Cloud Storage

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

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

Autorizzazioni obbligatorie

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

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

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

Crea un set di dati

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

Schemi ORC

Quando carichi file ORC in BigQuery, lo schema della tabella viene 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, hai i seguenti file ORC in Cloud Storage:

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

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.orc:

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

Quando BigQuery rileva lo schema, alcuni tipi di dati ORC vengono convertiti in tipi di dati BigQuery per renderli compatibili Sintassi GoogleSQL. Tutti i campi nello schema rilevato sono NULLABLE Per ulteriori informazioni, vedi Conversioni ORC.

Quando carichi più file ORC con schemi diversi, (con lo stesso nome e lo stesso livello nidificato) specificati in più campi gli schemi devono essere mappati allo stesso tipo di dati BigQuery convertito di ogni definizione di schema.

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

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

Compressione ORC

BigQuery supporta i seguenti codec di compressione Contenuto del file ORC:

  • Zlib
  • Snappy
  • LZO
  • LZ4

I dati nei file ORC non rimangono compressi dopo essere stati caricati in BigQuery. L'archiviazione dei dati viene riportata in byte logici o fisici byte, a seconda modello di fatturazione dello spazio di archiviazione del set di dati. Per ottenere informazioni sull'utilizzo dello spazio di archiviazione, esegui una query INFORMATION_SCHEMA.TABLE_STORAGE visualizzazione.

Caricare dati ORC in una nuova tabella

Puoi caricare i dati ORC in una nuova tabella:

  • Utilizzo della console Google Cloud
  • Utilizzo del comando bq load dello strumento a riga di comando bq
  • Chiamata al metodo API jobs.insert e configurazione di un job load
  • Utilizzo delle librerie client

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

Console

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

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
  3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
  4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
    1. Nella sezione Origine, seleziona Google Cloud Storage nell'elenco Crea tabella da. Poi segui questi passaggi:
      1. Seleziona un file dal bucket Cloud Storage o inserisci URI Cloud Storage. Non puoi includere più URI nella console Google Cloud, ma con i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nello stesso posizione come il set di dati che contiene la tabella da creare, aggiungere o sovrascrivere. seleziona il file di origine per creare una tabella BigQuery
      2. In Formato file, seleziona ORC.
    2. Nella sezione Destinazione, specifica i seguenti dettagli:
        .
      1. In Set di dati, seleziona il set di dati in cui creare il tabella.
      2. Nel campo Tabella, inserisci il nome della tabella da creare.
      3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
    3. Nella sezione Schema non è necessaria alcuna azione. Lo schema è autodescritti nei file ORC.
    4. (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, vedi Creazione di tabelle partizionate e Creazione e utilizzo di tabelle in cluster.
    5. Fai clic su Opzioni avanzate ed esegui le seguenti operazioni:
        .
      • In Write preference (Preferenza di scrittura), lascia selezionata l'opzione Write if empty (Scrivi se vuoto). Questo crea una nuova tabella e carica i dati al suo interno.
      • Se vuoi ignorare i valori in una riga che non sono presenti nello schema della tabella: Seleziona Valori sconosciuti.
      • In Crittografia, fai clic su Chiave gestita dal cliente per utilizzare una Chiave Cloud Key Management Service. Se lasci l'impostazione Chiave gestita da Google, BigQuery cripta i dati at-rest.
    6. Fai clic su Crea tabella.

SQL

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

  3. Fai clic su Esegui.

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

bq

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

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

Altri flag facoltativi includono:

  • --time_partitioning_type: abilita il partizionamento in base al tempo in una tabella e imposta il tipo di partizione. I valori possibili sono HOUR, DAY, MONTH e YEAR. Questo flag è facoltativo quando crei partizionata in base a una colonna DATE, DATETIME o TIMESTAMP. La il tipo di partizione predefinito per il partizionamento basato sul tempo è DAY. Non puoi modificare la specifica di partizionamento su una tabella esistente.
  • --time_partitioning_expiration: un numero intero che specifica (in secondi) quando occorre eliminare una partizione temporale. La scadenza valuta con la data UTC della partizione più il valore intero.
  • --time_partitioning_field: la colonna DATE o TIMESTAMP utilizzata per una tabella partizionata. Se il partizionamento basato sul tempo è abilitato senza viene creata una tabella partizionata per data di importazione.
  • --require_partition_filter: quando è abilitata, questa opzione richiede agli utenti per includere una clausola WHERE che specifichi le partizioni su cui eseguire la query. La richiesta di un filtro di partizionamento può ridurre i costi e migliorare le prestazioni. Per ulteriori informazioni, vedi Esecuzione di query su tabelle partizionate.
  • --clustering_fields: un elenco separato da virgole di massimo quattro nomi di colonna utilizzato per creare una tabella in cluster.

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

    Per saperne di più sulle tabelle partizionate, consulta:

    Per ulteriori informazioni sulle tabelle in cluster, consulta:

    Per ulteriori informazioni sulla crittografia delle tabelle, consulta:

Per caricare dati ORC in BigQuery, inserisci il seguente comando:

bq --location=location load \
--source_format=format \
dataset.table \
path_to_source

Dove:

  • location è la tua posizione. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando il valore file.bigqueryrc.
  • format è pari a ORC.
  • dataset è un set di dati esistente.
  • table è il nome della tabella in cui vengono caricati i dati.
  • path_to_source ha ottenuto la qualificazione URI Cloud Storage oppure un elenco di URI separati da virgole. Caratteri jolly sono supportate.

Esempi:

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

    bq load \
    --source_format=ORC \
    mydataset.mytable \
    gs://mybucket/mydata.orc

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

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

Il seguente comando carica i dati da gs://mybucket/mydata.orc in un tabella partizionata denominata mytable in mydataset. La tabella è partizionata nella colonna mytimestamp.

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

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

    bq load \
    --source_format=ORC \
    mydataset.mytable \
    gs://mybucket/mydata*.orc

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

    bq load --autodetect \
    --source_format=ORC \
    mydataset.mytable \
    "gs://mybucket/00/*.orc","gs://mybucket/01/*.orc"

API

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

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

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

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

  5. Per controllare lo stato del lavoro, chiama jobs.get(job_id*), dove job_id è l'ID del job restituito dal richiesta.

    • Se status.state = DONE, il job è stato completato correttamente.
    • Se è presente la proprietà status.errorResult, la richiesta non è riuscita. e include informazioni che descrivono cosa non ha funzionato. Quando una richiesta non va a buon fine, non viene creata alcuna tabella e non vengono caricati dati.
    • Se il campo status.errorResult non è presente, il job è stato completato correttamente. anche se potrebbero essersi verificati alcuni errori non irreversibili, come problemi importando alcune righe. Gli errori non irreversibili sono elencati nel job restituito dell'oggetto status.errors.

Note API:

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

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

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

C#

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

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


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsOrc
{
    public void LoadTableGcsOrc(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.orc";
        var dataset = client.GetDataset(datasetId);
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.Orc
        };
        // Create and run job
        var loadJob = client.CreateLoadJob(
            sourceUri: gcsURI,
            destination: destinationTableRef,
            // Pass null as the schema because the schema is inferred when
            // loading Orc data
            schema: null,
            options: jobOptions
        );
        loadJob = loadJob.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

Vai

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

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

import (
	"context"
	"fmt"

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

// importORCTruncate demonstrates loading Apache ORC data from Cloud Storage into a table.
func importORC(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.orc")
	gcsRef.SourceFormat = bigquery.ORC
	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 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to load ORC data from Cloud Storage into a new BigQuery table
public class LoadOrcFromGCS {

  public static void runLoadOrcFromGCS() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.orc";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadOrcFromGCS(datasetName, tableName, sourceUri, schema);
  }

  public static void loadOrcFromGCS(
      String datasetName, String tableName, String sourceUri, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri, FormatOptions.orc())
              .setSchema(schema)
              .build();

      // Load data from a GCS ORC file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("ORC from GCS successfully added during load append job");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

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

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

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

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

  /**
   * TODO(developer): Uncomment the following line 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: 'ORC',
    location: 'US',
  };

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

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

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

PHP

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

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

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

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

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

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

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

load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

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

destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

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

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

require "google/cloud/bigquery"

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

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

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

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

Aggiunta o sovrascrittura di una tabella con dati ORC

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

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

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

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

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

Puoi aggiungere o sovrascrivere una tabella:

  • Utilizzo della console Google Cloud
  • Utilizzo del comando bq load dello strumento a riga di comando bq
  • Chiamata al metodo API jobs.insert e configurazione di un job load
  • Utilizzo delle librerie client

Per aggiungere o sovrascrivere una tabella con dati ORC:

Console

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

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
  3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
  4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
    1. Nella sezione Origine, seleziona Google Cloud Storage nell'elenco Crea tabella da. Poi segui questi passaggi:
      1. Seleziona un file dal bucket Cloud Storage o inserisci URI Cloud Storage. Non puoi includere più URI nella console Google Cloud, ma con i caratteri jolly sono supportati. Il bucket Cloud Storage deve trovarsi nello stesso posizione come il set di dati che contiene la tabella da creare, aggiungere o sovrascrivere. seleziona il file di origine per creare una tabella BigQuery
      2. In Formato file, seleziona ORC.
    2. Nella sezione Destinazione, specifica i seguenti dettagli:
        .
      1. In Set di dati, seleziona il set di dati in cui creare il tabella.
      2. Nel campo Tabella, inserisci il nome della tabella da creare.
      3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
    3. Nella sezione Schema non è necessaria alcuna azione. Lo schema è autodescritti nei file ORC.
    4. (Facoltativo) Specifica le impostazioni di partizione e clustering. Per ulteriori informazioni, vedi Creazione di tabelle partizionate e Creazione e utilizzo di tabelle in cluster. Tu impossibile convertire una tabella in una tabella partizionata o in cluster aggiungendo o sovrascriverlo. La console Google Cloud non supporta aggiungendo o sovrascrivendo tabelle partizionate o in cluster in un job di caricamento.
    5. Fai clic su Opzioni avanzate ed esegui le seguenti operazioni:
        .
      • In Preferenza di scrittura, scegli Aggiungi alla tabella o Sovrascrivi dalla tabella.
      • Se vuoi ignorare i valori in una riga che non sono presenti nello schema della tabella: Seleziona Valori sconosciuti.
      • In Crittografia, fai clic su Chiave gestita dal cliente per utilizzare una Chiave Cloud Key Management Service. Se lasci l'impostazione Chiave gestita da Google, BigQuery cripta i dati at-rest.
    6. Fai clic su Crea tabella.

SQL

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

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi 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 è presente alcun flag specificato, il valore predefinito è l'aggiunta di dati. Fornisci il flag --source_format e lo imposti su ORC. Perché gli schemi ORC 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 includono:

  • --destination_kms_key: la chiave Cloud KMS per la crittografia dei file e i dati della tabella.
bq --location=location load \
--[no]replace \
--source_format=format \
dataset.table \
path_to_source

Dove:

  • location è la tua località. Il flag --location è facoltativo. Puoi impostare un valore predefinito per posizione utilizzando file.bigqueryrc.
  • format è pari a ORC.
  • dataset è un set di dati esistente.
  • table è il nome della tabella in cui vengono caricati i dati.
  • path_to_source ha ottenuto la qualificazione URI Cloud Storage oppure un elenco di URI separati da virgole. Caratteri jolly sono supportate.

Esempi:

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

    bq load \
    --replace \
    --source_format=ORC \
    mydataset.mytable \
    gs://mybucket/mydata.orc

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

    bq load \
    --noreplace \
    --source_format=ORC \
    mydataset.mytable \
    gs://mybucket/mydata.orc

Per informazioni sull'aggiunta e la sovrascrittura delle tabelle partizionate mediante a riga di comando bq, consulta: Aggiunta e sovrascrittura di tabella partizionata partizionate.

API

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

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

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

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

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

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. 


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsOrcTruncate
{
    public void LoadTableGcsOrcTruncate(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.orc";
        var dataset = client.GetDataset(datasetId);
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.Orc,
            WriteDisposition = WriteDisposition.WriteTruncate
        };
        // Create and run job
        var loadJob = client.CreateLoadJob(
            sourceUri: gcsURI,
            destination: destinationTableRef,
            // Pass null as the schema because the schema is inferred when
            // loading Orc data
            schema: null, options: jobOptions);
        loadJob = loadJob.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

Vai

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

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

import (
	"context"
	"fmt"

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

// importORCTruncate demonstrates loading Apache ORC data from Cloud Storage into a table
// and overwriting/truncating existing data in the table.
func importORCTruncate(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.orc")
	gcsRef.SourceFormat = bigquery.ORC
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	// Default for import jobs is to append data to a table.  WriteTruncate
	// specifies that existing data should instead be replaced/overwritten.
	loader.WriteDisposition = bigquery.WriteTruncate

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

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

Java 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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;

// Sample to overwrite the BigQuery table data by loading a ORC file from GCS
public class LoadOrcFromGcsTruncate {

  public static void runLoadOrcFromGcsTruncate() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.orc";
    loadOrcFromGcsTruncate(datasetName, tableName, sourceUri);
  }

  public static void loadOrcFromGcsTruncate(
      String datasetName, String tableName, String sourceUri) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.orc())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_TRUNCATE)
              .build();

      // Load data from a GCS ORC file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("Table is successfully overwritten by ORC file loaded from GCS");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

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

// Instantiate the 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.orc';

async function loadORCFromGCSTruncate() {
  /**
   * 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: 'ORC',
    // 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 per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

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

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

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

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

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

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.orc"
load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

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

destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

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

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

require "google/cloud/bigquery"

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

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

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

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

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

Carica i dati ORC partizionati in hive

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

Conversioni ORC

BigQuery converte i tipi di dati ORC nei seguenti Tipi di dati BigQuery:

Tipi primitivi

Tipo di dati ORC Tipo di dati BigQuery Note
boolean BOOLEANO
byte INTEGER
corti INTEGER
int INTEGER
Lungo INTEGER
numero in virgola mobile FLOAT
double FLOAT
string STRINGA Solo UTF-8
Varchar STRINGA Solo UTF-8
carattere STRINGA Solo UTF-8
binario BYTES
data DATA Tentativo di conversione di qualsiasi valore nei dati ORC inferiore a -719162 giorni o più di 2932896 giorni restituisce un errore invalid date value. Se ciò ti riguarda, contatta Assistenza per valori non supportati convertiti al valore minimo di BigQuery di 0001-01-01 o del valore massimo di 9999-12-31, in base alle necessità.
timestamp TIMESTAMP

ORC supporta la precisione in nanosecondi, ma BigQuery converte i valori inferiori al microsecondo in microsecondi quando i dati vengono lette.

Tentativo di conversione di qualsiasi valore nei dati ORC inferiore a -719162 giorni o più di 2932896 giorni restituisce un errore invalid date value. Se ciò ti riguarda, contatta Assistenza in modo che i valori non supportati vengano convertiti in valore minimo di 0001-01-01 o valore massimo di 9999-12-31, a seconda dei casi.

decimal NUMERIC, BIGNUMERIC o STRING Vedi Tipo decimale.

Tipo decimale

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

Tipi complessi

Tipo di dati ORC Tipo di dati BigQuery Note
struct RECORD
  • Tutti i campi sono NULLABLE.
  • L'ordine dei campi viene ignorato.
  • Il nome di un campo deve essere una colonna valida di testo.
mappa<K,V> RECORD Una mappa ORC<K,V> viene convertito in un RECORD ripetuto che contiene due campi: una chiave dello stesso tipo di dati del K e un valore dello stesso tipo di dati di V. Entrambi sono NULLABLE.
list campi ripetuti Gli elenchi nidificati e di mappe non sono supportati.
unione RECORD
  • Quando Union ha una sola variante, viene convertita in un valore NULLABLE .
  • In caso contrario, un'unione viene convertita in RECORD con un elenco di NULLABLE campi. I campi NULLABLE hanno suffissi come campo_0, campo_1, e così via. A uno solo di questi campi viene assegnato un valore quando vengono letti correttamente.

Nomi delle colonne

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. Presta attenzione quando inizi colonne con un numero, poiché utilizzi l'impostazione i nomi delle colonne con l'API BigQuery Storage Read o L'API BigQuery StorageWrite richiede una gestione speciale. Per ulteriori informazioni supporto flessibile per nomi di colonna, consulta nomi di colonne flessibili.

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

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

Non sono consentiti nomi di colonna duplicati anche se le differenze sono diverse. Ad esempio, un una colonna denominata Column1 è considerata identica a una colonna denominata column1. A per ulteriori informazioni sulle regole di denominazione delle colonne, consulta Colonna nomi utente nel Riferimento 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 delle 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 delle colonne flessibili supportano i seguenti caratteri:

  • Qualsiasi lettera in qualsiasi lingua, rappresentata dall'espressione regolare Unicode \p{L}
  • Qualsiasi carattere numerico in qualsiasi lingua, come rappresentato dalla regola Unicode espressione \p{N}
  • Qualsiasi carattere di punteggiatura del connettore, inclusi i trattini bassi, 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 dalla regola Unicode dell'espressione \u0026.
    • Un segno di percentuale (%) come rappresentato dalla regola Unicode dell'espressione \u0025.
    • Un segno di uguale (=) come rappresentato dalla regola Unicode dell'espressione \u003D.
    • Un segno più (+) come rappresentato dalla regola Unicode dell'espressione \u002B.
    • I due punti (:) come rappresentati dalla regola Unicode dell'espressione \u003A.
    • Un apostrofo (') come rappresentato dalla regola Unicode dell'espressione \u0027.
    • Un segno di minore (<) rappresentato dalla regola Unicode dell'espressione \u003C.
    • Un segno di maggiore (>) rappresentato dalla regola Unicode dell'espressione \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 (!) come rappresentato dal simbolo Unicode dell'espressione \u0021.
  • Una virgoletta (") rappresentata dalla regola Unicode dell'espressione \u0022.
  • Un simbolo del dollaro ($) come rappresentato dalla regola Unicode dell'espressione \u0024.
  • Una parentesi aperta (() rappresentata dalla regolare Unicode dell'espressione \u0028.
  • Una parentesi chiusa ()) rappresentata dalla regolare Unicode dell'espressione \u0029.
  • Un asterisco (*) come rappresentato dalla regola Unicode dell'espressione \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 (;) come rappresentato dalla regola Unicode dell'espressione \u003B.
  • Un punto interrogativo (?) come rappresentato dalla regola Unicode dell'espressione \u003F.
  • Una chiocciola (@) come rappresentata dalla normale dell'espressione \u0040.
  • Una parentesi quadra aperta ([) rappresentata dalla barra Unicode regolare dell'espressione \u005B.
  • Una barra rovesciata (\) rappresentata dalla barra Unicode regolare dell'espressione \u005C.
  • Una parentesi quadra chiusa (]) rappresentata dalla barra Unicode regolare dell'espressione \u005D.
  • Un accento circonflesso (^) come rappresentato dalla regolare Unicode dell'espressione \u005E.
  • Un accento grave (`) come rappresentato dalla regola Unicode dell'espressione \u0060.
  • Una parentesi graffa aperta {{) rappresentata dalla regola Unicode dell'espressione \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 della colonna espansi sono supportati dall'API BigQuery Storage Read e l'API BigQuery StorageWrite. Per utilizzare l'elenco espanso di caratteri Unicode con l'API BigQuery Storage Read, devi impostare un flag. Puoi utilizzare lo displayName per recuperare il nome della colonna. Nell'esempio che segue mostra 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 alle denominazione del buffer di protocollo convenzione. Tieni presente che le annotazioni column_name hanno sempre la precedenza sulle i nomi dei segnaposto.

  • Il caricamento dei dati Parquet non supporta nomi di colonne flessibili per impostazione predefinita. Per iscriverti a questa anteprima, completa la modulo di registrazione. Tieni presente che dopo la registrazione all'anteprima, eventuali nomi di colonna non validi (ad esempio, le regole di confronto dei nomi di colonna) restituiscono un errore. Per i progetti non registrati, la richiesta di caricamento sostituisce i caratteri non validi con trattini bassi che restituisce un errore.
  • Caricamento dei dati CSV utilizzando il rilevamento automatico dello schema non supporta nomi di colonne flessibili per impostazione predefinita. Per iscriverti a questa anteprima, completa la modulo di registrazione. Tieni presente che, dopo la registrazione all'anteprima, eventuali nomi di colonna non validi (ad esempio, regole di confronto dei nomi di colonna) restituisce un errore. Per i progetti non registrata, la richiesta di caricamento sostituisce i caratteri non validi con trattini bassi anziché restituire un errore.

Limitazioni

I nomi delle colonne flessibili hanno un supporto limitato per le tabelle esterne. Colonna flessibile sono supportati solo per le tabelle Apache Iceberg e Delta Lake con colonna la mappatura dei nomi abilitata. Non sono supportate per altre tabelle esterne.

NULL valori

Tieni presente che per i job di caricamento, BigQuery ignora gli elementi NULL per il parametro Tipo composto list, altrimenti verrebbe tradotto in NULL ARRAY che non possono rimanere in una tabella (vedi Tipi di dati per dettagli).

Per ulteriori informazioni sui tipi di dati ORC, consulta Specifica Apache ORCTM v1.