> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Uso de los formatos Native y binarios en ClickHouse

> Página que describe cómo usar los formatos Native y binarios en ClickHouse

export const CloudNotSupportedBadge = () => {
  return <div className="cloudNotSupportedBadge">
            <div className="cloudNotSupportedIcon">
            <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
                <path strokeWidth="1.5" d="M6.33366 12.6666L12.3739 12.6667C13.6593 12.6667 14.7073 11.6187 14.7073 10.3334C14.7073 9.04804 13.6593 8.00003 12.3739 8.00003C12.3739 8.00003 12.3337 7.66659 12.0003 7.33325M10.667 5.33322C8.00033 2.33325 4.45395 4.78537 4.14195 6.68203C2.55728 6.7627 1.29395 8.06203 1.29395 9.6667C1.29395 11.3234 2.66699 12.6666 4.00033 12.6666" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
                <path strokeWidth="1.5" d="M2.66699 14L12.0003 4.66663" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
            </svg>

        </div>
            Not supported in ClickHouse Cloud
        </div>;
};

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](/es/assets/some_data.sql) y [datos](/es/assets/some_data.tsv) para la demostración; no dudes en reproducirlo en tu instancia de ClickHouse.

<div id="exporting-in-a-native-clickhouse-format">
  ## Exportación en formato Native de ClickHouse
</div>

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

```sql theme={null}
SELECT * FROM some_data
INTO OUTFILE 'data.clickhouse' FORMAT Native
```

Esto creará el archivo [data.clickhouse](/es/assets/data.clickhouse) en formato nativo.

<div id="importing-from-a-native-format">
  ### Importación desde el formato Native
</div>

Para importar datos, podemos usar [file()](/es/reference/functions/table-functions/file) para archivos pequeños o para tareas de exploración:

```sql theme={null}
DESCRIBE file('data.clickhouse', Native);
```

```response theme={null}
┌─name──┬─type───┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ path  │ String │              │                    │         │                  │                │
│ month │ Date   │              │                    │         │                  │                │
│ hits  │ UInt32 │              │                    │         │                  │                │
└───────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```

<Tip>
  Al usar la función `file()`, con ClickHouse Cloud tendrás que ejecutar los comandos en `clickhouse client` desde la máquina donde se encuentra el archivo. Otra opción es usar [`clickhouse-local`](/es/concepts/features/tools-and-utilities/clickhouse-local) para explorar los archivos localmente.
</Tip>

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

```sql theme={null}
INSERT INTO sometable
FROM INFILE 'data.clickhouse'
FORMAT Native
```

<div id="native-format-compression">
  ### Compresión en el formato Native
</div>

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`:

```sql theme={null}
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:

```sql theme={null}
INSERT INTO sometable
FROM INFILE 'data.clickhouse'
COMPRESSION 'lz4'
FORMAT Native
```

<div id="exporting-to-rowbinary">
  ## Exportar a RowBinary
</div>

Otro formato binario compatible es [RowBinary](/es/reference/formats/RowBinary/RowBinary), que permite importar y exportar datos en filas codificadas en binario:

```sql theme={null}
SELECT * FROM some_data
INTO OUTFILE 'data.binary' FORMAT RowBinary
```

Esto generará el archivo [data.binary](/es/assets/data.binary) en formato binario por filas.

<div id="exploring-rowbinary-files">
  ### Explorar archivos RowBinary
</div>

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:

```sql theme={null}
SELECT *
FROM file('data.binary', RowBinary, 'path String, month Date, hits UInt32')
LIMIT 5
```

```response theme={null}
┌─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](/es/reference/formats/RowBinary/RowBinaryWithNames), que también añade una fila de encabezado con la lista de columnas. [RowBinaryWithNamesAndTypes](/es/reference/formats/RowBinary/RowBinaryWithNamesAndTypes) también añade una fila de encabezado adicional con los tipos de las columnas.

<div id="importing-from-rowbinary-files">
  ### Importación de archivos RowBinary
</div>

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

```sql theme={null}
INSERT INTO sometable
FROM INFILE 'data.binary'
FORMAT RowBinary
```

<div id="importing-single-binary-value-using-rawblob">
  ## Importar un único valor binario con RawBLOB
</div>

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](/es/reference/formats/RawBLOB). Este formato solo puede usarse directamente con una tabla de una sola columna:

```sql theme={null}
CREATE TABLE images(data String) ENGINE = Memory
```

Guardemos un archivo de imagen en la tabla `images`:

```bash theme={null}
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:

```sql theme={null}
SELECT length(data) FROM images
```

```response theme={null}
┌─length(data)─┐
│         6121 │
└──────────────┘
```

<div id="exporting-rawblob-data">
  ### Exportación de datos RawBLOB
</div>

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

```sql theme={null}
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.

<div id="messagepack">
  ## MessagePack
</div>

ClickHouse admite la importación y exportación en [MessagePack](https://msgpack.org/) mediante [MsgPack](/es/reference/formats/MsgPack). Para exportar en formato MessagePack:

```sql theme={null}
SELECT *
FROM some_data
INTO OUTFILE 'data.msgpk'
FORMAT MsgPack
```

Para importar datos de un [archivo MessagePack](/es/assets/data.msgpk):

```sql theme={null}
INSERT INTO sometable
FROM INFILE 'data.msgpk'
FORMAT MsgPack
```

<div id="protocol-buffers">
  ## Protocol Buffers
</div>

Para trabajar con [Protocol Buffers](/es/reference/formats/Protobuf/Protobuf), primero debemos definir un [archivo de esquema](/es/assets/schema.proto):

```protobuf theme={null}
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](/es/reference/formats/Protobuf/Protobuf):

```sql theme={null}
SELECT * FROM some_data
INTO OUTFILE 'proto.bin'
FORMAT Protobuf
SETTINGS format_schema = 'schema:MessageType'
```

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

<div id="capn-proto">
  ## Cap'n Proto
</div>

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

```response theme={null}
@0xec8ff1a10aa10dbe;

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

Ahora podemos importar y exportar con el formato [CapnProto](/es/reference/formats/CapnProto) y este esquema:

```sql theme={null}
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](/es/reference/formats/CapnProto#data_types-matching-capnproto).

<div id="other-formats">
  ## Otros formatos
</div>

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](/es/guides/clickhouse/data-formats/csv-tsv)
* [Parquet](/es/guides/clickhouse/data-formats/parquet)
* [Formatos JSON](/es/guides/clickhouse/data-formats/json/intro)
* [Regex y templates](/es/guides/clickhouse/data-formats/templates-regex)
* **Formatos Native y binarios**
* [Formatos SQL](/es/guides/clickhouse/data-formats/sql)

Y también consulta [clickhouse-local](https://clickhouse.com/blog/extracting-converting-querying-local-files-with-sql-clickhouse-local), una herramienta portátil y completa para trabajar con archivos locales y remotos sin iniciar el servidor de ClickHouse.