Consultas útiles para solucionar problemas

Consultas útiles para resolver problemas

Sin un orden en particular, aquí tienes algunas consultas útiles para resolver problemas de ClickHouse y entender qué está pasando. También tenemos un excelente blog con algunas consultas esenciales para supervisar ClickHouse.

Ver qué configuraciones se han modificado respecto a las predeterminadas

SELECT
    name,
    value
FROM system.settings
WHERE changed

Obtén el tamaño de todas tus tablas

SELECT table,
    formatReadableSize(sum(bytes)) as size
    FROM system.parts
    WHERE active
GROUP BY table

La respuesta tiene este aspecto:

┌─table───────────┬─size──────┐
│ stat            │ 38.89 MiB │
│ customers       │ 525.00 B  │
│ my_sparse_table │ 40.73 MiB │
│ crypto_prices   │ 32.18 MiB │
│ hackernews      │ 6.23 GiB  │
└─────────────────┴───────────┘

Número de filas y tamaño diario promedio de su tabla

SELECT
    table,
    formatReadableSize(size) AS size,
    rows,
    days,
    formatReadableSize(avgDaySize) AS avgDaySize
FROM
(
    SELECT
        table,
        sum(bytes) AS size,
        sum(rows) AS rows,
        min(min_date) AS min_date,
        max(max_date) AS max_date,
        max_date - min_date AS days,
        size / (max_date - min_date) AS avgDaySize
    FROM system.parts
    WHERE active
    GROUP BY table
    ORDER BY rows DESC
)

Porcentaje de compresión de las columnas, así como el tamaño del índice primario en memoria

Puede ver el nivel de compresión de sus datos por columna. Esta consulta también devuelve el tamaño de sus índices primarios en memoria, lo cual es útil saber porque los índices primarios deben caber en memoria.

SELECT
    parts.*,
    columns.compressed_size,
    columns.uncompressed_size,
    columns.compression_ratio,
    columns.compression_percentage
FROM
(
    SELECT
        table,
        formatReadableSize(sum(data_uncompressed_bytes)) AS uncompressed_size,
        formatReadableSize(sum(data_compressed_bytes)) AS compressed_size,
        round(sum(data_compressed_bytes) / sum(data_uncompressed_bytes), 3) AS compression_ratio,
        round(100 - ((sum(data_compressed_bytes) * 100) / sum(data_uncompressed_bytes)), 3) AS compression_percentage
    FROM system.columns
    GROUP BY table
) AS columns
RIGHT JOIN
(
    SELECT
        table,
        sum(rows) AS rows,
        max(modification_time) AS latest_modification,
        formatReadableSize(sum(bytes)) AS disk_size,
        formatReadableSize(sum(primary_key_bytes_in_memory)) AS primary_keys_size,
        any(engine) AS engine,
        sum(bytes) AS bytes_size
    FROM system.parts
    WHERE active
    GROUP BY
        database,
        table
) AS parts ON columns.table = parts.table
ORDER BY parts.bytes_size DESC

Número de consultas enviadas por el cliente en los últimos 10 minutos

Puedes aumentar o reducir el intervalo de tiempo en la función toIntervalMinute(10):

SELECT
    client_name,
    count(),
    query_kind,
    toStartOfMinute(event_time) AS event_time_m
FROM system.query_log
WHERE (type = 'QueryStart') AND (event_time > (now() - toIntervalMinute(10)))
GROUP BY
    event_time_m,
    client_name,
    query_kind
ORDER BY
    event_time_m DESC,
    count() ASC

Número de partes en cada partición

SELECT
    concat(database, '.', table),
    partition_id,
    count()
FROM system.parts
WHERE active
GROUP BY
    database,
    table,
    partition_id

Encontrar consultas de ejecución prolongada

Esto puede ayudar a encontrar consultas que se han quedado bloqueadas:

SELECT
    elapsed,
    initial_user,
    client_name,
    hostname(),
    query_id,
    query
FROM clusterAllReplicas(default, system.processes)
ORDER BY elapsed DESC

Usando el identificador de la consulta con peor rendimiento, podemos obtener una traza de pila que puede ayudar en la depuración.

SET allow_introspection_functions=1;

SELECT
    arrayStringConcat(
        arrayMap(
            x,
            y -> concat(x, ': ', y),
            arrayMap(x -> addressToLine(x), trace),
            arrayMap(x -> demangle(addressToSymbol(x)), trace)
        ),
        '\n'
    ) as trace
FROM
    system.stack_trace
WHERE
    query_id = '0bb6e88b-9b9a-4ffc-b612-5746c859e360';

Consultar los errores más recientes

SELECT *
FROM system.errors
ORDER BY last_error_time DESC

La respuesta tiene este aspecto:

┌─name──────────────────┬─code─┬─value─┬─────last_error_time─┬─last_error_message──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─last_error_trace─┬─remote─┐
│ UNKNOWN_TABLE         │   60 │     3 │ 2023-03-14 01:02:35 │ Table system.stack_trace doesn't exist                                                                                                              │ []               │      0 │
│ BAD_GET               │  170 │     1 │ 2023-03-14 00:58:55 │ Requested cluster 'default' not found                                                                                                               │ []               │      0 │
│ UNKNOWN_IDENTIFIER    │   47 │     1 │ 2023-03-14 00:49:12 │ Missing columns: 'parts.table' 'table' while processing query: 'table = parts.table', required columns: 'table' 'parts.table' 'table' 'parts.table' │ []               │      0 │
│ NO_ELEMENTS_IN_CONFIG │  139 │     2 │ 2023-03-14 00:42:11 │ Certificate file is not set.                                                                                                                        │ []               │      0 │
└───────────────────────┴──────┴───────┴─────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────────┴────────┘

Las 10 consultas que más CPU y memoria consumen

SELECT
    type,
    event_time,
    initial_query_id,
    formatReadableSize(memory_usage) AS memory,
    `ProfileEvents.Values`[indexOf(`ProfileEvents.Names`, 'UserTimeMicroseconds')] AS userCPU,
    `ProfileEvents.Values`[indexOf(`ProfileEvents.Names`, 'SystemTimeMicroseconds')] AS systemCPU,
    normalizedQueryHash(query) AS normalized_query_hash
FROM system.query_log
ORDER BY memory_usage DESC
LIMIT 10

Cuánto espacio en disco usan mis proyecciones

SELECT
    name,
    parent_name,
    formatReadableSize(bytes_on_disk) AS bytes,
    formatReadableSize(parent_bytes_on_disk) AS parent_bytes,
    bytes_on_disk / parent_bytes_on_disk AS ratio
FROM system.projection_parts

Mostrar el almacenamiento en disco, el número de partes, de filas en system.parts y de marks en todas las bases de datos

SELECT
    database,
    table,
    partition,
    count() AS parts,
    formatReadableSize(sum(bytes_on_disk)) AS bytes_on_disk,
    formatReadableQuantity(sum(rows)) AS rows,
    sum(marks) AS marks
FROM system.parts
WHERE (database != 'system') AND active
GROUP BY
    database,
    table,
    partition
ORDER BY database ASC

Mostrar los detalles de las partes nuevas escritas recientemente

Los detalles incluyen cuándo se crearon, su tamaño, cuántas filas contienen y más:

SELECT
    modification_time,
    rows,
    formatReadableSize(bytes_on_disk),
    *
FROM clusterAllReplicas(default, system.parts)
WHERE (database = 'default') AND active AND (level = 0)
ORDER BY modification_time DESC
LIMIT 100

Consultas de monitoreo de todo el clúster

Las siguientes consultas son útiles para monitorear clústeres de ClickHouse. Usan clusterAllReplicas() para agregar datos de todos los nodos.

Estas consultas asumen que su clúster se llama default. Si su clúster tiene un nombre distinto, reemplace 'default' y default por el nombre real de su clúster.

Promedio de nuevas partes creadas por minuto y por segundo (última hora)

WITH
    PER_MINUTE AS
    (
    SELECT
        toStartOfInterval(modification_time, toIntervalMinute(1)) AS t,
        count() AS new_part_count
    FROM
        clusterAllReplicas(default, merge(system, '^parts'))
    WHERE
        (database = 'default') AND
        (table = 'your_table') AND
        (active = true) AND
        (level = 0) AND
        (modification_time >= (now() - toIntervalHour(1)))
    GROUP BY
        t
    ORDER BY
        t ASC
    SETTINGS skip_unavailable_shards = 1
    )
SELECT
    AVG(new_part_count) AS new_parts_per_minute,
    new_parts_per_minute / 60 AS new_parts_per_second
FROM
    PER_MINUTE

Sustituya 'your_table' por el nombre real de la tabla que desea monitorizar.

Consultas con uso intensivo de CPU y memoria (en todo el clúster)

SELECT
    type,
    event_time,
    initial_query_id,
    formatReadableSize(memory_usage) AS memory,
    `ProfileEvents.Values`[indexOf(`ProfileEvents.Names`, 'UserTimeMicroseconds')] AS userCPU,
    `ProfileEvents.Values`[indexOf(`ProfileEvents.Names`, 'SystemTimeMicroseconds')] AS systemCPU,
    normalizedQueryHash(query) AS normalized_query_hash
FROM clusterAllReplicas(default, merge(system, '^query_log'))
ORDER BY memory_usage DESC
LIMIT 10

Fusiones en curso con ETA

Esta consulta muestra las fusiones que se están ejecutando actualmente en el clúster, con el tiempo estimado restante hasta su finalización:

SELECT
    hostName(),
    database,
    table,
    round(elapsed, 0) AS elapsed_seconds,
    round(progress, 4) AS progress_ratio,
    formatReadableTimeDelta((elapsed / progress) - elapsed) AS estimated_time_remaining,
    num_parts,
    result_part_name
FROM clusterAllReplicas(default, merge(system, '^merges'))
ORDER BY (elapsed / progress) - elapsed ASC

Consultas más comunes por hash normalizado

Encuentra las consultas que se ejecutan con mayor frecuencia (útil para identificar cuáles optimizar):

SELECT
    normalizedQueryHash(query) AS query_hash,
    count() AS execution_count,
    any(query) AS example_query
FROM clusterAllReplicas(default, merge(system, '^query_log'))
WHERE event_date >= today() - 1
GROUP BY normalizedQueryHash(query)
ORDER BY execution_count DESC
LIMIT 20

Número de errores por tipo de evento y fecha

Analice los errores de creación de partes en todo el clúster:

SELECT
    event_date,
    event_type,
    table,
    error,
    COUNT() AS error_count
FROM clusterAllReplicas(default, merge(system, '^part_log'))
WHERE database = 'default'
GROUP BY
    event_date,
    event_type,
    error,
    table
ORDER BY
    event_date DESC,
    error_count DESC

Número de tablas por nodo

Compruebe cómo se distribuyen las tablas entre los nodos del clúster:

SELECT
    hostName() AS host,
    count() AS table_count
FROM clusterAllReplicas('default', merge(system, '^tables'))
WHERE database = 'default'
GROUP BY hostName()
ORDER BY table_count DESC

Comprobar las operaciones de async insert

Supervise la actividad de async insert:

SELECT
    event_date,
    count() AS total_count,
    sum(if(query LIKE '%async%', 1, 0)) AS async_count,
    sum(if(query LIKE '%INSERT%', 1, 0)) AS insert_count
FROM clusterAllReplicas(default, merge(system, '^query_log'))
WHERE event_date >= today() - 7
GROUP BY event_date
ORDER BY event_date DESC

Análisis de partes y fusiones

Partes activas por tabla

Consulte el número de partes activas por tabla en todo el clúster:

SELECT
    database,
    table,
    count() AS part_count,
    formatReadableSize(sum(bytes_on_disk)) AS total_size
FROM clusterAllReplicas(default, system.parts)
WHERE active = 1 AND database = 'default'
GROUP BY database, table
ORDER BY part_count DESC

Particiones con demasiadas partes

Busque las particiones que puedan tener demasiadas partes (lo que puede afectar el rendimiento de las consultas):

SELECT
    database,
    table,
    partition,
    count() AS part_count,
    formatReadableSize(sum(bytes_on_disk)) AS total_size
FROM clusterAllReplicas(default, system.parts)
WHERE active = 1
GROUP BY database, table, partition
HAVING part_count > 100
ORDER BY part_count DESC

Partes desasociadas

Compruebe si hay partes desasociadas que puedan requerir investigación:

SELECT
    database,
    table,
    partition_id,
    name,
    reason,
    count()
FROM clusterAllReplicas(default, system.detached_parts)
GROUP BY database, table, partition_id, name, reason
ORDER BY database, table

Consultas sobre la información del sistema

Uso de memoria por nodo en todo el clúster

Supervise el consumo de memoria en todos los nodos:

SELECT
    hostName() AS host,
    formatReadableSize(max(memory_usage)) AS peak_memory,
    formatReadableSize(avg(memory_usage)) AS avg_memory,
    formatReadableSize(min(memory_usage)) AS min_memory
FROM clusterAllReplicas(default, merge(system, '^query_log'))
WHERE event_date >= today() - 1
GROUP BY hostName()
ORDER BY peak_memory DESC

Ejecutar consultas en el clúster

Compruebe qué consultas se están ejecutando actualmente:

SELECT
    hostName() AS host,
    initial_user,
    query_id,
    elapsed,
    read_rows,
    formatReadableSize(memory_usage) AS memory_usage,
    normalizedQueryHash(query) AS query_hash
FROM clusterAllReplicas(default, system.processes)
ORDER BY elapsed DESC

Ajustes modificados respecto de los valores predeterminados

Consulte qué ajustes se han modificado respecto de los valores predeterminados:

SELECT
    hostName() AS host,
    name,
    value
FROM clusterAllReplicas(default, system.settings)
WHERE changed = 1
ORDER BY hostName(), name

Estado de la cola de replicación

Para las tablas replicadas, compruebe la cola de replicación:

SELECT
    hostName() AS host,
    database,
    table,
    count() AS queue_size,
    sum(if(is_currently_executing = 1, 1, 0)) AS executing_count
FROM clusterAllReplicas(default, system.replication_queue)
GROUP BY hostName(), database, table
HAVING queue_size > 0
ORDER BY queue_size DESC

Última modificación el 12 de junio de 2026

Cómo usar ARRAY JOIN para extraer y consultar atributos variables con claves y valores de MapEjemplo sencillo para ilustrar cómo usar ARRAY JOIN para extraer y consultar atributos variables con claves y valores de Map

​Consultas útiles para resolver problemas

​Ver qué configuraciones se han modificado respecto a las predeterminadas

​Obtén el tamaño de todas tus tablas

​Número de filas y tamaño diario promedio de su tabla

​Porcentaje de compresión de las columnas, así como el tamaño del índice primario en memoria

​Número de consultas enviadas por el cliente en los últimos 10 minutos

​Número de partes en cada partición

​Encontrar consultas de ejecución prolongada

​Consultar los errores más recientes

​Las 10 consultas que más CPU y memoria consumen

​Cuánto espacio en disco usan mis proyecciones

​Mostrar el almacenamiento en disco, el número de partes, de filas en system.parts y de marks en todas las bases de datos

​Mostrar los detalles de las partes nuevas escritas recientemente

​Consultas de monitoreo de todo el clúster

​Promedio de nuevas partes creadas por minuto y por segundo (última hora)

​Consultas con uso intensivo de CPU y memoria (en todo el clúster)

​Fusiones en curso con ETA

​Consultas más comunes por hash normalizado

​Número de errores por tipo de evento y fecha

​Número de tablas por nodo

​Comprobar las operaciones de async insert

​Análisis de partes y fusiones

​Partes activas por tabla

​Particiones con demasiadas partes

​Partes desasociadas

​Consultas sobre la información del sistema

​Uso de memoria por nodo en todo el clúster

​Ejecutar consultas en el clúster

​Ajustes modificados respecto de los valores predeterminados

​Estado de la cola de replicación

Consultas útiles para resolver problemas

Ver qué configuraciones se han modificado respecto a las predeterminadas

Obtén el tamaño de todas tus tablas

Número de filas y tamaño diario promedio de su tabla

Porcentaje de compresión de las columnas, así como el tamaño del índice primario en memoria

Número de consultas enviadas por el cliente en los últimos 10 minutos

Número de partes en cada partición

Encontrar consultas de ejecución prolongada

Consultar los errores más recientes

Las 10 consultas que más CPU y memoria consumen

Cuánto espacio en disco usan mis proyecciones

Mostrar el almacenamiento en disco, el número de partes, de filas en system.parts y de marks en todas las bases de datos

Mostrar los detalles de las partes nuevas escritas recientemente

Consultas de monitoreo de todo el clúster

Promedio de nuevas partes creadas por minuto y por segundo (última hora)

Consultas con uso intensivo de CPU y memoria (en todo el clúster)

Fusiones en curso con ETA

Consultas más comunes por hash normalizado

Número de errores por tipo de evento y fecha

Número de tablas por nodo

Comprobar las operaciones de async insert

Análisis de partes y fusiones

Partes activas por tabla

Particiones con demasiadas partes

Partes desasociadas

Consultas sobre la información del sistema

Uso de memoria por nodo en todo el clúster

Ejecutar consultas en el clúster

Ajustes modificados respecto de los valores predeterminados

Estado de la cola de replicación