> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
> Códecs de compresión de columnas para la sentencia CREATE TABLE
# Códecs de compresión de columnas
export const ExperimentalBadge = () => {
return
Funcionalidad experimental
;
};
export const CloudNotSupportedBadge = () => {
return
No es compatible con ClickHouse Cloud
;
};
De forma predeterminada, ClickHouse aplica la compresión `lz4` en la versión autogestionada y `zstd` en ClickHouse Cloud.
En las tablas de la familia de motores `MergeTree`, puede cambiar el método de compresión predeterminado en la sección [compression](/docs/es/reference/settings/server-settings/settings/other#compression) de la configuración del servidor.
También puede definir el método de compresión para cada columna en la consulta [`CREATE TABLE`](/docs/es/reference/statements/create/table).
```sql theme={null}
CREATE TABLE codec_example
(
dt Date CODEC(ZSTD),
ts DateTime CODEC(LZ4HC),
float_value Float32 CODEC(NONE),
double_value Float64 CODEC(LZ4HC(9)),
value Float32 CODEC(Delta, ZSTD)
)
ENGINE =
...
```
El códec `Default` puede especificarse para hacer referencia a la compresión predeterminada, que puede depender de distintos ajustes (y de las propiedades de los datos) en tiempo de ejecución.
Ejemplo: `value UInt64 CODEC(Default)` — equivale a no especificar ningún códec.
Consulte también [Selección adaptativa de códecs](#adaptive-codec-selection).
También puede eliminar el CODEC actual de la columna y usar la compresión predeterminada de config.xml:
```sql theme={null}
ALTER TABLE codec_example MODIFY COLUMN float_value CODEC(Default);
```
Los códecs se pueden combinar en una canalización; por ejemplo, `CODEC(Delta, Default)`.
No puedes descomprimir archivos de bases de datos de ClickHouse con utilidades externas como `lz4`. En su lugar, utiliza la utilidad específica [clickhouse-compressor](https://github.com/ClickHouse/ClickHouse/tree/master/programs/compressor).
La compresión es compatible con los siguientes motores de tabla:
* La familia [MergeTree](/docs/es/reference/engines/table-engines/mergetree-family/mergetree). Admite códecs de compresión de columnas y permite seleccionar el método de compresión predeterminado mediante la configuración de [compresión](/docs/es/reference/settings/server-settings/settings/other#compression).
* La familia [Log](/docs/es/reference/engines/table-engines/log-family/index). Utiliza el método de compresión `lz4` de forma predeterminada y admite códecs de compresión de columnas.
* [Set](/docs/es/reference/engines/table-engines/special/set). Solo admite la compresión predeterminada.
* [Join](/docs/es/reference/engines/table-engines/special/join). Solo admite la compresión predeterminada.
ClickHouse admite códecs de uso general y códecs especializados.
## Códecs de uso general
### NONE
`NONE` — Sin compresión.
### LZ4
`LZ4`: [algoritmo de compresión de datos](https://github.com/lz4/lz4) sin pérdida utilizado de forma predeterminada. Aplica compresión rápida mediante LZ4.
### LZ4HC
`LZ4HC[(level)]` — algoritmo LZ4 HC (alta compresión) con nivel configurable. Nivel predeterminado: 9. Si se establece `level <= 0`, se aplica el nivel predeterminado. Niveles posibles: \[1, 12]. Intervalo de niveles recomendado: \[4, 9].
### ZSTD
`ZSTD[(level)]` — [algoritmo de compresión ZSTD](https://en.wikipedia.org/wiki/Zstandard) con un `level` configurable. Niveles posibles: \[1, 22]. Nivel predeterminado: 1.
Los niveles de compresión altos son útiles en escenarios asimétricos, como cuando se comprime una vez y se descomprime repetidamente. Los niveles más altos ofrecen una mejor compresión y un mayor uso de CPU.
### ZXC
`ZXC[(level)]` — algoritmo de compresión asimétrico [`zxc`](https://github.com/hellobertrand/zxc) con `level` configurable. Niveles posibles: \[1, 7]. Nivel predeterminado: 3.
`ZXC` sacrifica velocidad de compresión a cambio de una descompresión muy rápida, con una relación de compresión entre `LZ4` y `ZSTD`. Es adecuado para el patrón de comprimir una vez y descomprimir muchas veces, y alcanza su máxima velocidad de descompresión en núcleos ARM modernos. Los niveles más altos proporcionan mejor compresión, pero más lenta, mientras que la descompresión sigue siendo rápida.
Este códec es experimental y requiere `SET allow_experimental_codecs = 1` para poder usarse.
### Obsoleto: ZSTD\_QAT
### Obsoleto: DEFLATE\_QPL
## Códecs especializados
Estos códecs están diseñados para mejorar la eficacia de la compresión aprovechando características específicas de los datos. Algunos de ellos no comprimen los datos por sí mismos, sino que los preprocesan para que una segunda etapa de compresión con un códec de uso general alcance una mayor tasa de compresión.
### Delta
`Delta(delta_bytes)` — Método de compresión en el que los valores sin procesar se sustituyen por la diferencia entre dos valores consecutivos, excepto el primero, que permanece sin cambios. `delta_bytes` es el tamaño máximo de los valores sin procesar; el valor predeterminado es `sizeof(type)`. Especificar `delta_bytes` como argumento está obsoleto y dejará de ser compatible en una versión futura. Delta es un códec de preparación de datos; es decir, no puede utilizarse de forma independiente.
### DoubleDelta
`DoubleDelta(bytes_size)` — Calcula la delta de las deltas y la escribe en formato binario compacto. `bytes_size` tiene un significado similar a `delta_bytes` en el códec [Delta](#delta). Especificar `bytes_size` como argumento está obsoleto y dejará de ser compatible en una versión futura. Se obtienen tasas de compresión óptimas con secuencias monótonas de stride constante, como los datos de series temporales. Puede usarse con cualquier tipo numérico. Implementa el algoritmo utilizado en Gorilla TSDB y lo amplía para admitir tipos de 64 bits. Usa 1 bit adicional para deltas de 32 bits: prefijos de 5 bits en lugar de prefijos de 4 bits. Para obtener más información, consulte Compressing Time Stamps en [Gorilla: A Fast, Scalable, In-Memory Time Series Database](http://www.vldb.org/pvldb/vol8/p1816-teller.pdf). DoubleDelta es un códec de preparación de datos; es decir, no puede usarse de forma independiente.
### GCD
`GCD()` - - Calcula el máximo común divisor (MCD) de los valores de la columna y luego divide cada valor por el MCD. Se puede utilizar con columnas de enteros, decimales y fecha/hora. El códec es adecuado para columnas cuyos valores cambian (aumentan o disminuyen) en múltiplos del MCD; por ejemplo, 24, 28, 16, 24, 8, 24 (MCD = 4). GCD es un códec de preparación de datos, es decir, no se puede utilizar de forma independiente.
### Gorilla
`Gorilla(bytes_size)` — Calcula el XOR entre el valor actual de punto flotante y el anterior, y lo escribe en forma binaria compacta. Cuanto menor sea la diferencia entre valores consecutivos, es decir, cuanto más lentamente cambien los valores de la serie, mejor será la tasa de compresión. Implementa el algoritmo utilizado en Gorilla TSDB y lo amplía para admitir tipos de 64 bits. Los valores posibles de `bytes_size` son 1, 2, 4 y 8; el valor predeterminado es `sizeof(type)` si equivale a 1, 2, 4 u 8. En todos los demás casos, es 1. Para obtener más información, consulte la sección 4.1 de [Gorilla: A Fast, Scalable, In-Memory Time Series Database](https://doi.org/10.14778/2824032.2824078).
### ALP
`ALP(variant)` — Compresión adaptativa sin pérdida para datos de coma flotante. Admite `Float32` y `Float64`. Para más información, consulte [ALP: Adaptive lossless floating-point compression](https://ir.cwi.nl/pub/33334).
El códec acepta un argumento de variante opcional:
* `ALP()` o `ALP(AUTO)` (predeterminado) — Usa STD y recurre a RD según el tamaño comprimido estimado.
* `ALP(STD)` — Variante estándar de ALP. Representa cada valor como un entero escalado exacto mediante potencias de diez y, a continuación, comprime los enteros resultantes con Frame-of-Reference y empaquetado de bits. Los valores que no pueden representarse se almacenan como excepciones sin procesar. Funciona mejor con números procedentes de valores decimales (p. ej., mediciones, precios).
* `ALP(RD)` — Variante Real Doubles. Reinterpreta el patrón de bits de cada valor y lo divide en una parte alta (signo + exponente + bits superiores de la mantisa) y una parte baja. Las partes altas se codifican mediante diccionario (hasta 8 entradas) y las partes bajas se empaquetan en bits. Funciona mejor cuando muchos valores comparten los mismos bits altos.
Este códec es experimental y requiere `SET allow_experimental_codecs = 1` para poder utilizarse.
### FPC
`FPC(level, float_size)` - Predice repetidamente el siguiente valor de coma flotante de la secuencia usando el mejor de dos predictores; a continuación, aplica XOR entre el valor real y el predicho y comprime el resultado mediante ceros iniciales. Al igual que Gorilla, es eficiente para almacenar una serie de valores de coma flotante que cambian lentamente. Para valores de 64 bits (double), FPC es más rápido que Gorilla; para valores de 32 bits, el rendimiento puede variar. Valores posibles de `level`: 1-28; el valor predeterminado es 12. Valores posibles de `float_size`: 4, 8; el valor predeterminado es `sizeof(type)` si el tipo es Float. En todos los demás casos, es 4. Para obtener una descripción detallada del algoritmo, consulte [High Throughput Compression of Double-Precision Floating-Point Data](https://userweb.cs.txstate.edu/~burtscher/papers/dcc07a.pdf).
### SZ3
`SZ3` o `SZ3(algorithm, error_bound_mode, error_bound)`: códec con pérdida y límite de error ([SZ3 Lossy Compressor](https://szcompressor.org/)) para columnas de tipo Float32, Float64, Array(Float32) o Array(Float64). En las columnas de arrays, la compresión es más eficaz cuando todos los arrays tienen la misma longitud (en cuyo caso se comprimen como vectores de ancho fijo); los arrays de distintas longitudes también se admiten y se comprimen como una secuencia plana de valores. El códec no se puede aplicar a columnas Map, ya que sus claves se corromperían con la compresión con pérdida. Los valores admitidos para «algorithm» son `ALGO_LORENZO_REG`, `ALGO_INTERP_LORENZO` y `ALGO_INTERP`. Los valores admitidos para «error\_bound\_mode» son `ABS`, `REL`, `PSNR` y `ABS_AND_REL`. El argumento «error\_bound» representa el error máximo y es de tipo Float64.
Este códec es experimental y requiere `SET allow_experimental_codecs = 1` para poder utilizarse.
### T64
`T64` — Método de compresión que recorta los bits altos no utilizados de los valores de tipos de datos enteros (incluidos `Enum`, `Date` y `DateTime`). En cada paso de su algoritmo, el códec toma un bloque de 64 valores, los coloca en una matriz de bits de 64x64, la transpone, recorta los bits no utilizados de los valores y devuelve el resto como una secuencia. Los bits no utilizados son aquellos que no difieren entre los valores máximo y mínimo de toda la parte de datos para la que se utiliza la compresión.
Los códecs `DoubleDelta` y `Gorilla` se utilizan en Gorilla TSDB como componentes de su algoritmo de compresión. El método Gorilla es eficaz cuando hay una secuencia de valores que cambian lentamente junto con sus marcas de tiempo. Las marcas de tiempo se comprimen eficazmente con el códec `DoubleDelta` y los valores, con el códec `Gorilla`. Por ejemplo, para almacenar una tabla de forma eficiente, puede crearla con la siguiente configuración:
```sql theme={null}
CREATE TABLE codec_example
(
timestamp DateTime CODEC(DoubleDelta),
slow_values Float32 CODEC(Gorilla)
)
ENGINE = MergeTree()
```
### Quantized
`Quantized(method, dimensions[, ...])` — Un códec especializado para admitir la búsqueda vectorial aproximada en columnas de tipo `Array(Float32)`, `Array(Float64)` o `Array(BFloat16)`.
Almacena los vectores originales de precisión completa, junto con un *código cuantizado* compacto por vector.
En las tablas de la familia `MergeTree`, las consultas de búsqueda vectorial que usan la configuración [`vector_search_use_quantized_codes`](/docs/es/reference/settings/session-settings/vector-search#vector_search_use_quantized_codes) exploran los códigos cuantizados para crear una lista reducida y, posteriormente, recalculan la puntuación de los resultados con los vectores de precisión completa.
Esta búsqueda en dos fases lee menos bytes que un escaneo normal con precisión completa, a costa de una menor exhaustividad.
`dimensions` es la longitud del vector; los valores admitidos para `method` son `rabitq`, `turboquant`, `int8`, `prefix` y `product`, cada uno con una combinación distinta de tamaño, exactitud y función de distancia.
El códec solo se puede establecer en `CREATE TABLE`; no se puede añadir, eliminar ni cambiar mediante `ALTER TABLE`, ni siquiera con `ADD COLUMN ... CODEC(Quantized(...))`.
No se puede encadenar con ningún otro códec (ni siquiera con un códec de cifrado como `AES_128_GCM_SIV`).
Para obtener más información, consulte [Búsqueda vectorial con códecs cuantizados](/docs/es/reference/engines/table-engines/mergetree-family/annindexes#vector-search-with-quantized-codecs).
```sql theme={null}
SET allow_experimental_codecs = 1;
CREATE TABLE vectors
(
id UInt32,
vec Array(BFloat16) CODEC(Quantized('rabitq', 1536))
)
ENGINE = MergeTree ORDER BY id;
```
## Códecs de cifrado
Estos códecs no comprimen los datos, sino que los cifran en disco. Solo están disponibles cuando se especifica una clave de cifrado en la configuración de [encryption](/docs/es/reference/settings/server-settings/settings/other#encryption). Tenga en cuenta que el cifrado solo tiene sentido al final de las canalizaciones de códecs, ya que los datos cifrados normalmente no se pueden comprimir de forma significativa.
Códecs de cifrado:
### AES\_128\_GCM\_SIV
`CODEC('AES-128-GCM-SIV')` — Cifra los datos con AES-128 en el modo GCM-SIV definido en la [RFC 8452](https://tools.ietf.org/html/rfc8452).
### AES-256-GCM-SIV
`CODEC('AES-256-GCM-SIV')` — Cifra datos con AES-256 en modo GCM-SIV.
Estos códecs utilizan un nonce fijo, por lo que el cifrado es determinista. Esto los hace compatibles con motores que realizan deduplicación, como [ReplicatedMergeTree](/docs/es/reference/engines/table-engines/mergetree-family/replication), pero presenta una debilidad: si el mismo bloque de datos se cifra dos veces, el texto cifrado resultante será exactamente el mismo, de modo que un adversario que pueda leer el disco podrá detectar esta equivalencia (aunque solo la equivalencia, sin acceder al contenido).
La mayoría de los motores, incluida la familia "\*MergeTree", crean archivos de índice en disco sin aplicar códecs. Esto significa que habrá texto sin cifrar en el disco si se indexa una columna cifrada.
Si ejecuta una consulta SELECT que menciona un valor específico en una columna cifrada (por ejemplo, en su cláusula WHERE), el valor puede aparecer en [system.query\_log](/docs/es/reference/system-tables/query_log). Puede que le convenga desactivar el registro.
**Ejemplo**
```sql theme={null}
CREATE TABLE mytable
(
x String CODEC(AES_128_GCM_SIV)
)
ENGINE = MergeTree ORDER BY x;
```
Si se necesita aplicar compresión, debe especificarse explícitamente. De lo contrario, los datos solo se cifrarán.
**Ejemplo**
```sql theme={null}
CREATE TABLE mytable
(
x String CODEC(Delta, LZ4, AES_128_GCM_SIV)
)
ENGINE = MergeTree ORDER BY x;
```
## Selección adaptativa de códecs
Los códecs especializados anteriores pueden reducir drásticamente el tamaño de los datos adecuados, pero elegirlos requiere experiencia, y ninguna opción única se adapta a una columna cuyos datos cambian con el tiempo. Con la configuración de MergeTree [`allow_experimental_adaptive_codec_selection`](/docs/es/reference/settings/merge-tree-settings) habilitada, ClickHouse elige por usted. Para las columnas que usan el códec predeterminado (`CODEC(Default)` o ningún `CODEC`), cada bloque se escribe con el códec que permite comprimirlo al menor tamaño, elegido entre el códec predeterminado de la tabla, `NONE` y los códecs especializados adecuados para el tipo de columna.
Un bloque nunca ocupa más espacio que con el códec predeterminado, y los datos incompresibles se almacenan sin procesar (comprimirlos produciría un archivo ligeramente más grande y más lento de leer). El trabajo se realiza en segundo plano, durante las combinaciones y mutaciones, cuando los datos se recomprimen de todos modos. La velocidad de inserción no se ve afectada. Las consultas suelen ser más rápidas: se recuperan menos datos del disco, cada bloque que lee una consulta debe descomprimirse primero y los códecs especializados se descomprimen más rápido que el `LZ4` predeterminado. Cada bloque registra el códec con el que se escribió, por lo que la lectura no requiere ninguna configuración, y la funcionalidad puede desactivarse en cualquier momento sin que los datos dejen de ser legibles.
```sql theme={null}
CREATE TABLE adaptive
(
time DateTime,
user_id UInt64
)
ENGINE = MergeTree
ORDER BY time
SETTINGS allow_experimental_adaptive_codec_selection = 1;
INSERT INTO adaptive SELECT toDateTime('2026-01-01') + number, cityHash64(number) FROM numbers(1000000);
OPTIMIZE TABLE adaptive FINAL;
```
Puedes comprobar cómo funciona con la función de tabla [`mergeTreeCodecBlockCounts`](/docs/es/reference/functions/table-functions/mergeTreeCodecBlockCounts). Aquí, `time` aumenta de forma constante, por lo que `T64`, que almacena solo los bits que varían dentro de un bloque, superó al códec predeterminado en todos los bloques. `user_id` contiene hashes que ningún códec puede comprimir, por lo que sus bloques se almacenaron sin procesar:
```sql theme={null}
SELECT column, codec_block_counts FROM mergeTreeCodecBlockCounts(currentDatabase(), 'adaptive');
```
```text theme={null}
┌─column──┬─codec_block_counts─┐
1. │ time │ {'T64':62} │
2. │ user_id │ {'NONE':123} │
└─────────┴────────────────────┘
```
Actualmente, la selección abarca columnas de tipo entero: enteros, enumeraciones, fechas y horas, `Decimal32`/`Decimal64` e `IPv4`.
## Contenido relacionado
* Blog: [Optimización de ClickHouse con esquemas y códecs](https://clickhouse.com/blog/optimize-clickhouse-codecs-compression-schema)
* Blog: [Uso de datos de series temporales en ClickHouse](https://clickhouse.com/blog/working-with-time-series-data-and-functions-ClickHouse)