CREATE VIEW

Crea una nueva vista. Las vistas pueden ser normales, materializadas, materializadas actualizables y de ventana.

Sintaxis:

CREATE [OR REPLACE] VIEW [IF NOT EXISTS] [db.]table_name [(alias1 [, alias2 ...])] [ON CLUSTER cluster_name]
[DEFINER = { user | CURRENT_USER }] [SQL SECURITY { DEFINER | INVOKER | NONE }]
AS SELECT ...
[COMMENT 'comment']

Las vistas normales no almacenan datos. Simplemente leen de otra tabla en cada acceso. En otras palabras, una vista normal no es más que una consulta guardada. Al leer una vista, esta consulta guardada se usa como subconsulta en la cláusula FROM.

Como ejemplo, suponga que ha creado una vista:

CREATE VIEW view AS SELECT ...

y escribir una consulta:

SELECT a, b, c FROM view

Esta consulta equivale por completo a usar la subconsulta:

SELECT a, b, c FROM (SELECT ...)

Las vistas parametrizadas son similares a las vistas normales, pero pueden crearse con parámetros que no se resuelven inmediatamente. Estas vistas pueden usarse con funciones de tabla, que especifican el nombre de la vista como nombre de la función y los valores de los parámetros como argumentos.

CREATE VIEW view AS SELECT * FROM TABLE WHERE Column1={column1:datatype1} and Column2={column2:datatype2} ...

Lo anterior crea una vista para la tabla, que puede usarse como función de tabla al sustituir los parámetros, como se muestra a continuación.

SELECT * FROM view(column1=value1, column2=value2 ...)

Dado que la vista parametrizada depende de los valores de los parámetros, no tiene un esquema cuando no se proporcionan parámetros. Esto significa que no hay información sobre las vistas parametrizadas en la tabla system.columns. Además, las consultas DESCRIBE solo funcionarían si se proporcionan parámetros.

DESCRIBE view(column1=value1, column2=value2 ...)

CREATE MATERIALIZED VIEW [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster_name] [TO[db.]name [(columns)]] [ENGINE = engine] [POPULATE]
[REFRESH ...]
[DEFINER = { user | CURRENT_USER }] [SQL SECURITY { DEFINER | NONE }]
AS SELECT ...
[COMMENT 'comment']

CREATE OR REPLACE MATERIALIZED VIEW [db.]table_name [ON CLUSTER cluster_name] [TO[db.]name [(columns)]] [ENGINE = engine] [POPULATE]
[REFRESH ...]
[DEFINER = { user | CURRENT_USER }] [SQL SECURITY { DEFINER | NONE }]
AS SELECT ...
[COMMENT 'comment']

OR REPLACE e IF NOT EXISTS son mutuamente excluyentes: combinarlos da lugar a un error de sintaxis.

CREATE OR REPLACE MATERIALIZED VIEW reemplaza de forma atómica una vista materializada existente y su tabla de almacenamiento subyacente (si la hay). La operación requiere un motor de base de datos Atomic o Replicated.

CREATE OR REPLACE MATERIALIZED VIEW [db.]name [ON CLUSTER cluster]
[TO [db.]target_table]
[ENGINE = engine]
[POPULATE]
[REFRESH ...]
AS SELECT ...

Comportamientos clave:

• Sin la cláusula TO: se elimina la tabla interna anterior y se crea una nueva. Los datos existentes en la tabla interna se pierden, salvo que se especifique POPULATE.
• Con la cláusula TO: solo se reemplaza la definición de la vista; la tabla de destino y sus datos no se ven afectados.
• Compatible con REFRESH, ON CLUSTER y todas las opciones del motor. POPULATE solo se admite en bases de datos Atomic; se rechaza en bases de datos Replicated (consulte la nota sobre POPULATE más abajo).
• Requiere los privilegios CREATE VIEW y DROP VIEW.

Ejemplos:

-- Create a materialized view with an inner table
CREATE OR REPLACE MATERIALIZED VIEW mv
    ENGINE = MergeTree ORDER BY x
    AS SELECT x, sum(y) AS total FROM src GROUP BY x;

-- Replace with a new definition (old inner table data is lost)
CREATE OR REPLACE MATERIALIZED VIEW mv
    ENGINE = MergeTree ORDER BY x
    AS SELECT x, count() AS cnt FROM src GROUP BY x;

-- Replace with POPULATE to backfill from existing source data
CREATE OR REPLACE MATERIALIZED VIEW mv
    ENGINE = MergeTree ORDER BY x
    POPULATE
    AS SELECT x FROM src;

-- Replace an inner-table MV with a TO-table MV (target data is preserved)
CREATE OR REPLACE MATERIALIZED VIEW mv TO target
    AS SELECT x FROM src;

Las vistas materializadas almacenan los datos transformados por la consulta SELECT correspondiente.

Al crear una vista materializada sin TO [db].[table], debes especificar ENGINE: el motor de tabla para almacenar los datos.

Al crear una vista materializada con TO [db].[table], también puedes usar POPULATE para rellenar la tabla de destino con datos históricos de los datos de origen existentes (la tabla de destino ya puede contener datos, en cuyo caso se añaden las filas rellenadas). POPULATE no se puede combinar con REFRESH: una vista materializada actualizable se rellena mediante su primera actualización, por lo que POPULATE cargaría los datos iniciales dos veces (usa EMPTY para omitir la primera actualización en su lugar).

Una vista materializada se implementa de la siguiente manera: al insertar datos en la tabla especificada en SELECT, una parte de los datos insertados se transforma mediante esta consulta SELECT, y el resultado se inserta en la vista.

Si especifica POPULATE, los datos existentes de la tabla de origen se insertan en la vista al crearla. De lo contrario, la vista contiene solo los datos insertados en la tabla de origen después de crearla.

Para un CREATE MATERIALIZED VIEW simple, POPULATE es atómico de forma predeterminada (configuración materialized_views_populate_atomically = 1): la vista se suscribe a las nuevas inserciones en la tabla de origen y se toma simultáneamente una instantánea de los datos existentes, bajo un breve bloqueo exclusivo en la tabla de origen, de modo que cada fila insertada de forma concurrente durante la carga inicial se entrega a la vista exactamente una vez: no se omite ni se duplica. A continuación, la carga inicial (que puede ser prolongada) lee la instantánea fijada sin mantener ningún bloqueo.

Esta es una atomicidad local de la ruta de inserción: el bloqueo exclusivo solo se serializa con las inserciones que adquieren el bloqueo de almacenamiento de esta tabla de origen en el mismo servidor, por lo que la garantía de entrega exactamente una vez cubre las inserciones que llegan a través de este servidor. No es una garantía para todo el clúster: las filas insertadas en otra réplica de un origen ReplicatedMergeTree, o mediante una ruta de escritura distribuida (por ejemplo, en una tabla Distributed o mediante ON CLUSTER), de forma concurrente con la carga inicial, quedan fuera de este alcance y aún pueden omitirse o duplicarse.

Si la carga inicial falla —por ejemplo, si no se puede adquirir el bloqueo exclusivo en una tabla de origen ocupada dentro de lock_acquire_timeout, o si el SELECT de la vista genera una excepción durante su ejecución—, la vista recién creada se elimina y la consulta CREATE falla, sin dejar nada de lo que creó, por lo que puede reintentarse sin más. Para la forma TO [db].[table], esta reversión elimina solo la vista, nunca la tabla de destino preexistente; pero las filas que la carga inicial fallida ya insertó en el destino permanecen allí, exactamente como después de un INSERT ... SELECT fallido en esa tabla, por lo que reintentar el CREATE las inserta de nuevo. Si el relleno debe ser exacto, vuelva a intentarlo con una tabla de destino truncada o nueva, o use un motor de deduplicación como ReplacingMergeTree.

Una consulta SELECT puede contener DISTINCT, GROUP BY, ORDER BY, LIMIT. Tenga en cuenta que las transformaciones correspondientes se realizan de forma independiente en cada bloque de datos insertados. Por ejemplo, si se establece GROUP BY, los datos se agregan durante la inserción, pero solo dentro de un único paquete de datos insertados. Los datos no se volverán a agregar después. La excepción es cuando se usa un ENGINE que realiza la agregación de datos por sí mismo, como SummingMergeTree.

Si la vista materializada usa la construcción TO [db.]name, puede aplicar DETACH a la vista, ejecutar ALTER en la tabla de destino y luego hacer ATTACH de la vista previamente separada con DETACH.

Las vistas tienen el mismo aspecto que las tablas normales. Por ejemplo, aparecen en el resultado de la consulta SHOW TABLES.

Para eliminar una vista, use DROP VIEW. Aunque DROP TABLE también funciona para las VIEW.

DEFINER y SQL SECURITY permiten especificar qué usuario de ClickHouse se utilizará al ejecutar la consulta subyacente de la vista. SQL SECURITY tiene tres valores válidos: DEFINER, INVOKER o NONE. Puede especificar cualquier usuario existente o CURRENT_USER en la cláusula DEFINER.

La siguiente tabla explica qué permisos se requieren para cada usuario al seleccionar datos de una vista. Tenga en cuenta que, independientemente de la opción de SQL security, en todos los casos sigue siendo necesario tener GRANT SELECT ON <view> para poder leer de ella.

Si no se especifican DEFINER/SQL SECURITY, el resultado depende de la configuración del servidor ignore_empty_sql_security_in_create_view_query.

Con su valor predeterminado de true, la consulta se almacena tal como se escribió y la vista obtiene un tipo de SQL security vacío. Una vista normal se ejecuta entonces con los permisos del invocador y, en el caso de una vista materializada con una tabla de destino especificada explícitamente, se omiten las comprobaciones de acceso a esa tabla de destino: insertar en la tabla fuente no requiere el privilegio INSERT en la tabla de destino, y leer de la vista no requiere el privilegio SELECT sobre ella.

Con false, los siguientes valores predeterminados se escriben en la definición de la vista en el momento de crearla:

• SQL SECURITY: INVOKER para las vistas normales (configurable mediante default_normal_view_sql_security) y DEFINER para las vistas materializadas (configurable mediante default_materialized_view_sql_security)
• DEFINER: CURRENT_USER (configurable mediante default_view_definer)

Las vistas materializadas actualizables siempre reciben estos valores predeterminados, independientemente de la configuración.

Una vista conserva el tipo de SQL security de su definición almacenada cuando se adjunta o se recarga al iniciar el servidor, por lo que una vista almacenada sin DEFINER/SQL SECURITY conserva el tipo de SQL security vacío.

Para cambiar SQL security de una vista existente, use

ALTER TABLE MODIFY SQL SECURITY { DEFINER | INVOKER | NONE } [DEFINER = { user | CURRENT_USER }]

CREATE VIEW test_view
DEFINER = alice SQL SECURITY DEFINER
AS SELECT ...

CREATE VIEW test_view
SQL SECURITY INVOKER
AS SELECT ...

Esta función está obsoleta y se eliminará en el futuro.

Para mayor comodidad, la documentación anterior está disponible aquí

CREATE MATERIALIZED VIEW [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
REFRESH [EVERY|AFTER interval [OFFSET interval]]
[RANDOMIZE FOR interval]
[DEPENDS ON [db.]name [, [db.]name [, ...]]]
[SETTINGS name = value [, name = value [, ...]]]
[APPEND]
[TO[db.]name] [(columns)] [ENGINE = engine]
[EMPTY]
[DEFINER = { user | CURRENT_USER }] [SQL SECURITY { DEFINER | NONE }]
AS SELECT ...
[COMMENT 'comment']

donde interval es una secuencia de intervalos simples:

number SECOND|MINUTE|HOUR|DAY|WEEK|MONTH|YEAR

La cláusula REFRESH debe especificar al menos uno de EVERY, AFTER o DEPENDS ON. REFRESH sin más (sin ninguno de ellos) se rechaza. REFRESH DEPENDS ON ... sin EVERY/AFTER es una forma abreviada de REFRESH AFTER 0 SECOND DEPENDS ON ...; consulta Dependencias de actualización más abajo.

Ejecuta periódicamente la consulta correspondiente y almacena su resultado en una tabla.

• Si se especifica APPEND, cada actualización inserta filas en la tabla sin eliminar las existentes. La inserción no es atómica, igual que en una consulta INSERT INTO ... SELECT normal.
• De lo contrario, cada actualización reemplaza atómicamente el contenido previo de la tabla.

Diferencias con las vistas materializadas normales no actualizables:

• No hay trigger de inserción. Cuando se insertan datos nuevos en la tabla especificada en SELECT, no se envían automáticamente a la vista materializada actualizable. En su lugar, los datos solo se insertan durante las ejecuciones de actualización periódicas o manuales.
• La consulta SELECT no tiene restricciones. Se permiten funciones de tabla (por ejemplo, url()), vistas, UNION y JOIN.

Ejemplos de programación de actualización:

REFRESH EVERY 1 DAY -- every day, at midnight (UTC)
REFRESH EVERY 1 MONTH -- on 1st day of every month, at midnight
REFRESH EVERY 1 MONTH OFFSET 5 DAY 2 HOUR -- on 6th day of every month, at 2:00 am
REFRESH EVERY 2 WEEK OFFSET 5 DAY 15 HOUR 10 MINUTE -- every other Saturday, at 3:10 pm
REFRESH EVERY 30 MINUTE -- at 00:00, 00:30, 01:00, 01:30, etc
REFRESH AFTER 30 MINUTE -- 30 minutes after the previous refresh completes, no alignment with time of day
-- REFRESH AFTER 1 HOUR OFFSET 1 MINUTE -- syntax error, OFFSET is not allowed with AFTER
REFRESH EVERY 1 WEEK 2 DAYS -- every 9 days, not on any particular day of the week or month;
                            -- specifically, when day number (since 1969-12-29) is divisible by 9
REFRESH EVERY 5 MONTHS -- every 5 months, different months each year (as 12 is not divisible by 5);
                       -- specifically, when month number (since 1970-01) is divisible by 5

RANDOMIZE FOR ajusta aleatoriamente el momento en que se realiza cada actualización, por ejemplo:

REFRESH EVERY 1 DAY OFFSET 2 HOUR RANDOMIZE FOR 1 HOUR -- every day at random time between 01:30 and 02:30

Como máximo, puede haber una sola actualización en ejecución a la vez para una vista determinada. Por ejemplo, si una vista con REFRESH EVERY 1 MINUTE tarda 2 minutos en actualizarse, simplemente se actualizará cada 2 minutos. Si después se vuelve más rápida y empieza a actualizarse en 10 segundos, volverá a actualizarse cada minuto. (En particular, no se actualizará cada 10 segundos para compensar actualizaciones omitidas: no existe tal retraso acumulado).

Normalmente, la primera actualización se inicia inmediatamente después de crear la vista materializada: el tiempo transcurrido desde la última actualización es infinito, por lo que cualquier programación indica que es momento de actualizarla. Si se especifica EMPTY, esta actualización inicial se omite y la primera actualización se realiza en el siguiente momento programado; por ejemplo, para EVERY 1 HOUR, la primera actualización se realizará al final de la hora actual.

Si la vista materializada actualizable está en una base de datos Replicated, las réplicas se coordinan entre sí para que solo una de ellas realice la actualización en cada momento programado. Se requiere el motor de tabla ReplicatedMergeTree para que todas las réplicas vean los datos generados por la actualización.

En modo APPEND, la coordinación puede deshabilitarse con SETTINGS all_replicas = 1. Esto hace que las réplicas realicen las actualizaciones de forma independiente. En este caso, ReplicatedMergeTree no es necesario.

En el modo no APPEND, solo se admite la actualización coordinada. Para una actualización no coordinada, use la base de datos Atomic y la consulta CREATE ... ON CLUSTER para crear vistas materializadas actualizables en todas las réplicas.

La coordinación se realiza mediante Keeper. La ruta del znode se determina mediante la configuración de servidor default_replica_path.

DEPENDS ON sincroniza las actualizaciones de diferentes tablas:

CREATE MATERIALIZED VIEW dependent REFRESH EVERY 1 HOUR DEPENDS ON dependency [...]

La actualización de la vista dependiente solo comenzará una vez que hayan finalizado las actualizaciones de todas las vistas de las que depende.

Para actualizarla inmediatamente después de la actualización de otra vista:

CREATE MATERIALIZED VIEW dependent REFRESH AFTER 0 SECOND DEPENDS ON dependency [...]

O, de forma equivalente:

CREATE MATERIALIZED VIEW dependent REFRESH DEPENDS ON dependency [...]

Si ambas vistas usan REFRESH EVERY con el mismo período, la dependencia se aplica en cada franja horaria.

P. ej., supongamos que las vistas X e Y usan REFRESH EVERY 1 HOUR, y que Y lee de la tabla de salida de X. Sin dependencias, Y normalmente vería los datos de X de la actualización de la hora anterior. Con DEPENDS ON X, la actualización de Y de las 11:00 solo comenzará después de que finalice la actualización de X de las 11:00.

           10:00            11:00            12:00
           │                │                │
  X:        [run]┐           [run]┐           [run]┐
                 │                │                │
  Y:             └►[run]          └►[run]          └►[run]

Tanto la dependencia como la vista dependiente pueden omitir franjas horarias de forma independiente si las actualizaciones tardan más que el período de actualización. No se garantiza que la vista dependiente se actualice exactamente una vez por cada actualización de la dependencia.

           10:00          11:00          12:00          13:00
           │              │              │              |
  X:        [run]┐         [run]┐         [run]┐         [run]┐
                 │              └────┐    (Y skips 12:00)     └───┐
  Y:             └►[10:00 ru------un]└►[11:00 ru---------------un]└►[13:00 run]

Si no se usa REFRESH EVERY, la vista dependiente X se actualiza si todas sus dependencias se han actualizado al menos una vez desde la última actualización de X. REFRESH AFTER T añade un retraso: la vista dependiente iniciará la actualización T unidades de tiempo después de que la dependencia complete una actualización.

Se permiten las dependencias circulares y son útiles. Considere este grafo de vistas materializadas actualizables:

1. X toma un lote de filas de un flujo y las coloca en una tabla.
2. Luego, Y y Z leen de esa tabla, realizan agregaciones distintas y añaden los resultados a otras tablas.
3. Una vez que el lote se ha procesado por completo, X toma el siguiente lote y el ciclo se repite.

            source
               │
               ▼
          ┌─────────┐
     ┌───►│    X    │◄───┐
     │    └──┬───┬──┘    │
  DEPENDS    │   │    DEPENDS
    ON       ▼   ▼      ON
     │      ┌─┐ ┌─┐      │
     └──────┤Y│ │Z├──────┘
            └─┘ └─┘

Ejemplo completo:

CREATE TABLE current_batch (t UInt64, v Int64) ENGINE ReplicatedMergeTree ORDER BY t;
CREATE TABLE batch_log (max_t UInt64, n Int64, v_sum Int64, processed_at DateTime64) ENGINE ReplicatedMergeTree ORDER BY max_t;
CREATE TABLE stats (h UInt64, n UInt64) ENGINE ReplicatedSummingMergeTree ORDER BY h;

-- (system.numbers stands in for a data source with monotonically increasing timestamps or sequence numbers)
CREATE MATERIALIZED VIEW current_batch_v REFRESH EVERY 10 SECOND DEPENDS ON batch_log_v, stats_v TO current_batch AS SELECT number as t, number * 10 as v FROM system.numbers WHERE number > (SELECT max(max_t) FROM batch_log) LIMIT 100;

CREATE MATERIALIZED VIEW batch_log_v REFRESH DEPENDS ON current_batch_v APPEND TO batch_log AS SELECT max(t) as max_t, count() as n, sum(v) as v_sum, now64() as processed_at FROM current_batch;

CREATE MATERIALIZED VIEW stats_v REFRESH DEPENDS ON current_batch_v APPEND TO stats AS SELECT cityHash64(v) % 20 as h, count() as n FROM current_batch GROUP BY h;

-- Must trigger initial refresh manually.
SYSTEM REFRESH VIEW current_batch_v;

Las cadenas más largas también funcionan.

Esto solo funciona bien cuando la coordinación de actualización está habilitada, es decir, cuando las vistas están en una base de datos Replicated o Shared. Sin coordinación, un reinicio del servidor interrumpe el ciclo, por lo que se requiere un SYSTEM REFRESH VIEW manual después de cada reinicio, en lugar de solo una vez tras crear las vistas.

Parámetros de actualización disponibles:

• refresh_retries - Cuántas veces reintentar si la consulta de actualización falla con una excepción. Si fallan todos los reintentos, se pasa a la siguiente hora de actualización programada. 0 significa que no hay reintentos; -1, que los reintentos son infinitos. Predeterminado: 2.
• refresh_retry_initial_backoff_ms - Retraso antes del primer reintento, si refresh_retries no es cero. Cada reintento posterior duplica el retraso, hasta refresh_retry_max_backoff_ms. Predeterminado: 100 ms.
• refresh_retry_max_backoff_ms - Límite del crecimiento exponencial del retraso entre intentos de actualización. Predeterminado: 60000 ms (1 minuto).
• all_replicas - En una base de datos Replicated con APPEND, controla si todas las réplicas se actualizan de forma independiente o si solo una réplica se actualiza en cada momento programado. No se puede cambiar después de crear la vista. Predeterminado: false.

Los parámetros de actualización de una vista materializada actualizable existente se modifican mediante ALTER TABLE ... MODIFY REFRESH:

ALTER TABLE [db.]name MODIFY REFRESH EVERY|AFTER ... [RANDOMIZE FOR ...] [DEPENDS ON ...] [SETTINGS ...]

La programación (EVERY o AFTER) es obligatoria: la sentencia siempre sustituye todos los parámetros de actualización —la programación, RANDOMIZE FOR, DEPENDS ON y los parámetros de actualización— por los especificados. Todo lo que se omita se restablece a su valor predeterminado (configuración) o se elimina (dependencias, aleatorización).

Ejemplos:

-- Cambiar el horario, eliminar la configuración y las dependencias existentes.
ALTER TABLE rmv MODIFY REFRESH EVERY 30 MINUTE;

-- Cambiar el horario y ajustar el comportamiento de reintentos.
ALTER TABLE rmv MODIFY REFRESH EVERY 30 MINUTE
SETTINGS refresh_retries = 5,
         refresh_retry_initial_backoff_ms = 500,
         refresh_retry_max_backoff_ms = 60000;

-- Mantener la dependencia al cambiar el período.
ALTER TABLE rmv MODIFY REFRESH EVERY 6 HOUR DEPENDS ON other_rmv;

-- Eliminar la dependencia omitiendo `DEPENDS ON`.
ALTER TABLE rmv MODIFY REFRESH EVERY 6 HOUR;

El estado de todas las vistas materializadas actualizables está disponible en la tabla system.view_refreshes. En particular, incluye el progreso de la actualización (si está en curso), la hora de la última y de la próxima actualización, y el mensaje de excepción si una actualización falló.

Para detener, iniciar, activar o cancelar actualizaciones manualmente, use SYSTEM STOP|START|REFRESH|WAIT|CANCEL VIEW.

Para esperar a que se complete una actualización, use SYSTEM WAIT VIEW. En particular, resulta útil para esperar a que termine la actualización inicial tras crear una vista.

CREATE WINDOW VIEW [IF NOT EXISTS] [db.]table_name [TO [db.]table_name] [INNER ENGINE engine] [ENGINE engine] [WATERMARK strategy] [ALLOWED_LATENESS interval_function] [POPULATE]
AS SELECT ...
GROUP BY time_window_function
[COMMENT 'comment']

Una window view puede agregar datos por ventana de tiempo y generar los resultados cuando la ventana esté lista para dispararse. Almacena los resultados parciales de la agregación en una tabla interna (o especificada) para reducir la latencia, y puede enviar el resultado del procesamiento a una tabla especificada o enviar notificaciones mediante la consulta WATCH.

Crear una window view es similar a crear MATERIALIZED VIEW. Una window view necesita un motor de almacenamiento interno para guardar datos intermedios. El almacenamiento interno puede especificarse mediante la cláusula INNER ENGINE; la window view usará AggregatingMergeTree como motor interno predeterminado.

Al crear una window view sin TO [db].[table], debe especificar ENGINE, el motor de tabla para almacenar los datos.

Las funciones de ventana de tiempo se utilizan para obtener los límites inferior y superior de la ventana de los registros. La window view debe usarse con una función de ventana de tiempo.

Window view admite el uso de tiempo de procesamiento y tiempo de evento.

El tiempo de procesamiento permite que window view genere resultados en función de la hora de la máquina local y se usa de forma predeterminada. Es la noción de tiempo más sencilla, pero no proporciona determinismo. El atributo de tiempo de procesamiento puede definirse estableciendo el valor de time_attr de la función de ventana de tiempo en una columna de la tabla o mediante la función now(). La siguiente consulta crea una window view con tiempo de procesamiento.

CREATE WINDOW VIEW wv AS SELECT count(number), tumbleStart(w_id) as w_start from date GROUP BY tumble(now(), INTERVAL '5' SECOND) as w_id

El tiempo del evento es el momento en que ocurrió cada evento individual en el dispositivo que lo produjo. Este tiempo suele estar incluido en los registros cuando se generan. El procesamiento por tiempo del evento permite obtener resultados coherentes incluso en caso de eventos desordenados o tardíos. Window view admite el procesamiento por tiempo del evento mediante la sintaxis WATERMARK.

Window view proporciona tres estrategias de watermark:

• STRICTLY_ASCENDING: Emite un watermark con la marca temporal máxima observada hasta el momento. Las filas con una marca temporal inferior a la marca temporal máxima no se consideran tardías.
• ASCENDING: Emite un watermark con la marca temporal máxima observada hasta el momento menos 1. Las filas con una marca temporal igual o inferior a la marca temporal máxima no se consideran tardías.
• BOUNDED: WATERMARK=INTERVAL. Emite watermarks que corresponden a la marca temporal máxima observada menos el retraso especificado.

Las siguientes consultas son ejemplos de creación de una window view con WATERMARK:

CREATE WINDOW VIEW wv WATERMARK=STRICTLY_ASCENDING AS SELECT count(number) FROM date GROUP BY tumble(timestamp, INTERVAL '5' SECOND);
CREATE WINDOW VIEW wv WATERMARK=ASCENDING AS SELECT count(number) FROM date GROUP BY tumble(timestamp, INTERVAL '5' SECOND);
CREATE WINDOW VIEW wv WATERMARK=INTERVAL '3' SECOND AS SELECT count(number) FROM date GROUP BY tumble(timestamp, INTERVAL '5' SECOND);

De forma predeterminada, la ventana se activará cuando llegue la watermark, y los elementos que lleguen por detrás de la watermark se descartarán. La window view admite el procesamiento de eventos tardíos configurando ALLOWED_LATENESS=INTERVAL. Un ejemplo de gestión de la tardanza es:

CREATE WINDOW VIEW test.wv TO test.dst WATERMARK=ASCENDING ALLOWED_LATENESS=INTERVAL '2' SECOND AS SELECT count(a) AS count, tumbleEnd(wid) AS w_end FROM test.mt GROUP BY tumble(timestamp, INTERVAL '5' SECOND) AS wid;

Tenga en cuenta que los elementos emitidos por una activación tardía deben tratarse como resultados actualizados de un cálculo anterior. En lugar de activarse al final de las ventanas, la window view se activará inmediatamente cuando llegue el evento tardío. Por lo tanto, generará múltiples salidas para la misma ventana. Los usuarios deben tener en cuenta estos resultados duplicados o deduplicarlos.

Puede modificar la consulta SELECT especificada en la window view mediante la sentencia ALTER TABLE ... MODIFY QUERY. La estructura de datos resultante de la nueva consulta SELECT debe ser la misma que la de la consulta SELECT original, con o sin la cláusula TO [db.]name. Tenga en cuenta que los datos de la ventana actual se perderán porque el estado intermedio no se puede reutilizar.

Window view admite la consulta WATCH para supervisar los cambios, o use la sintaxis TO para enviar los resultados a una tabla.

WATCH [db.]window_view
[EVENTS]
[LIMIT n]
[FORMAT format]

Se puede especificar un LIMIT para definir el número de actualizaciones que se recibirán antes de finalizar la consulta. La cláusula EVENTS puede usarse para obtener una forma abreviada de la consulta WATCH, donde, en lugar del resultado de la consulta, solo se obtiene la watermark más reciente de la consulta.

• window_view_clean_interval: El intervalo de limpieza de window view, en segundos, para liberar datos obsoletos. El sistema conservará las ventanas que no se hayan activado por completo según la hora del sistema o la configuración de WATERMARK, y eliminará el resto de los datos.
• window_view_heartbeat_interval: El intervalo de heartbeat, en segundos, para indicar que la consulta watch sigue activa.
• wait_for_window_view_fire_signal_timeout: Tiempo de espera para recibir la señal de activación de window view durante el procesamiento por tiempo de evento.

Supongamos que necesitamos contar la cantidad de logs de clics por cada 10 segundos en una tabla de logs llamada data, cuya estructura es:

CREATE TABLE data ( `id` UInt64, `timestamp` DateTime) ENGINE = Memory;

Primero, creamos una window view con una tumble window con un intervalo de 10 segundos:

CREATE WINDOW VIEW wv as select count(id), tumbleStart(w_id) as window_start from data group by tumble(timestamp, INTERVAL '10' SECOND) as w_id

A continuación, usamos la consulta WATCH para obtener los resultados.

WATCH wv

Cuando se insertan logs en la tabla data,

INSERT INTO data VALUES(1,now())

La consulta WATCH debería mostrar los resultados de la siguiente manera:

┌─count(id)─┬────────window_start─┐
│         1 │ 2020-01-14 16:56:40 │
└───────────┴─────────────────────┘

Como alternativa, podemos adjuntar la salida a otra tabla mediante la sintaxis TO.

CREATE WINDOW VIEW wv TO dst AS SELECT count(id), tumbleStart(w_id) as window_start FROM data GROUP BY tumble(timestamp, INTERVAL '10' SECOND) as w_id

Se pueden encontrar ejemplos adicionales en las pruebas con estado de ClickHouse (allí se llaman *window_view*).

La window view es útil en los siguientes escenarios:

• Monitoreo: Agrega y calcula las métricas de los logs a lo largo del tiempo, y envía los resultados a una tabla de destino. El dashboard puede usar la tabla de destino como tabla de origen.
• Análisis: Agrega y preprocesa automáticamente los datos dentro de la ventana de tiempo. Esto puede ser útil al analizar una gran cantidad de logs. El preprocesamiento elimina cálculos repetidos en múltiples consultas y reduce la latencia de las consultas.

• Blog: Cómo trabajar con datos de series temporales en ClickHouse
• Blog: Creación de una solución de observabilidad con ClickHouse - Parte 2 - Trazas

ClickHouse admite vistas temporales con las siguientes características (en línea con las tablas temporales, cuando corresponde):

• Duración de la sesión Una vista temporal existe solo durante la sesión actual. Se elimina automáticamente cuando la sesión finaliza.

• Sin base de datos No se puede calificar una vista temporal con un nombre de base de datos. Existe fuera de las bases de datos (en el espacio de nombres de la sesión).

• No replicadas / sin ON CLUSTER Los objetos temporales son locales a la sesión y no pueden crearse con ON CLUSTER.

• Resolución de nombres Si un objeto temporal (tabla o vista) tiene el mismo nombre que un objeto persistente y una consulta hace referencia a ese nombre sin una base de datos, se usa el objeto temporal.

• Objeto lógico (sin almacenamiento) Una vista temporal solo almacena su texto SELECT (usa internamente el motor View). No conserva datos y no admite INSERT.

• Cláusula ENGINE No es necesario especificar ENGINE; si se indica como ENGINE = View, se ignora o se trata como la misma vista lógica.

• Seguridad / privilegios Para crear una vista temporal se requiere el privilegio CREATE TEMPORARY VIEW, que se concede implícitamente mediante CREATE VIEW.

• SHOW CREATE Use SHOW CREATE TEMPORARY VIEW view_name; para mostrar el DDL de una vista temporal.

CREATE TEMPORARY VIEW [IF NOT EXISTS] view_name AS <select_query>

OR REPLACE no se admite para las vistas temporales (para mantener la coherencia con las tablas temporales). Si necesita “reemplazar” una vista temporal, elimínela y vuelva a crearla.

Cree una tabla fuente temporal y una vista temporal sobre esta:

CREATE TEMPORARY TABLE t_src (id UInt32, val String);
INSERT INTO t_src VALUES (1, 'a'), (2, 'b');

CREATE TEMPORARY VIEW tview AS
SELECT id, upper(val) AS u
FROM t_src
WHERE id <= 2;

SELECT * FROM tview ORDER BY id;

Muestra su DDL:

SHOW CREATE TEMPORARY VIEW tview;

Elimínela:

DROP TEMPORARY VIEW IF EXISTS tview;  -- las vistas temporales se eliminan con la sintaxis TEMPORARY TABLE

• CREATE OR REPLACE TEMPORARY VIEW ... → no permitido (usa DROP + CREATE).
• CREATE TEMPORARY MATERIALIZED VIEW ... / WINDOW VIEW → no permitido.
• CREATE TEMPORARY VIEW db.view AS ... → no permitido (sin calificador de base de datos).
• CREATE TEMPORARY VIEW view ON CLUSTER 'name' AS ... → no permitido (los objetos temporales son locales a la sesión).
• POPULATE, REFRESH, TO [db.table], motores internos y todas las cláusulas específicas de las MV → no aplicables a las vistas temporales.

Una vista temporal es solo una definición; no hay datos que transferir. Si la vista temporal hace referencia a tablas temporales (p. ej., Memory), sus datos pueden enviarse a servidores remotos durante la ejecución de consultas distribuidas, del mismo modo que ocurre con las tablas temporales.

-- A session-scoped, in-memory table
CREATE TEMPORARY TABLE temp_ids (id UInt64) ENGINE = Memory;

INSERT INTO temp_ids VALUES (1), (5), (42);

-- A session-scoped view over the temp table (purely logical)
CREATE TEMPORARY VIEW v_ids AS
SELECT id FROM temp_ids;

-- Replace 'test' with your cluster name.
-- GLOBAL JOIN forces ClickHouse to *ship* the small join-side (temp_ids via v_ids)
-- to every remote server that executes the left side.
SELECT count()
FROM cluster('test', system.numbers) AS n
GLOBAL ANY INNER JOIN v_ids USING (id)
WHERE n.number < 100;