Cargar datos de Parquet desde Google Cloud Storage

Esta página proporciona una descripción general de la carga de datos de Parquet desde Cloud Storage en BigQuery.

Parquet es un formato de datos orientado a columnas de código abierto que se usa ampliamente en el ecosistema de Apache Hadoop.

Cuando cargas datos Parquet desde Cloud Storage, puedes cargar los datos en una tabla o partición nuevas, o puedes agregar o reemplazar una tabla o partición existente. 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 más información sobre cómo cargar datos Parquet desde un archivo local, consulta Cargar datos en BigQuery desde una fuente de datos local.

Esquemas de Parquet

Cuando cargas archivos Parquet en BigQuery, el esquema de la tabla se recupera automáticamente de los datos de origen de descripción automática. Cuando BigQuery recupera el esquema de los datos de origen, se usa el último archivo en orden alfabético.

Por ejemplo, tienes los siguientes archivos de Parquet en Cloud Storage:

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

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

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

Cuando cargas varios archivos de Parquet con diferentes esquemas, las columnas idénticas especificadas en múltiples esquemas deben tener el mismo modo en cada definición de esquema.

Cuando BigQuery detecta el esquema, algunos tipos de datos de Parquet se convierten en tipos de datos de BigQuery para que sean compatibles con la sintaxis de BigQuery SQL. Para obtener más información, consulta conversiones de Parquet.

Compresión de Parquet

Los archivos comprimidos de Parquet no son compatibles, pero sí los bloques de datos comprimidos. BigQuery es compatible con los códecs de Snappy y GZip.

Cómo cargar datos de Parquet data en una tabla nueva

Sigue los pasos a continuación para cargar datos de Parquet de Google Cloud Storage en una tabla nueva de BigQuery o agregar datos a una tabla existente:

IU web

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 haz clic en 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 de origen:
- Para la Ubicación, selecciona Google Cloud Storage y en el campo de origen ingresa el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios 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 estás creando.
- Para el formato de archivo, selecciona Parquet.
En la página Crear tabla, en la sección Tabla de destino:
- Para el Nombre de tabla, elige el conjunto de datos apropiado. Luego, ingresa el nombre de la tabla que quieres crear en BigQuery en el campo correspondiente.
- Verifica que el Tipo de tabla esté configurado en Tabla nativa.
En la sección Esquema no es necesaria ninguna acción. El esquema se describe en sí en archivos de Parquet.
Haz clic en Crear tabla.

Línea de comandos

Usa el comando bq load, especifica el PARQUET como el source_format, y agrega 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 configura 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. Por ejemplo, si usas BigQuery en la región de Tokio, puedes configurar el valor de las marcas en asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
[FORMAT] es PARQUET.
[DATASET] es un conjunto de datos existente.
[TABLE] es el nombre de la tabla en la que cargas 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.parquet 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=PARQUET mydataset.mytable gs://mybucket/mydata.parquet
```
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 de varias regiones de US.
```
bq --location=US load --source_format=PARQUET mydataset.mytable gs://mybucket/mydata*.parquet
```
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 de asia-northeast1.
```
bq --location=asia-northeast1 load --autodetect --source_format=PARQUET mydataset.mytable "gs://mybucket/00/*.parquet","gs://mybucket/01/*.parquet"
```

API

Configura las siguientes propiedades para cargar datos de Parquet con la API.

Crea un trabajo de carga que apunte a los datos de origen en Google Cloud Storage.
Especifica tu ubicación en la propiedad de la location en la sección de 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 '*'.
Especifica el formato de datos de Parquet mediante la configuración de la propiedad configuration.load.sourceFormat a PARQUET.
Para verificar el estado del trabajo, llama jobs.get([JOB_ID]*), en el que [JOB_ID] es el ID del trabajo mostrado por la solicitud inicial.
- Si el estado es status.state = DONE, el trabajo se completó correctamente.
- Si la propiedad status.errorResult está presente, la solicitud falló y ese objeto incluirá información que describe lo que salió mal. Cuando falla una solicitud, no se crea ninguna tabla ni se agregan datos.
- Si status.errorResult está ausente, el trabajo finalizó correctamente, 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 API:

Los trabajos de carga son atómicos y coherentes, si un trabajo de carga falla, ninguno de los datos está disponible, y si un trabajo de carga es correcto, todos los datos está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.

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. Para obtener más información, consulta la documentación de referencia de la API de Go de BigQuery.

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.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())
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Java de BigQuery.

Ver en GitHub Comentarios

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();
// Load the table
Job loadJob = bigquery.create(JobInfo.of(configuration));
loadJob = loadJob.waitFor();
// Check the table
StandardTableDefinition destinationTable = bigquery.getTable(tableId).getDefinition();
System.out.println("State: " + loadJob.getStatus().getState());
System.out.printf("Loaded %d rows.\n", destinationTable.getNumRows());

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

Ver en GitHub Comentarios

// Imports 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 projectId = "your-project-id";
// const datasetId = "my_dataset";
// const tableId = "my_table";

/**
 * 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';

// Instantiates clients
const bigquery = new BigQuery({projectId});
const storage = new Storage({projectId});

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

// Loads 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

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de PHP de BigQuery.

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

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. Para obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Usa el método Client.load_table_from_uri() para iniciar un trabajo de carga desde Cloud Storage. Para usar Parquet, configura la propiedad LoadJobConfig.source_format a la constante SourceFormat PARQUET y pasa la configuración del trabajo como el argumento job_config al método load_table_from_uri().

Ver en GitHub

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

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

Cómo reemplazar una tabla con datos de Parquet

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 Preferencia de escritura para especificar qué acción tomar cuando cargues datos desde un archivo de origen o desde un resultado de consulta.

Tienes las siguientes opciones cuando cargas datos adicionales en una tabla:

Opción de Console	Opción de IU clásica	Marca CLI	Propiedad de la API de BigQuery	Descripción
Escribir si está vacía	Escribir si está vacía	Ninguno	WRITE_EMPTY	Escribe los datos solo si la tabla está vacía.
Agregar a la tabla	Agregar a la tabla	`--noreplace` o `--replace=false`, si `--[no]replace` no está especificado, el valor predeterminado es agregar	WRITE_APPEND	(Predeterminado) Agrega los datos al final de la tabla.
Reemplazar tabla	Reemplazar tabla	`--replace` o `--replace=true`	WRITE_TRUNCATE	Borra todos los datos existentes en una tabla antes de escribir los datos nuevos.

De forma predeterminada, los trabajos de carga agregará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:

IU web

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 haz clic en 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 de origen:
- Para la Ubicación, selecciona Google Cloud Storage y en el campo de origen, ingresa el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios 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 estás creando o reemplazando.
- Para el formato de archivo, selecciona Parquet.
En la página Crear tabla, en la sección Tabla de destino:
- Para 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 estás creando o reemplazando.
- Verifica que el Tipo de tabla esté configurado en Tabla nativa.
En la sección Esquema no es necesaria ninguna acción. La información del esquema se describe en sí en archivos de Parquet.
En la sección Opciones, para la Preferencia de escritura, elige Escribir si está vacío, Agregar a la tabla o Reemplazar tabla.
Haz clic en Crear tabla.

Línea de comandos

Ingresa el comando bq load con la marca --replace para reemplazar la tabla. Proporciona la marca --location y configura el valor en tu ubicación. Usa la marca --noreplace para agregar datos a una tabla. Si no se especifica ninguna marca, se agregan 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. Puedes configurar un valor predeterminado para la ubicación usando el archivo .bigqueryrc.
[DATASET] es un conjunto de datos existente.
[TABLE] es el nombre de la tabla en la que cargas 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.parquet 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=PARQUET mydataset.mytable gs://mybucket/mydata.parquet
```
El siguiente comando carga datos desde gs://mybucket/mydata.parquet 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=PARQUET mydataset.mytable gs://mybucket/mydata.parquet
```

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 Google Cloud Storage.
Especifica tu ubicación en la propiedad de la location en la sección de jobReference del recurso de trabajo.
Los URI de origen deben estar completamente calificados en el formato gs://[BUCKET]/[OBJECT]. Puedes incluir varios URI como una lista separada por comas. Ten en cuenta que los comodines también son compatibles cuando se cargan datos CSV desde Google Cloud Storage.
Especifica el formato de datos mediante la configuración de la propiedad configuration.load.sourceFormat a PARQUET.
Especifica la preferencia de escritura configurando la propiedad configuration.load.writeDisposition en WRITE_TRUNCATE, WRITE_APPEND o WRITE_EMPTY.

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.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())
}

Node.js

Ver en GitHub Comentarios

// Imports 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 projectId = "your-project-id";
// 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.parquet';

// Instantiates clients
const bigquery = new BigQuery({
  projectId: projectId,
});

const storage = new Storage({
  projectId: projectId,
});

// 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: 'PARQUET',
  // Set the write disposition to overwrite existing table data.
  writeDisposition: 'WRITE_TRUNCATE',
};

// Loads 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

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

Para remplazar las filas en una tabla existente, configura la propiedad LoadJobConfig.write_disposition a la constante WriteDisposition WRITE_TRUNCATE.

Ver en GitHub

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

previous_rows = client.get_table(table_ref).num_rows
assert previous_rows > 0

job_config = bigquery.LoadJobConfig()
job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
job_config.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_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))

Conversiones de Parquet

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

Tipos de conversiones

Tipo de Parquet	Tipos de conversión de Parquet	Tipos de datos de BigQuery
BOOLEANO	NINGUNO	Booleano
INT32	NINGUNO, UINT_8, UINT_16, UINT_32, INT_8, INT_16, INT_32	Número entero
INT32	DECIMAL (ver anotación DECIMAL)	Numérico
INT32	FECHA	Fecha
INT64	NINGUNO, UINT_64, INT_64	Número entero
INT64	DECIMAL (ver anotación DECIMAL)	Numérico
INT64	TIMESTAMP_MILLIS	Marca de tiempo
INT64	TIMESTAMP_MICROS	Marca de tiempo
INT96	NINGUNO	Marca de tiempo
FLOAT	NINGUNO	Punto flotante
DOBLE	NINGUNO	Punto flotante
BYTE_ARRAY	NINGUNO	Bytes
BYTE_ARRAY	UTF8	String
FIXED_LEN_BYTE_ARRAY	DECIMAL (ver anotación DECIMAL)	Numérico
FIXED_LEN_BYTE_ARRAY	NINGUNO	Bytes

Otras combinaciones de tipos de Parquet y tipos convertidos no son compatibles.

Anotación decimal

Los tipos de Parquet con la anotación DECIMAL pueden tener como máximo una precisión de 38 (número total de dígitos) y como máximo una escala de 9 (dígitos a la derecha del decimal). El número de dígitos enteros, que es la precisión menos la escala, puede ser de máximo 29. Por ejemplo, DECIMAL(38, 9) es compatible porque la precisión es 38 y la escala es 9. En este ejemplo, el número de dígitos enteros es 29. DECIMAL(38, 5) no es compatible porque tiene una precisión de 38 y una escala de 5. En este ejemplo, el número de dígitos enteros es 33.

Conversiones de nombre de columna

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

_TABLE_
_FILE_
_PARTITION

No se permiten nombres de columna duplicados, incluso si el caso difiere. Por ejemplo, una columna llamada Column1 se considera idéntica a una columna con el nombre column1.

Actualmente, no puedes cargar archivos de Parquet que contengan columnas que tengan un punto (.) en el nombre de la columna.

Si el nombre de una columna de Parquet contiene otros caracteres (aparte de un punto), los caracteres se reemplazan por guiones bajos. Se pueden agregar guiones bajos a los nombres de las columnas para evitar colisiones. Por ejemplo, si un archivo de Parquet contiene 2 columnas Column1 y column1, las columnas se cargan como Column1 y column1_, respectivamente.

Esquemas de Parquet

Compresión de Parquet

Cómo cargar datos de Parquet data en una tabla nueva

IU web

Línea de comandos

API

Go

Java

Node.js

PHP

Python

Cómo reemplazar una tabla con datos de Parquet

IU web

Línea de comandos

API

Go

Node.js

PHP

Python

Conversiones de Parquet

Tipos de conversiones

Anotación decimal

Conversiones de nombre de columna

Enviar comentarios sobre...