Uso de los formatos Native y binarios en ClickHouse

ClickHouse admite múltiples formatos binarios, que ofrecen un mejor rendimiento y un uso más eficiente del espacio. Los formatos binarios también evitan problemas de codificación de caracteres, ya que los datos se guardan en formato binario.

Vamos a usar some_data tabla y datos para la demostración; no dudes en reproducirlo en tu instancia de ClickHouse.

El formato de datos más eficiente para exportar e importar datos entre nodos de ClickHouse es el formato Native. La exportación se realiza con la cláusula INTO OUTFILE:

SELECT * FROM some_data
INTO OUTFILE 'data.clickhouse' FORMAT Native

Esto creará el archivo data.clickhouse en formato nativo.

Para importar datos, podemos usar file() para archivos pequeños o para tareas de exploración:

DESCRIBE file('data.clickhouse', Native);

┌─name──┬─type───┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ path  │ String │              │                    │         │                  │                │
│ month │ Date   │              │                    │         │                  │                │
│ hits  │ UInt32 │              │                    │         │                  │                │
└───────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘

En producción, usamos FROM INFILE para importar datos:

INSERT INTO sometable
FROM INFILE 'data.clickhouse'
FORMAT Native

También podemos habilitar la compresión al exportar datos en formato Native (así como en la mayoría de los demás formatos) mediante la cláusula COMPRESSION:

SELECT * FROM some_data
INTO OUTFILE 'data.clickhouse'
COMPRESSION 'lz4'
FORMAT Native

Hemos utilizado compresión LZ4 para la exportación. Tendremos que especificarla al importar los datos:

INSERT INTO sometable
FROM INFILE 'data.clickhouse'
COMPRESSION 'lz4'
FORMAT Native

Otro formato binario compatible es RowBinary, que permite importar y exportar datos en filas codificadas en binario:

SELECT * FROM some_data
INTO OUTFILE 'data.binary' FORMAT RowBinary

Esto generará el archivo data.binary en formato binario por filas.

La inferencia automática de esquemas no está disponible para este formato, así que, para explorarlo antes de cargarlo, tenemos que definir el esquema explícitamente:

SELECT *
FROM file('data.binary', RowBinary, 'path String, month Date, hits UInt32')
LIMIT 5

┌─path───────────────────────────┬──────month─┬─hits─┐
│ Bangor_City_Forest             │ 2015-07-01 │   34 │
│ Alireza_Afzal                  │ 2017-02-01 │   24 │
│ Akhaura-Laksam-Chittagong_Line │ 2015-09-01 │   30 │
│ 1973_National_500              │ 2017-10-01 │   80 │
│ Attachment                     │ 2017-09-01 │ 1356 │
└────────────────────────────────┴────────────┴──────┘

Considere usar RowBinaryWithNames, que también añade una fila de encabezado con la lista de columnas. RowBinaryWithNamesAndTypes también añade una fila de encabezado adicional con los tipos de las columnas.

Para cargar datos desde un archivo RowBinary, podemos usar la cláusula FROM INFILE:

INSERT INTO sometable
FROM INFILE 'data.binary'
FORMAT RowBinary

Supongamos que queremos leer un archivo binario completo y guardarlo en un campo de una tabla. Este es el caso en el que puede usarse el formato RawBLOB. Este formato solo puede usarse directamente con una tabla de una sola columna:

CREATE TABLE images(data String) ENGINE = Memory

Guardemos un archivo de imagen en la tabla images:

cat image.jpg | clickhouse-client -q "INSERT INTO images FORMAT RawBLOB"

Podemos verificar la longitud del campo data, que será igual al tamaño original del archivo:

SELECT length(data) FROM images

┌─length(data)─┐
│         6121 │
└──────────────┘

Este formato también se puede usar para exportar datos mediante una cláusula INTO OUTFILE:

SELECT * FROM images LIMIT 1
INTO OUTFILE 'out.jpg'
FORMAT RawBLOB

Ten en cuenta que tuvimos que usar LIMIT 1 porque exportar más de un valor creará un archivo dañado.

ClickHouse admite la importación y exportación de MessagePack mediante MsgPack. Para exportar al formato MessagePack:

SELECT *
FROM some_data
INTO OUTFILE 'data.msgpk'
FORMAT MsgPack

Para importar datos de un archivo MessagePack:

INSERT INTO sometable
FROM INFILE 'data.msgpk'
FORMAT MsgPack

Para trabajar con Protocol Buffers, primero debemos definir un archivo de esquema:

syntax = "proto3";

message MessageType {
  string path = 1;
  date month = 2;
  uint32 hits = 3;
};

La ruta de este archivo de esquema (schema.proto en nuestro caso) se especifica en la opción de configuración format_schema del formato Protobuf:

SELECT * FROM some_data
INTO OUTFILE 'proto.bin'
FORMAT Protobuf
SETTINGS format_schema = 'schema:MessageType'

Esto guarda los datos en el archivo proto.bin. ClickHouse también permite importar datos Protobuf y mensajes anidados. Considere usar ProtobufSingle para trabajar con un solo mensaje de Protocol Buffer (en este caso, se omitirán los delimitadores de longitud).

Otro formato popular de serialización binaria compatible con ClickHouse es Cap'n Proto. Al igual que con el formato Protobuf, en nuestro ejemplo tenemos que definir un archivo de esquema (schema.capnp):

@0xec8ff1a10aa10dbe;

struct PathStats {
  path @0 :Text;
  month @1 :UInt32;
  hits @2 :UInt32;
}

Ahora podemos importar y exportar con el formato CapnProto y este esquema:

SELECT
    path,
    CAST(month, 'UInt32') AS month,
    hits
FROM some_data
INTO OUTFILE 'capnp.bin'
FORMAT CapnProto
SETTINGS format_schema = 'schema:PathStats'

Ten en cuenta que tuvimos que convertir la columna Date a UInt32 para ajustarla a los tipos correspondientes.

ClickHouse admite muchos formatos, tanto de texto como binarios, para cubrir diversos escenarios y plataformas. Consulta más formatos y formas de trabajar con ellos en los siguientes artículos:

• Formatos CSV y TSV
• Parquet
• Formatos JSON
• Regex y templates
• Formatos Native y binarios
• Formatos SQL

Y también consulta clickhouse-local, una herramienta portátil y completa para trabajar con archivos locales y remotos sin iniciar el servidor de ClickHouse.