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

> Documentación de TABLE

# CREATE TABLE

export const ExperimentalBadge = () => {
  return <div className="experimentalBadge">
            <div className="experimentalIcon">
            <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
                <path strokeWidth="1.25" d="M5.5 2H10.5" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
                <path strokeWidth="1.25" d="M9.50015 2V6.19625L13.4283 12.7425C13.4738 12.8183 13.4985 12.9049 13.4996 12.9934C13.5008 13.0818 13.4785 13.169 13.435 13.246C13.3914 13.323 13.3283 13.3871 13.2519 13.4317C13.1755 13.4764 13.0886 13.4999 13.0002 13.5H3.00015C2.91164 13.5 2.8247 13.4766 2.74822 13.432C2.67174 13.3874 2.60847 13.3233 2.56487 13.2463C2.52126 13.1693 2.49889 13.082 2.50004 12.9935C2.50119 12.905 2.52582 12.8184 2.5714 12.7425L6.50015 6.19625V2" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
                <path strokeWidth="1.25" d="M4.47656 9.56754C5.30344 9.41254 6.47656 9.47942 7.99969 10.25C10.0153 11.2707 11.4216 11.0569 12.2184 10.7282" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
            </svg>
        </div>
            Experimental feature. <u><a href="/docs/beta-and-experimental-features#experimental-features">Learn more.</a></u>
        </div>;
};

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>;
};

Crea una tabla nueva. Esta consulta puede tener varias formas sintácticas según el caso de uso.

De forma predeterminada, las tablas se crean solo en el servidor actual. Las consultas DDL distribuidas se implementan mediante la cláusula `ON CLUSTER`, que se [describe por separado](/es/reference/statements/distributed-ddl).

<div id="syntax-forms">
  ## Variantes de sintaxis
</div>

<div id="with-explicit-schema">
  ### Con esquema explícito
</div>

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
    name1 [type1] [NULL|NOT NULL] [DEFAULT|MATERIALIZED|EPHEMERAL|ALIAS expr1] [COMMENT 'comment for column'] [compression_codec] [TTL expr1],
    name2 [type2] [NULL|NOT NULL] [DEFAULT|MATERIALIZED|EPHEMERAL|ALIAS expr2] [COMMENT 'comment for column'] [compression_codec] [TTL expr2],
    ...
) ENGINE = engine
  [COMMENT 'comment for table']
```

Crea una tabla llamada `table_name` en la base de datos `db` o en la base de datos actual si no se ha definido `db`, con la estructura especificada entre corchetes y el motor `engine`.
La estructura de la tabla es una lista de descripciones de columnas, índices secundarios, proyecciones y restricciones. Si el motor admite [clave primaria](#primary-key), esta se indicará como parámetro del motor de tabla.

Una descripción de columna es `name type` en el caso más simple. Ejemplo: `RegionID UInt32`.

También se pueden definir expresiones para los valores predeterminados (véase más abajo).

Si es necesario, se puede especificar la clave primaria, con una o más expresiones de clave.

Se pueden añadir comentarios a las columnas y a la tabla.

<div id="with-a-schema-similar-to-other-table">
  ### Con el esquema de una tabla existente
</div>

ClickHouse permite copiar el esquema y los datos de una tabla existente.

Para replicar el esquema de una tabla existente:

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db2.]table_clone AS [db.]table [ENGINE = engine]
```

Esto crea una tabla con la misma estructura que otra.

<div id="with-a-schema-and-data-cloned-from-another-table">
  ### Con el esquema y los datos de una tabla existente
</div>

Para replicar el esquema y los datos de una tabla existente:

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db2.]table_clone CLONE AS [db.]table [ENGINE = engine]
```

Esto crea una tabla con el mismo esquema y los mismos datos que una tabla existente.  Una vez creada la nueva tabla, se le adjuntan todas las particiones de `db.table`. En otras palabras, los datos de `db.table` se clonan en `db2.table_clone` en el momento de su creación. Esta consulta es equivalente a la siguiente:

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db2.]table_clone AS [db.]table [ENGINE = engine];
ALTER TABLE [db2.]table_clone ATTACH PARTITION ALL FROM [db.]table;
```

Para ambas funcionalidades, puede especificar un motor diferente para la tabla. Si no se especifica el motor, se usará el mismo motor que para la tabla original (`db.table`).

<div id="from-a-table-function">
  ### A partir de una función de tabla
</div>

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name AS table_function()
```

Crea una tabla con el mismo resultado que la [función de tabla](/es/reference/functions/table-functions) especificada. La tabla creada también funcionará del mismo modo que la función de tabla correspondiente que se haya especificado.

<div id="from-select-query">
  ### A partir de una consulta SELECT
</div>

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name[(name1 [type1], name2 [type2], ...)] ENGINE = engine AS SELECT ...
```

Crea una tabla con una estructura similar al resultado de la consulta `SELECT`, usa el motor `engine` y la rellena con datos de `SELECT`. También puede especificar explícitamente la definición de las columnas.

Si la tabla ya existe y se especifica `IF NOT EXISTS`, la consulta no hará nada.

Puede haber otras cláusulas después de la cláusula `ENGINE` en la consulta. Consulte la documentación detallada sobre cómo crear tablas en las descripciones de los [motores de tabla](/es/reference/engines/table-engines).

**Ejemplo**

```sql title="Query" theme={null}
CREATE TABLE t1 (x String) ENGINE = Memory AS SELECT 1;
SELECT x, toTypeName(x) FROM t1;
```

```text title="Response" theme={null}
┌─x─┬─toTypeName(x)─┐
│ 1 │ String        │
└───┴───────────────┘
```

<div id="null-or-not-null-modifiers">
  ## Modificadores `NULL` o `NOT NULL`
</div>

Los modificadores `NULL` y `NOT NULL` después del tipo de dato en la definición de una columna permiten o impiden que sea [Nullable](/es/reference/data-types/nullable).

Si el tipo no es `Nullable` y se especifica `NULL`, se tratará como `Nullable`; si se especifica `NOT NULL`, no. Por ejemplo, `INT NULL` es equivalente a `Nullable(INT)`. Si el tipo es `Nullable` y se especifican los modificadores `NULL` o `NOT NULL`, se generará una excepción.

Véase también la opción de configuración [data\_type\_default\_nullable](/es/reference/settings/session-settings#data_type_default_nullable).

<div id="default_values">
  ## Valores predeterminados
</div>

La descripción de la columna puede especificar una expresión de valor predeterminado en la forma `DEFAULT expr`, `MATERIALIZED expr` o `ALIAS expr`. Ejemplo: `URLDomain String DEFAULT domain(URL)`.

La expresión `expr` es opcional. Si se omite, el tipo de la columna debe especificarse explícitamente y el valor predeterminado será `0` para las columnas numéricas, `''` (la cadena vacía) para las columnas String, `[]` (el Array vacío) para las columnas Array, `1970-01-01` para las columnas de fecha o `NULL` para las columnas Nullable.

El tipo de la columna con valor predeterminado puede omitirse, en cuyo caso se infiere a partir del tipo de `expr`. Por ejemplo, el tipo de la columna `EventDate DEFAULT toDate(EventTime)` será date.

Si se especifican tanto un tipo de dato como una expresión de valor predeterminado, se inserta una función implícita de conversión de tipos que convierte la expresión al tipo especificado. Ejemplo: `Hits UInt32 DEFAULT 0` se representa internamente como `Hits UInt32 DEFAULT toUInt32(0)`.

Una expresión de valor predeterminado `expr` puede hacer referencia a columnas de tabla arbitrarias y constantes. ClickHouse comprueba que los cambios en la estructura de la tabla no introduzcan bucles en el cálculo de la expresión. Para INSERT, comprueba que las expresiones puedan resolverse; es decir, que se hayan pasado todas las columnas a partir de las cuales pueden calcularse.

<div id="default">
  ### DEFAULT
</div>

`DEFAULT expr`

Valor predeterminado normal. Si no se especifica el valor de una columna de este tipo en una consulta INSERT, se calcula a partir de `expr`.

Ejemplo:

```sql theme={null}
CREATE OR REPLACE TABLE test
(
    id UInt64,
    updated_at DateTime DEFAULT now(),
    updated_at_date Date DEFAULT toDate(updated_at)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test (id) VALUES (1);

SELECT * FROM test;
┌─id─┬──────────updated_at─┬─updated_at_date─┐
│  1 │ 2023-02-24 17:06:46 │      2023-02-24 │
└────┴─────────────────────┴─────────────────┘
```

<div id="materialized">
  ### MATERIALIZED
</div>

`MATERIALIZED expr`

Expresión materializada. Los valores de estas columnas se calculan automáticamente según la expresión materializada especificada cuando se insertan filas. Los valores no pueden especificarse explícitamente durante los `INSERT`.

Además, las columnas con valor predeterminado de este tipo no se incluyen en el resultado de `SELECT *`. Esto preserva el invariante de que el resultado de un `SELECT *` siempre puede volver a insertarse en la tabla mediante `INSERT`. Este comportamiento puede deshabilitarse con la configuración `asterisk_include_materialized_columns`.

Ejemplo:

```sql theme={null}
CREATE OR REPLACE TABLE test
(
    id UInt64,
    updated_at DateTime MATERIALIZED now(),
    updated_at_date Date MATERIALIZED toDate(updated_at)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1);

SELECT * FROM test;
┌─id─┐
│  1 │
└────┘

SELECT id, updated_at, updated_at_date FROM test;
┌─id─┬──────────updated_at─┬─updated_at_date─┐
│  1 │ 2023-02-24 17:08:08 │      2023-02-24 │
└────┴─────────────────────┴─────────────────┘

SELECT * FROM test SETTINGS asterisk_include_materialized_columns=1;
┌─id─┬──────────updated_at─┬─updated_at_date─┐
│  1 │ 2023-02-24 17:08:08 │      2023-02-24 │
└────┴─────────────────────┴─────────────────┘
```

<div id="ephemeral">
  ### EPHEMERAL
</div>

`EPHEMERAL [expr]`

Columna efímera. Las columnas de este tipo no se almacenan en la tabla y no es posible hacer `SELECT` de ellas. El único propósito de las columnas efímeras es utilizarlas para construir expresiones de valor predeterminado para otras columnas.

Una inserción sin columnas especificadas explícitamente omitirá las columnas de este tipo. Esto preserva la invariante de que el resultado de un `SELECT *` siempre puede volver a insertarse en la tabla mediante `INSERT`.

Ejemplo:

```sql theme={null}
CREATE OR REPLACE TABLE test
(
    id UInt64,
    unhexed String EPHEMERAL,
    hexed FixedString(4) DEFAULT unhex(unhexed)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test (id, unhexed) VALUES (1, '5a90b714');

SELECT
    id,
    hexed,
    hex(hexed)
FROM test
FORMAT Vertical;

Row 1:
──────
id:         1
hexed:      Z��
hex(hexed): 5A90B714
```

<div id="alias">
  ### ALIAS
</div>

`ALIAS expr`

Columnas calculadas (sinónimo). Las columnas de este tipo no se almacenan en la tabla y no es posible insertar valores en ellas con `INSERT`.

Cuando las consultas `SELECT` hacen referencia explícita a columnas de este tipo, el valor se calcula en el momento de la consulta a partir de `expr`. De forma predeterminada, `SELECT *` excluye las columnas ALIAS. Este comportamiento se puede desactivar con el ajuste `asterisk_include_alias_columns`.

Al usar la consulta `ALTER` para añadir columnas nuevas, no se escriben los datos antiguos de esas columnas. En su lugar, al leer datos antiguos que no tienen valores para las columnas nuevas, las expresiones se calculan sobre la marcha de forma predeterminada. Sin embargo, si para ejecutar las expresiones se necesitan otras columnas que no se indican en la consulta, esas columnas también se leerán, pero solo para los bloques de datos que lo requieran.

Si añade una nueva columna a una tabla pero más tarde cambia su expresión por defecto, los valores usados para los datos antiguos cambiarán (para los datos cuyos valores no se almacenaron en disco). Tenga en cuenta que, al ejecutar fusiones en segundo plano, los datos de las columnas que faltan en una de las partes que se están fusionando se escriben en la parte fusionada.

No es posible establecer valores predeterminados para elementos de estructuras de datos anidadas.

```sql theme={null}
CREATE OR REPLACE TABLE test
(
    id UInt64,
    size_bytes Int64,
    size String ALIAS formatReadableSize(size_bytes)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, 4678899);

SELECT id, size_bytes, size FROM test;
┌─id─┬─size_bytes─┬─size─────┐
│  1 │    4678899 │ 4.46 MiB │
└────┴────────────┴──────────┘

SELECT * FROM test SETTINGS asterisk_include_alias_columns=1;
┌─id─┬─size_bytes─┬─size─────┐
│  1 │    4678899 │ 4.46 MiB │
└────┴────────────┴──────────┘
```

<div id="primary-key">
  ## Clave primaria
</div>

Puede definir una [clave primaria](/es/reference/engines/table-engines/mergetree-family/mergetree#primary-keys-and-indexes-in-queries) al crear una tabla. La clave primaria se puede especificar de dos maneras:

* En la lista de columnas

```sql theme={null}
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...,
    PRIMARY KEY(expr1[, expr2,...])
)
ENGINE = engine;
```

* Fuera de la lista de columnas

```sql theme={null}
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...
)
ENGINE = engine
PRIMARY KEY(expr1[, expr2,...]);
```

<Tip>
  No se pueden combinar ambas formas en una sola consulta.
</Tip>

<div id="constraints">
  ## Restricciones
</div>

Además de las descripciones de las columnas, se pueden definir restricciones:

<div id="constraint">
  ### CONSTRAINT
</div>

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
    name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [compression_codec] [TTL expr1],
    ...
    CONSTRAINT constraint_name_1 CHECK boolean_expr_1,
    ...
) ENGINE = engine
```

`boolean_expr_1` puede ser cualquier expresión booleana. Si se definen restricciones para la tabla, cada una de ellas se comprobará en cada fila de la consulta `INSERT`. Si alguna restricción no se cumple, el servidor lanzará una excepción con el nombre de la restricción y la expresión de comprobación.

Añadir una gran cantidad de restricciones puede afectar negativamente al rendimiento de consultas `INSERT` grandes.

<div id="assume">
  ### ASSUME
</div>

La cláusula `ASSUME` se utiliza para definir una `CONSTRAINT` sobre una tabla que se asume verdadera. Esta restricción puede ser utilizada posteriormente por el optimizador para mejorar el rendimiento de las consultas SQL.

Veamos este ejemplo en el que `ASSUME CONSTRAINT` se usa al crear la tabla `users_a`:

```sql theme={null}
CREATE TABLE users_a (
    uid Int16, 
    name String, 
    age Int16, 
    name_len UInt8 MATERIALIZED length(name), 
    CONSTRAINT c1 ASSUME length(name) = name_len
) 
ENGINE=MergeTree 
ORDER BY (name_len, name);
```

Aquí, `ASSUME CONSTRAINT` se usa para indicar que la función `length(name)` siempre es igual al valor de la columna `name_len`. Esto significa que, cada vez que se llama a `length(name)` en una consulta, ClickHouse puede sustituirla por `name_len`, lo que debería ser más rápido porque evita llamar a la función `length()`.

Luego, al ejecutar la consulta `SELECT name FROM users_a WHERE length(name) < 5;`, ClickHouse puede optimizarla como `SELECT name FROM users_a WHERE name_len < 5`; gracias a `ASSUME CONSTRAINT`. Esto puede hacer que la consulta se ejecute más rápido porque evita calcular la longitud de `name` para cada fila.

`ASSUME CONSTRAINT` **no impone la restricción**, simplemente informa al optimizador de que la restricción se cumple. Si la restricción en realidad no es cierta, los resultados de las consultas pueden ser incorrectos. Por lo tanto, solo debes usar `ASSUME CONSTRAINT` si estás seguro de que la restricción es cierta.

<div id="ttl-expression">
  ## Expresión TTL
</div>

Define el tiempo de almacenamiento de los valores. Solo se puede especificar para tablas de la familia MergeTree. Para obtener una descripción detallada, consulte [TTL para columnas y tablas](/es/reference/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-ttl).

<div id="column_compression_codec">
  ## Códecs de compresión de columnas
</div>

De forma predeterminada, ClickHouse aplica la compresión `lz4` en la versión autogestionada y `zstd` en ClickHouse Cloud.

En la familia de motores `MergeTree`, puede cambiar el método de compresión predeterminado en la sección [compression](/es/reference/settings/server-settings/settings#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`.

```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 = <Engine>
...
```

El códec `Default` puede especificarse para hacer referencia a la compresión predeterminada, que en tiempo de ejecución puede depender de distintos ajustes (y de las propiedades de los datos).
Ejemplo: `value UInt64 CODEC(Default)` — equivale a no especificar ningún códec.

También puede quitar 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 pueden combinarse en una pipeline; por ejemplo, `CODEC(Delta, Default)`.

<Tip>
  No es posible descomprimir archivos de bases de datos de ClickHouse con utilidades externas como `lz4`. En su lugar, usa la utilidad especial [clickhouse-compressor](https://github.com/ClickHouse/ClickHouse/tree/master/programs/compressor).
</Tip>

Se admite compresión en los siguientes motores de tabla:

* Familia [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree). Admite códecs de compresión por columna y la selección del método de compresión predeterminado mediante la configuración de [compression](/es/reference/settings/server-settings/settings#compression).
* Familia [Log](/es/reference/engines/table-engines/log-family). Usa el método de compresión `lz4` de forma predeterminada y admite códecs de compresión por columna.
* [Set](/es/reference/engines/table-engines/special/set). Solo admite la compresión predeterminada.
* [Join](/es/reference/engines/table-engines/special/join). Solo admite la compresión predeterminada.

ClickHouse admite códecs de propósito general y códecs especializados.

<div id="general-purpose-codecs">
  ### Códecs de uso general
</div>

<div id="none">
  #### NONE
</div>

`NONE` — Sin compresión.

<div id="lz4">
  #### LZ4
</div>

`LZ4` — Algoritmo de [compresión de datos](https://github.com/lz4/lz4) sin pérdida usado de forma predeterminada. Utiliza la compresión rápida LZ4.

<div id="lz4hc">
  #### LZ4HC
</div>

`LZ4HC[(level)]` — algoritmo LZ4 HC (alta compresión) con un nivel configurable. Nivel predeterminado: 9. La opción `level <= 0` aplica el nivel predeterminado. Niveles posibles: \[1, 12]. Rango de niveles recomendado: \[4, 9].

<div id="zstd">
  #### ZSTD
</div>

`ZSTD[(level)]` — [algoritmo de compresión ZSTD](https://en.wikipedia.org/wiki/Zstandard) con `level` configurable. Niveles posibles: \[1, 22]. Nivel predeterminado: 1.

Los niveles de compresión altos son útiles en escenarios asimétricos, como comprimir una vez y descomprimir repetidamente. Los niveles más altos implican una mejor compresión y un mayor uso de CPU.

<div id="zstd_qat">
  #### Obsoleto: ZSTD\_QAT
</div>

<div id="deflate_qpl">
  #### Obsoleto: DEFLATE\_QPL
</div>

<div id="specialized-codecs">
  ### Códecs especializados
</div>

Estos códecs están diseñados para hacer que la compresión sea más eficaz aprovechando características específicas de los datos. Algunos de estos códecs no comprimen los datos por sí mismos, sino que los preprocesan para que una segunda etapa de compresión con un códec de propósito general pueda alcanzar una mayor tasa de compresión.

<div id="delta">
  #### Delta
</div>

`Delta(delta_bytes)` — Método de compresión en el que los valores originales se sustituyen por la diferencia entre dos valores adyacentes, excepto el primero, que permanece sin cambios. `delta_bytes` es el tamaño máximo de los valores originales; el valor predeterminado es `sizeof(type)`. Especificar `delta_bytes` como argumento está obsoleto y la compatibilidad se eliminará en una versión futura. Delta es un códec de preparación de datos, es decir, no puede usarse por sí solo.

<div id="doubledelta">
  #### DoubleDelta
</div>

`DoubleDelta(bytes_size)` — Calcula el delta de los deltas y lo escribe en formato binario compacto. `bytes_size` tiene un significado similar al de `delta_bytes` en el códec [Delta](#delta). Especificar `bytes_size` como argumento está obsoleto y esta compatibilidad se eliminará en una versión futura. Se obtienen tasas de compresión óptimas para secuencias monótonas con un paso 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 por sí solo.

<div id="gcd">
  #### GCD
</div>

`GCD()` - - Calcula el máximo común divisor (GCD) de los valores de la columna y, a continuación, divide cada valor por el GCD. Puede usarse con columnas de enteros, decimales y fecha/hora. El códec es especialmente adecuado para columnas con valores que cambian (aumentan o disminuyen) en múltiplos del GCD, p. ej., 24, 28, 16, 24, 8, 24 (GCD = 4). GCD es un códec de preparación de datos, es decir, no puede usarse por sí solo.

<div id="gorilla">
  #### Gorilla
</div>

`Gorilla(bytes_size)` — Calcula el XOR entre el valor actual y el valor anterior de coma flotante, y lo escribe en formato binario compacto. Cuanto menor sea la diferencia entre valores consecutivos, es decir, cuanto más lentamente cambien los valores de la serie temporal, 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, 8; el valor predeterminado es `sizeof(type)` si es igual 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).

<div id="alp">
  #### ALP
</div>

`ALP()` — Compresión adaptativa sin pérdidas para datos de coma flotante basada en el escalado decimal. ALP intenta representar 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 exactamente se almacenan como excepciones en bruto. Funciona mejor con números derivados de valores decimales (p. ej., mediciones, moneda). Es compatible con `Float32` y `Float64`. Para obtener más información, consulte [ALP: Adaptive lossless floating-point compression](https://ir.cwi.nl/pub/33334).

<Note>
  Este códec es experimental y requiere `SET allow_experimental_codecs = 1` para poder utilizarse.
</Note>

<div id="fpc">
  #### FPC
</div>

`FPC(level, float_size)` - Predice repetidamente el siguiente valor de coma flotante de la secuencia usando el mejor de dos predictores; luego aplica XOR entre el valor real y el valor predicho, y comprime el resultado suprimiendo los 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. Posibles valores de `level`: 1-28; el valor predeterminado es 12. Posibles valores 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).

<div id="t64">
  #### T64
</div>

`T64` — Enfoque de compresión que recorta los bits altos no utilizados de los valores en 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 64x64 bits, la transpone, recorta los bits no utilizados de los valores y devuelve el resto como una secuencia. Los bits no utilizados son los bits que no difieren entre los valores máximo y mínimo en toda la parte de datos para la que se usa la compresión.

Los códecs `DoubleDelta` y `Gorilla` se usan en Gorilla TSDB como componentes de su algoritmo de compresión. El enfoque de Gorilla es eficaz en escenarios en los que 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 se comprimen eficazmente con el códec `Gorilla`. Por ejemplo, para obtener una tabla almacenada 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()
```

<div id="encryption-codecs">
  ### Códecs de cifrado
</div>

En realidad, estos códecs no comprimen los datos, sino que los cifran en disco. Solo están disponibles cuando se especifica una clave de cifrado mediante la configuración de [encryption](/es/reference/settings/server-settings/settings#encryption). Tenga en cuenta que el cifrado solo tiene sentido al final de las canalizaciones de códecs, porque, por lo general, los datos cifrados no pueden comprimirse de forma significativa.

Códecs de cifrado:

<div id="aes_128_gcm_siv">
  #### AES\_128\_GCM\_SIV
</div>

`CODEC('AES-128-GCM-SIV')` — Cifra los datos con AES-128 en modo GCM-SIV según [RFC 8452](https://tools.ietf.org/html/rfc8452).

<div id="aes-256-gcm-siv">
  #### AES-256-GCM-SIV
</div>

`CODEC('AES-256-GCM-SIV')` — Cifra los datos con AES-256 en modo GCM-SIV.

Estos códecs usan un nonce fijo y, por lo tanto, el cifrado es determinista. Esto los hace compatibles con motores con deduplicación, como [ReplicatedMergeTree](/es/reference/engines/table-engines/mergetree-family/replication), pero tiene una debilidad: cuando el mismo bloque de datos se cifra dos veces, el texto cifrado resultante será exactamente el mismo, por lo que un adversario que pueda leer el disco podrá detectar esta equivalencia (aunque solo la equivalencia, sin obtener su contenido).

<Note>
  La mayoría de los motores, incluida la familia "\*MergeTree", crean archivos de índice en disco sin aplicar códecs. Esto significa que el texto en claro aparecerá en disco si se indexa una columna cifrada.
</Note>

<Note>
  Si realiza una consulta SELECT que menciona un valor específico en una columna cifrada (como en su cláusula WHERE), el valor puede aparecer en [system.query\_log](/es/reference/system-tables/query_log). Puede que le convenga deshabilitar el registro.
</Note>

**Ejemplo**

```sql theme={null}
CREATE TABLE mytable
(
    x String CODEC(AES_128_GCM_SIV)
)
ENGINE = MergeTree ORDER BY x;
```

<Note>
  Si es necesario aplicar compresión, debe especificarse explícitamente. De lo contrario, solo se aplicará cifrado a los datos.
</Note>

**Ejemplo**

```sql theme={null}
CREATE TABLE mytable
(
    x String CODEC(Delta, LZ4, AES_128_GCM_SIV)
)
ENGINE = MergeTree ORDER BY x;
```

<div id="temporary-tables">
  ## Tablas temporales
</div>

<Note>
  Tenga en cuenta que las tablas temporales no están replicadas. Como resultado, no hay garantía de que los datos insertados en una tabla temporal estén disponibles en otras réplicas. El caso de uso principal en el que las tablas temporales pueden resultar útiles es para consultar o combinar pequeños conjuntos de datos externos durante una sola sesión.
</Note>

ClickHouse admite tablas temporales con las siguientes características:

* Las tablas temporales desaparecen al finalizar la sesión, incluso si se pierde la conexión.
* Una tabla temporal usa el motor de tabla Memory cuando no se especifica ningún motor, y puede usar cualquier motor de tabla excepto los motores Replicated y `KeeperMap`.
* No se puede especificar la DB para una tabla temporal. Se crea fuera de las bases de datos.
* No es posible crear una tabla temporal con una consulta DDL distribuida en todos los servidores del clúster (usando `ON CLUSTER`): esta tabla solo existe en la sesión actual.
* Si una tabla temporal tiene el mismo nombre que otra y una consulta especifica el nombre de la tabla sin especificar la DB, se usará la tabla temporal.
* Para el procesamiento distribuido de consultas, las tablas temporales con motor Memory usadas en una consulta se pasan a los servidores remotos.

Para crear una tabla temporal, use la siguiente sintaxis:

```sql theme={null}
CREATE [OR REPLACE] TEMPORARY TABLE [IF NOT EXISTS] table_name
(
    name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1],
    name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2],
    ...
) [ENGINE = engine]
```

En la mayoría de los casos, las tablas temporales no se crean manualmente, sino que se crean al usar datos externos para una consulta o para `(GLOBAL) IN` distribuido. Para obtener más información, consulte las secciones correspondientes

Es posible usar tablas con [ENGINE = Memory](/es/reference/engines/table-engines/special/memory) en lugar de tablas temporales.

<div id="replace-table">
  ## REPLACE TABLE
</div>

La sentencia `REPLACE` permite actualizar una tabla [de forma atómica](/es/concepts/core-concepts/glossary#atomicity).

<Note>
  Esta sentencia es compatible con los motores de base de datos [`Atomic`](/es/reference/engines/database-engines/atomic) y [`Replicated`](/es/reference/engines/database-engines/replicated),
  que son los motores de base de datos predeterminados de ClickHouse y ClickHouse Cloud, respectivamente.
</Note>

Normalmente, si necesita eliminar algunos datos de una tabla,
puede crear una tabla nueva y llenarla con una sentencia `SELECT` que no recupere los datos no deseados;
después, eliminar la tabla antigua y cambiar el nombre de la nueva.
Este enfoque se muestra en el ejemplo siguiente:

```sql theme={null}
CREATE TABLE myNewTable AS myOldTable;

INSERT INTO myNewTable
SELECT * FROM myOldTable 
WHERE CounterID <12345;

DROP TABLE myOldTable;

RENAME TABLE myNewTable TO myOldTable;
```

En lugar del enfoque anterior, también es posible usar `REPLACE` (si se usan los motores de base de datos predeterminados) para obtener el mismo resultado:

```sql theme={null}
REPLACE TABLE myOldTable
ENGINE = MergeTree()
ORDER BY CounterID 
AS
SELECT * FROM myOldTable
WHERE CounterID <12345;
```

<div id="syntax">
  ### Sintaxis
</div>

```sql theme={null}
{CREATE [OR REPLACE] | REPLACE} TABLE [db.]table_name
```

<Note>
  Todas las formas sintácticas de la sentencia `CREATE` también sirven para esta sentencia. Invocar `REPLACE` sobre una tabla inexistente provocará un error.
</Note>

<div id="examples">
  ### Ejemplos:
</div>

<Tabs>
  <Tab title="Local">
    Considere la siguiente tabla:

    ```sql theme={null}
    CREATE DATABASE base 
    ENGINE = Atomic;

    CREATE OR REPLACE TABLE base.t1
    (
        n UInt64,
        s String
    )
    ENGINE = MergeTree
    ORDER BY n;

    INSERT INTO base.t1 VALUES (1, 'test');

    SELECT * FROM base.t1;

    ┌─n─┬─s────┐
    │ 1 │ test │
    └───┴──────┘
    ```

    Podemos usar la sentencia `REPLACE` para vaciar todos los datos:

    ```sql theme={null}
    CREATE OR REPLACE TABLE base.t1 
    (
        n UInt64,
        s Nullable(String)
    )
    ENGINE = MergeTree
    ORDER BY n;

    INSERT INTO base.t1 VALUES (2, null);

    SELECT * FROM base.t1;

    ┌─n─┬─s──┐
    │ 2 │ \N │
    └───┴────┘
    ```

    O bien podemos usar la sentencia `REPLACE` para cambiar la estructura de la tabla:

    ```sql theme={null}
    REPLACE TABLE base.t1 (n UInt64) 
    ENGINE = MergeTree 
    ORDER BY n;

    INSERT INTO base.t1 VALUES (3);

    SELECT * FROM base.t1;

    ┌─n─┐
    │ 3 │
    └───┘
    ```
  </Tab>

  <Tab title="Cloud">
    Considere la siguiente tabla en ClickHouse Cloud:

    ```sql theme={null}
    CREATE DATABASE base;

    CREATE OR REPLACE TABLE base.t1 
    (
        n UInt64,
        s String
    )
    ENGINE = MergeTree
    ORDER BY n;

    INSERT INTO base.t1 VALUES (1, 'test');

    SELECT * FROM base.t1;

    1    test
    ```

    Podemos usar la sentencia `REPLACE` para vaciar todos los datos:

    ```sql theme={null}
    CREATE OR REPLACE TABLE base.t1 
    (
        n UInt64, 
        s Nullable(String)
    )
    ENGINE = MergeTree
    ORDER BY n;

    INSERT INTO base.t1 VALUES (2, null);

    SELECT * FROM base.t1;

    2    
    ```

    O bien podemos usar la sentencia `REPLACE` para cambiar la estructura de la tabla:

    ```sql theme={null}
    REPLACE TABLE base.t1 (n UInt64) 
    ENGINE = MergeTree 
    ORDER BY n;

    INSERT INTO base.t1 VALUES (3);

    SELECT * FROM base.t1;

    3
    ```
  </Tab>
</Tabs>

<div id="comment-clause">
  ## Cláusula COMMENT
</div>

Puede añadir un comentario a la tabla cuando la cree.

**Sintaxis**

```sql theme={null}
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...
)
ENGINE = engine
COMMENT 'Comment'
```

<Note>
  La cláusula `COMMENT` debe especificarse **después** de cualquier cláusula específica de almacenamiento, como `PARTITION BY`, `ORDER BY` y `SETTINGS` específicos del almacenamiento.

  Después de la cláusula `COMMENT`, solo se interpretarán los `SETTINGS` específicos de la consulta (como `max_threads`, etc.), no los ajustes relacionados con el almacenamiento.

  Esto significa que el orden correcto de las cláusulas es:

  * `ENGINE`
  * cláusulas de almacenamiento
  * `COMMENT`
  * ajustes de la consulta (si los hay)
</Note>

**Ejemplo**

```sql title="Query" theme={null}
CREATE TABLE t1 (x String) ENGINE = Memory COMMENT 'The temporary table';
SELECT name, comment FROM system.tables WHERE name = 't1';
```

```text title="Response" theme={null}
┌─name─┬─comment─────────────┐
│ t1   │ The temporary table │
└──────┴─────────────────────┘
```

<div id="related-content">
  ## Contenido relacionado
</div>

* Blog: [Optimizar ClickHouse con esquemas y códecs](https://clickhouse.com/blog/optimize-clickhouse-codecs-compression-schema)
* Blog: [Trabajar con datos de series temporales en ClickHouse](https://clickhouse.com/blog/working-with-time-series-data-and-functions-ClickHouse)