Saltar al contenido principal
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.

Variantes de sintaxis

Con esquema explícito

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

Con el esquema de una tabla existente

ClickHouse permite copiar el esquema y los datos de una tabla existente. Para replicar el esquema de una tabla existente:
CREATE TABLE [IF NOT EXISTS] [db2.]table_clone AS [db.]table [ENGINE = engine]
Esto crea una tabla con la misma estructura que otra.

Con el esquema y los datos de una tabla existente

Para replicar el esquema y los datos de una tabla existente:
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:
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).

A partir de una función de tabla

CREATE TABLE [IF NOT EXISTS] [db.]table_name AS table_function()
Crea una tabla con el mismo resultado que la función de tabla especificada. La tabla creada también funcionará del mismo modo que la función de tabla correspondiente que se haya especificado.

A partir de una consulta SELECT

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. Ejemplo
Query
CREATE TABLE t1 (x String) ENGINE = Memory AS SELECT 1;
SELECT x, toTypeName(x) FROM t1;
Response
┌─x─┬─toTypeName(x)─┐
│ 1 │ String        │
└───┴───────────────┘

Modificadores NULL o NOT NULL

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

Valores predeterminados

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.

DEFAULT

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:
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─┐
12023-02-24 17:06:462023-02-24
└────┴─────────────────────┴─────────────────┘

MATERIALIZED

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:
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─┐
12023-02-24 17:08:082023-02-24
└────┴─────────────────────┴─────────────────┘

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

EPHEMERAL

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

ALIAS

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.
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─────┐
146788994.46 MiB │
└────┴────────────┴──────────┘

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

Clave primaria

Puede definir una clave primaria al crear una tabla. La clave primaria se puede especificar de dos maneras:
  • En la lista de columnas
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...,
    PRIMARY KEY(expr1[, expr2,...])
)
ENGINE = engine;
  • Fuera de la lista de columnas
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...
)
ENGINE = engine
PRIMARY KEY(expr1[, expr2,...]);
No se pueden combinar ambas formas en una sola consulta.

Restricciones

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

CONSTRAINT

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.

ASSUME

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

Expresión TTL

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.

Códecs de compresión de columnas

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 de la configuración del servidor. También puede definir el método de compresión para cada columna en la consulta CREATE TABLE.
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:
ALTER TABLE codec_example MODIFY COLUMN float_value CODEC(Default);
Los códecs pueden combinarse en una pipeline; por ejemplo, CODEC(Delta, Default).
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.
Se admite compresión en los siguientes motores de tabla:
  • Familia 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.
  • Familia Log. Usa el método de compresión lz4 de forma predeterminada y admite códecs de compresión por columna.
  • Set. Solo admite la compresión predeterminada.
  • Join. Solo admite la compresión predeterminada.
ClickHouse admite códecs de propósito general y códecs especializados.

Códecs de uso general

NONE

NONE — Sin compresión.

LZ4

LZ4 — Algoritmo de compresión de datos sin pérdida usado de forma predeterminada. Utiliza la compresión rápida LZ4.

LZ4HC

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

ZSTD

ZSTD[(level)]algoritmo de compresión ZSTD 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.

Obsoleto: ZSTD_QAT

Obsoleto: DEFLATE_QPL

Códecs especializados

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.

Delta

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.

DoubleDelta

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. 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. DoubleDelta es un códec de preparación de datos; es decir, no puede usarse por sí solo.

GCD

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.

Gorilla

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.

ALP

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

T64

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:
CREATE TABLE codec_example
(
    timestamp DateTime CODEC(DoubleDelta),
    slow_values Float32 CODEC(Gorilla)
)
ENGINE = MergeTree()

Códecs de cifrado

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

AES_128_GCM_SIV

CODEC('AES-128-GCM-SIV') — Cifra los datos con AES-128 en modo GCM-SIV según RFC 8452.

AES-256-GCM-SIV

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, 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).
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.
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. Puede que le convenga deshabilitar el registro.
Ejemplo
CREATE TABLE mytable
(
    x String CODEC(AES_128_GCM_SIV)
)
ENGINE = MergeTree ORDER BY x;
Si es necesario aplicar compresión, debe especificarse explícitamente. De lo contrario, solo se aplicará cifrado a los datos.
Ejemplo
CREATE TABLE mytable
(
    x String CODEC(Delta, LZ4, AES_128_GCM_SIV)
)
ENGINE = MergeTree ORDER BY x;

Tablas temporales

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.
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:
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 en lugar de tablas temporales.

REPLACE TABLE

La sentencia REPLACE permite actualizar una tabla de forma atómica.
Esta sentencia es compatible con los motores de base de datos Atomic y Replicated, que son los motores de base de datos predeterminados de ClickHouse y ClickHouse Cloud, respectivamente.
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:
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:
REPLACE TABLE myOldTable
ENGINE = MergeTree()
ORDER BY CounterID 
AS
SELECT * FROM myOldTable
WHERE CounterID <12345;

Sintaxis

{CREATE [OR REPLACE] | REPLACE} TABLE [db.]table_name
Todas las formas sintácticas de la sentencia CREATE también sirven para esta sentencia. Invocar REPLACE sobre una tabla inexistente provocará un error.

Ejemplos:

Considere la siguiente tabla:
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:
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:
REPLACE TABLE base.t1 (n UInt64) 
ENGINE = MergeTree 
ORDER BY n;

INSERT INTO base.t1 VALUES (3);

SELECT * FROM base.t1;

┌─n─┐
3
└───┘

Cláusula COMMENT

Puede añadir un comentario a la tabla cuando la cree. Sintaxis
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...
)
ENGINE = engine
COMMENT 'Comment'
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)
Ejemplo
Query
CREATE TABLE t1 (x String) ENGINE = Memory COMMENT 'The temporary table';
SELECT name, comment FROM system.tables WHERE name = 't1';
Response
┌─name─┬─comment─────────────┐
│ t1   │ The temporary table │
└──────┴─────────────────────┘
Última modificación el 10 de junio de 2026