Carga datos de ORC desde Cloud Storage

En esta página, se proporciona una descripción general de la carga de datos ORC de Cloud Storage en BigQuery.

ORC es un formato de datos de código abierto orientado a columnas, cuyo uso está generalizado en el ecosistema de Apache Hadoop.

Cuando cargas datos ORC de Cloud Storage, puedes cargar datos en una tabla o partición nuevas, o puedes adjuntar o reemplazar una tabla o partición existentes. Cuando tus datos se cargan en BigQuery, se convierten en formato de columnas para Capacitor (formato de almacenamiento de BigQuery).

Cuando cargas datos de Cloud Storage en una tabla de BigQuery, el conjunto de datos que contiene la tabla debe estar en la misma ubicación regional o multirregional que el depósito de Cloud Storage.

Para obtener información sobre cómo cargar datos ORC de un archivo local, consulta Carga datos en BigQuery desde una fuente de datos local.

Esquemas de ORC

Cuando cargas archivos ORC en BigQuery, el esquema de la tabla se recupera de forma automática a partir de los datos de origen autodescriptivos. Cuando BigQuery recupera el esquema de los datos de origen, se usa el último archivo en orden alfabético.

Por ejemplo, supongamos que tienes los siguientes archivos ORC en Cloud Storage:

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

Este comando carga todos los archivos en un solo comando de CLI (como una lista separada por comas), y el esquema se deriva de mybucket/01/b.orc:

bq --location=US load --source_format=ORC [DATASET].[TABLE] "gs://mybucket/00/*.orc","gs://mybucket/01/*.orc"

Cuando BigQuery detecta el esquema, algunos tipos de datos ORC se convierten en tipos de datos de BigQuery para hacerlos compatibles con la sintaxis SQL de BigQuery. Todos los campos del esquema detectado son NULLABLE (anulables). Para obtener más información, consulta Conversiones de ORC.

Cuando cargas varios archivos ORC con diferentes esquemas, los campos idénticos (con el mismo nombre y mismo nivel de anidamiento) especificados en múltiples esquemas deben asignarse al mismo tipo de datos convertido de BigQuery en cada definición de esquema.

Compresión de ORC

Los archivos ORC comprimidos no son compatibles, pero las rayas y el pie de página del archivo comprimido lo son. Los tipos de compresión compatibles son Zlib, Snappy, LZO y LZ4.

Carga datos ORC en una tabla nueva

Sigue los pasos que se indican a continuación para cargar datos ORC de Cloud Storage en una tabla de BigQuery nueva o para adjuntar datos a una tabla existente:

Console

Abre la IU web de BigQuery en GCP Console.
Ir a la IU web de BigQuery
En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos.
En el lado derecho de la ventana, en el panel de detalles, haz clic en Crear tabla (Create table). El proceso de carga de datos es el mismo que el proceso para crear una tabla vacía.
En la página Crear tabla (Create table), en la sección Origen (Source):
- En Crear tabla desde (Create table from), selecciona el tipo de fuente que desees.
- En el campo de origen, busca el depósito de Cloud Storage/archivo, o ingresa el URI de Cloud Storage. Ten en cuenta que no puedes ingresar más de un URI en la IU web de BigQuery, pero se admiten comodines. El depósito de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que vas a crear.
- En Formato de archivo (File format), selecciona ORC.
En la sección Destino (Destination) de la página Crear tabla (Create table), haz lo siguiente:
- Para Nombre del conjunto de datos (Dataset name), selecciona el conjunto de datos que corresponda.
- En el campo Nombre de la tabla (Table name), ingresa el nombre de la tabla que creas en BigQuery.
- Verifica que Tipo de tabla (Table type) esté configurado como Tabla nativa (Native table).
En la sección Esquema, no hace falta que realices ninguna acción. El esquema se describe de forma automática en los archivos ORC.
Selecciona los elementos aplicables en la sección Opciones avanzadas (Advanced options) y luego haz clic en Crear tabla (Create table).

IU clásica

Ve a la IU web de BigQuery.
Ir a la IU web de BigQuery
En el panel de navegación, desplázate sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo y selecciona Crear tabla nueva. El proceso de carga de datos es el mismo que el proceso para crear una tabla vacía.
En la página Crear tabla, en la sección Datos fuente:
- En Ubicación, selecciona Cloud Storage y en el campo de origen ingresa el URI de Cloud Storage. Ten en cuenta que no puedes ingresar más de un URI en la IU web de BigQuery, pero se admiten comodines. El depósito de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que vas a crear.
- En Formato de archivo, selecciona ORC.
En la página Crear tabla, en la sección Tabla de destino, realiza lo siguiente:
- En Table name (Nombre de tabla), selecciona el conjunto de datos apropiado y, en el campo de nombre de tabla, ingresa el nombre de la tabla que vas a crear en BigQuery.
- Verifica que Tipo de tabla (Table type) esté configurado como Tabla nativa (Native table).
En la sección Esquema, no hace falta que realices ninguna acción. El esquema se describe de forma automática en los archivos ORC.
Haz clic en Create Table (Crear tabla).

Línea de comandos

Usa el comando bq load, especifica ORC como el source_format y, además, incluye un URI de Cloud Storage. Puedes incluir un solo URI, una lista de URI separados por comas o un URI que contenga un comodín.

Proporciona la marca --location y establece el valor en tu ubicación.

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

donde:

[LOCATION] es tu ubicación. La marca --location es opcional si tus datos están en la ubicación multirregión US o EU. Por ejemplo, si usas BigQuery en la región de Tokio, configura el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
[FORMAT] es ORC.
[DATASET] es un conjunto de datos existente.
[TABLE] es el nombre de la tabla en la que cargas los datos.
[PATH_TO_SOURCE] es un URI de Cloud Storage totalmente calificado o una lista de URI separados por comas. También se admiten comodines.

Ejemplos:

El siguiente comando carga datos de gs://mybucket/mydata.orc en una tabla llamada mytable en mydataset. mybucket y mydataset se crearon en la ubicación multirregión US.
```
bq --location=US load --source_format=ORC mydataset.mytable gs://mybucket/mydata.orc
```
El siguiente comando carga datos de varios archivos en gs://mybucket/ en una tabla llamada mytable en mydataset. El URI de Cloud Storage usa un comodín. mybucket y mydataset se crearon en la ubicación multirregión US.
```
bq --location=US load --source_format=ORC mydataset.mytable gs://mybucket/mydata*.orc
```
El siguiente comando carga datos de varios archivos en gs://mybucket/ en una tabla llamada mytable en mydataset. El comando incluye una lista separada por comas de URI de Cloud Storage con comodines. mybucket y mydataset se crearon en la región asia-northeast1.
```
bq --location=asia-northeast1 load --autodetect --source_format=ORC mydataset.mytable "gs://mybucket/00/*.orc","gs://mybucket/01/*.orc"
```

API

Configura las siguientes propiedades para cargar los datos ORC con la API.

Crea un trabajo de carga que apunte a los datos de origen en Cloud Storage.
Especifica tu ubicación en la propiedad location, en la sección jobReference del recurso de trabajo.
Los URI de origen deben estar completamente calificados en el formato gs://[BUCKET]/[OBJECT]. Cada URI puede contener un carácter comodín “*”.
Configura la propiedad configuration.load.sourceFormat como ORC para especificar el formato de datos ORC.
Para verificar el estado del trabajo, llama a jobs.get([JOB_ID]*), en el que [JOB_ID] es el ID del trabajo que muestra la solicitud inicial.
- Si se muestra status.state = DONE, el trabajo se completó con éxito.
- Si la propiedad status.errorResult está presente, la solicitud falló, y ese objeto incluirá información que describe qué salió mal. Cuando una solicitud falla, no se crea ninguna tabla ni se agregan datos.
- Si status.errorResult está ausente, el trabajo se completó con éxito, aunque puede haber algunos errores no fatales, como problemas cuando se importan algunas filas. Los errores no fatales se enumeran en la propiedad status.errors del objeto de trabajo mostrado.

Notas de API:

Los trabajos de carga son atómicos y coherentes; si un trabajo de carga falla, ninguno de los datos estará disponible, y si un trabajo de carga se realiza con éxito, todos los datos estarán disponibles.
Como recomendación, genera un ID único y pásalo como jobReference.jobId cuando llames a jobs.insert() para crear un trabajo de carga. Este enfoque es más resistente al fallo de la red porque el cliente puede sondear o reintentar con el ID de trabajo conocido.
Llamar a jobs.insert() con un ID de trabajo dado es idempotente, en otras palabras, puedes volver a intentarlo tantas veces como desees con el mismo ID de trabajo y al menos una de las operaciones será correcta.

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para C# que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Si necesitas más información, consulta la documentación de referencia de la API de BigQuery para C#.

Ver en GitHub Comentarios

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.PollUntilCompleted();  // 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}");
    }
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Ver en GitHub Comentarios

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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())
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

Ver en GitHub Comentarios

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const datasetId = "my_dataset";
// const tableId = "my_table"

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

  // Instantiate clients
  const bigqueryClient = new BigQuery();
  const storageClient = new Storage();

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load
  const metadata = {
    sourceFormat: 'ORC',
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .load(storageClient.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;
  }
}
loadTableGCSORC();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

Ver en GitHub Comentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Ver en GitHub Comentarios

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.source_format = bigquery.SourceFormat.ORC
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.orc"

load_job = client.load_table_from_uri(
    uri, dataset_ref.table("us_states"), job_config=job_config
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

destination_table = client.get_table(dataset_ref.table("us_states"))
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración para Ruby que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

Ver en GitHub Comentarios

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

Anexa o reemplaza una tabla con datos ORC

Puedes cargar datos adicionales en una tabla desde los archivos de origen o cuando agregas los resultados de la consulta.

En la consola y en la IU web clásica de BigQuery, usa la opción de Write preference (Preferencia de escritura) para especificar qué acción tomar cuando cargues datos desde un archivo de origen o desde un resultado de consulta.

Cuando cargas datos adicionales en una tabla, tienes las siguientes opciones:

Opción de la consola	Opción de la IU clásica	Marcador CLI	Propiedad de la API de BigQuery	Descripción
Escribir si está vacía	Escribir si está vacía	Ninguno	WRITE_EMPTY	Solo escribe los datos si la tabla está vacía.
Adjuntar a la tabla	Adjuntar a la tabla	`--noreplace` o `--replace=false`; si `--[no]replace` no se especifica, la opción predeterminada es adjuntar	WRITE_APPEND	(Predeterminado) Adjunta los datos al final de la tabla.
Reemplazar tabla	Reemplazar tabla	`--replace` o `--replace=true`	WRITE_TRUNCATE	Borra todos los datos existentes de una tabla antes de escribir los datos nuevos.

De manera predeterminada, los trabajos de carga adjuntarán datos a una tabla, a menos que se altere la disposición de escritura. Si, en cambio, deseas reemplazar los datos con los datos de un trabajo de carga, puedes optar por reemplazar los datos en una tabla de BigQuery:

Console

Abre la IU web de BigQuery en GCP Console.
Ir a la IU web de BigQuery
En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos.
En el lado derecho de la ventana, en el panel de detalles, haz clic en Crear tabla (Create table). El proceso de carga de datos es el mismo que el proceso para crear una tabla vacía.
En la página Crear tabla (Create table), en la sección Origen (Source):
- En Crear tabla desde (Create table from), selecciona el tipo de fuente que desees.
- En el campo de origen, busca el depósito de Cloud Storage/archivo, o ingresa el URI de Cloud Storage. Ten en cuenta que no puedes ingresar más de un URI en la IU web de BigQuery, pero se admiten comodines. El depósito de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que vas a crear.
- En Formato de archivo (File format), selecciona ORC.
En la sección Destino (Destination) de la página Crear tabla (Create table), haz lo siguiente:
- Para Nombre del conjunto de datos (Dataset name), selecciona el conjunto de datos que corresponda.
- En el campo Nombre de la tabla (Table name), ingresa el nombre de la tabla que creas en BigQuery.
- Verifica que Tipo de tabla (Table type) esté configurado como Tabla nativa (Native table).
En la sección Esquema, ingresa la definición del esquema.
- Para ingresar la información del esquema manualmente, puedes realizar las siguientes acciones:
  - Habilitar Editar como texto (Edit as text) y, luego ingresar el esquema de la tabla como un arreglo JSON
    
    Nota: Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando: bq show --format=prettyjson [DATASET].[TABLE].
  - Usar Agregar campo (Add field) para ingresar el esquema de forma manual
En la sección Opciones avanzadas (Advanced options), en Preferencia de escritura (Write preference), elige Escribir si está vacía (Write if empty), Agregar a la tabla (Append to table), o bien Reemplazar tabla (Overwrite table).
Haz clic en Crear tabla.

IU clásica

Ve a la IU web de BigQuery.
Ir a la IU web de BigQuery
En el panel de navegación, desplázate sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo y selecciona Crear tabla nueva. El proceso de carga de datos es el mismo que el proceso para crear una tabla vacía.
En la página Crear tabla, en la sección Datos fuente:
- En Ubicación, selecciona Cloud Storage y en el campo de origen, ingresa el URI de Cloud Storage. Ten en cuenta que no puedes ingresar más de un URI en la IU, pero se admiten comodines. El depósito de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que creas o reemplazas.
- En Formato de archivo, selecciona ORC.
En la página Crear tabla, en la sección Tabla de destino, realiza lo siguiente:
- En Nombre de la tabla, elige el conjunto de datos apropiado y en el campo de nombre de la tabla ingresa el nombre de la tabla que creas o reemplazas.
- Verifica que Tipo de tabla (Table type) esté configurado como Tabla nativa (Native table).
En la sección Esquema, no hace falta que realices ninguna acción. La información del esquema se describe de forma automática en los archivos ORC.
En la sección Options (Opciones), en Write preference (Escribir preferencia), elige Write if empty (Escribir si está vacía), Append to table (Adjuntar a la tabla), o bien Overwrite table (Reemplazar tabla).
Haz clic en Create Table (Crear tabla).

Línea de comandos

Ingresa el comando bq load con el marcador --replace para reemplazar la tabla. Proporciona la marca --location y establece el valor en tu ubicación. Usa la marca --noreplace para agregar datos a una tabla. Si no se especifica ningún marcador, se adjuntan datos de manera predeterminada.

bq --location=[LOCATION] load --[no]replace [DATASET].[TABLE] [PATH_TO_SOURCE]

donde:

[LOCATION] es tu ubicación. La marca --location es opcional si tus datos están en la ubicación multirregión US o EU. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
[DATASET] es un conjunto de datos existente.
[TABLE] es el nombre de la tabla en la que cargas los datos.
[PATH_TO_SOURCE] es un URI de Cloud Storage totalmente calificado o una lista de URI separados por comas. También se admiten comodines.

Ejemplos:

El siguiente comando carga datos desde gs://mybucket/mydata.orc y reemplaza una tabla llamada mytable en mydataset. mybucket y mydataset se crearon en la ubicación multirregión US.
```
bq --location=US load --replace --source_format=ORC mydataset.mytable gs://mybucket/mydata.orc
```
El siguiente comando carga datos desde gs://mybucket/mydata.orc y agrega los datos a una tabla llamada mytable en mydataset. mybucket y mydataset se crearon en la región asia-northeast1.
```
bq --location=asia-northeast1 load --noreplace --source_format=ORC mydataset.mytable gs://mybucket/mydata.orc
```

API

Configura las siguientes propiedades para cargar datos CSV con la API.

Crea un trabajo de carga que apunte a los datos de origen en Cloud Storage.
Especifica tu ubicación en la propiedad location, en la sección jobReference del recurso de trabajo.
Los URI de origen deben estar completamente calificados en el formato gs://[BUCKET]/[OBJECT]. Puedes incluir varios URI en una lista separada por comas. Ten en cuenta que los comodines también son compatibles cuando se cargan datos CSV desde Cloud Storage.
Establece la propiedad configuration.load.sourceFormat como ORC para especificar el formato de datos.
Configura la propiedad configuration.load.writeDisposition como WRITE_TRUNCATE, WRITE_APPEND o WRITE_EMPTY para especificar la preferencia de escritura. Para trabajos de carga, el modo predeterminado es WRITE_APPEND.

C#

Ver en GitHub Comentarios

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.PollUntilCompleted();  // 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}");
    }
}

Go

Ver en GitHub Comentarios

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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())
}

Node.js

Ver en GitHub Comentarios

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = "my_dataset";
// const tableId = "my_table";

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

  // Instantiate clients
  const bigqueryClient = new BigQuery();
  const storageClient = new Storage();

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load
  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 bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .load(storageClient.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;
  }
}
loadORCFromGCSTruncate();

PHP

Ver en GitHub Comentarios

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

Para reemplazar las filas de una tabla existente, configura la propiedad LoadJobConfig.write_disposition como WRITE_TRUNCATE.

Ver en GitHub Comentarios

# from google.cloud import bigquery
# client = bigquery.Client()
# table_ref = client.dataset('my_dataset').table('existing_table')

job_config = bigquery.LoadJobConfig()
job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
job_config.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_ref, job_config=job_config
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

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

Ruby

Ver en GitHub Comentarios

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

Conversiones de ORC

BigQuery convierte los tipos de datos ORC en los siguientes tipos de datos de BigQuery:

Tipos básicos

Tipo de datos ORC	Tipo de datos de BigQuery	Notas
boolean	BOOLEAN
byte	INTEGER
short	INTEGER
int	INTEGER
long	INTEGER
float	FLOAT
double	FLOAT
string	STRING	Solo UTF-8
varchar	STRING	Solo UTF-8
char	STRING	Solo UTF-8
binary	BYTES
date	DATE
timestamp	TIMESTAMP	ORC admite la precisión de nanosegundos, pero BigQuery convierte los valores inferiores a microsegundos en microsegundos cuando se leen los datos.
decimal	NUMERIC o STRING	El tipo NUMERIC consiste en valores numéricos exactos con 38 dígitos de precisión y 9 dígitos decimales de escala. Consulta Tipo NUMERIC para ver más detalles. Si un tipo decimal en un esquema ORC tiene su escala a no más de 9 y su precisión/escala a no más de 29, se convierte en NUMERIC. De lo contrario, se convierte en STRING. Si un tipo decimal se convierte en STRING, se muestra un mensaje de advertencia.

Tipos complejos

Tipo de datos ORC	Tipo de datos de BigQuery	Notas
struct	RECORD	Todos los campos son NULLABLE. Se ignora el orden de los campos. El nombre de un campo debe ser un nombre de columna válido.
map<K,V>	RECORD	Un campo map<K,V> de ORC se convierte en un RECORD repetido que contiene dos campos: una clave con el mismo tipo de datos que K y un valor con el mismo tipo de datos que V. Ambos campos son NULLABLE.
list	repeated fields	Las listas anidadas y de mapas no son compatibles.
union	RECORD	Cuando union solo tiene una variante, se convierte en un campo NULLABLE. De lo contrario, un union se convierte en un RECORD con una lista de campos NULLABLE. Los campos NULLABLE tienen sufijos como campo_0, campo_1, etcétera. Solo se asigna un valor a uno de estos campos cuando se leen los datos.

Nombres de columnas

Un nombre de columna solo debe contener letras (a-z, A-Z), números (0-9) o guiones bajos (_) y deben comenzar con una letra o un guion bajo. La longitud máxima del nombre de la columna es de 128 caracteres. No se puede usar ninguno de los siguientes prefijos para el nombre de una columna:

_TABLE_
_FILE_
_PARTITION

No se permiten nombres de columna duplicados, incluso si difieren las mayúsculas y minúsculas. Por ejemplo, una columna llamada Column1 se considera idéntica a una columna con el nombre column1.

Valores `NULL`

Ten en cuenta que, por el momento, BigQuery ignora los elementos NULL para el tipo compuesto list.

Para obtener más información sobre los tipos de datos ORC, consulta la Especificación v1 de Apache ORC™.

Esquemas de ORC

Compresión de ORC

Carga datos ORC en una tabla nueva

Console

IU clásica

Línea de comandos

API

C#

Go

Node.js

PHP

Python

Ruby

Anexa o reemplaza una tabla con datos ORC

Console

IU clásica

Línea de comandos

API

C#

Go

Node.js

PHP

Python

Ruby

Conversiones de ORC

Tipos básicos

Tipos complejos

Nombres de columnas

Valores NULL

Enviar comentarios sobre...

Valores `NULL`