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

# Consultas útiles para solucionar problemas

> Una colección de consultas prácticas para solucionar problemas de ClickHouse, que incluye cómo supervisar el tamaño de las tablas, las consultas de larga duración y los errores.

{frontMatter.description}

<div id="useful-queries-for-troubleshooting">
  ## Consultas útiles para resolver problemas
</div>

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](https://clickhouse.com/blog/monitoring-troubleshooting-select-queries-clickhouse).

<div id="view-which-settings-have-been-changed-from-the-default">
  ## Ver qué configuraciones se han modificado respecto a las predeterminadas
</div>

```sql theme={null}
SELECT
    name,
    value
FROM system.settings
WHERE changed
```

<div id="get-the-size-of-all-your-tables">
  ## Obtén el tamaño de todas tus tablas
</div>

```sql theme={null}
SELECT table,
    formatReadableSize(sum(bytes)) as size
    FROM system.parts
    WHERE active
GROUP BY table
```

La respuesta tiene este aspecto:

```response theme={null}
┌─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  │
└─────────────────┴───────────┘
```

<div id="row-count-and-average-day-size-of-your-table">
  ## Número de filas y tamaño diario promedio de su tabla
</div>

```sql theme={null}
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
)
```

<div id="compression-columns-percentage-as-well-as-the-size-of-primary-index-in-memory">
  ## Porcentaje de compresión de las columnas, así como el tamaño del índice primario en memoria
</div>

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.

```sql theme={null}
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
```

<div id="number-of-queries-sent-by-client-in-the-last-10-minutes">
  ## Número de consultas enviadas por el cliente en los últimos 10 minutos
</div>

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

```sql theme={null}
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
```

<div id="number-of-parts-in-each-partition">
  ## Número de partes en cada partición
</div>

```sql theme={null}
SELECT
    concat(database, '.', table),
    partition_id,
    count()
FROM system.parts
WHERE active
GROUP BY
    database,
    table,
    partition_id
```

<div id="finding-long-running-queries">
  ## Encontrar consultas de ejecución prolongada
</div>

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

```sql theme={null}
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';
```

<div id="view-the-most-recent-errors">
  ## Consultar los errores más recientes
</div>

```
SELECT *
FROM system.errors
ORDER BY last_error_time DESC
```

La respuesta tiene este aspecto:

```response theme={null}
┌─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 │
└───────────────────────┴──────┴───────┴─────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────────┴────────┘
```

<div id="top-10-queries-that-are-using-the-most-cpu-and-memory">
  ## Las 10 consultas que más CPU y memoria consumen
</div>

```sql theme={null}
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
```

<Note>
  Una sola consulta puede registrarse como varias filas con distintos valores de `query_id`: las consultas secundarias distribuidas y los pasos internos de las vistas tienen `is_initial_query = 0`. Filtre por `is_initial_query = 1` (o `query_id = initial_query_id`) para ver las consultas tal como se enviaron, y tenga en cuenta que los valores internos de `query_id` que asigna ClickHouse pueden incluir una etiqueta como `queryView...`. Consulte la [referencia de `query_log`](/es/reference/system-tables/query_log) para obtener más información.
</Note>

<div id="how-much-disk-space-are-my-projection-using">
  ## Cuánto espacio en disco usan mis proyecciones
</div>

```sql theme={null}
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
```

<div id="show-disk-storage-number-of-parts-number-of-rows-in-systemparts-and-marks-across-databases">
  ## Mostrar el almacenamiento en disco, el número de partes, de filas en system.parts y de marks en todas las bases de datos
</div>

```sql theme={null}
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
```

<div id="list-details-of-recently-written-new-parts">
  ## Mostrar los detalles de las partes nuevas escritas recientemente
</div>

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

```sql theme={null}
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
```

<div id="cluster-wide-monitoring-queries">
  ## Consultas de monitoreo de todo el clúster
</div>

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

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

<div id="avg-new-parts-per-minute-and-second">
  ### Promedio de nuevas partes creadas por minuto y por segundo (última hora)
</div>

```sql theme={null}
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.

<div id="cpu-and-memory-intensive-queries-cluster-wide">
  ### Consultas con uso intensivo de CPU y memoria (en todo el clúster)
</div>

```sql theme={null}
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
```

<div id="merges-in-progress-with-eta">
  ### Fusiones en curso con ETA
</div>

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

```sql theme={null}
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
```

<div id="most-common-queries-by-normalized-hash">
  ### Consultas más comunes por hash normalizado
</div>

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

```sql theme={null}
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
```

<div id="error-counts-by-event-type-and-date">
  ### Número de errores por tipo de evento y fecha
</div>

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

```sql theme={null}
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
```

<div id="number-of-tables-by-node">
  ### Número de tablas por nodo
</div>

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

```sql theme={null}
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
```

<div id="check-for-async-insert-operations">
  ### Comprobar las operaciones de async insert
</div>

Supervise la actividad de async insert:

```sql theme={null}
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
```

<div id="parts-and-merges-analysis">
  ## Análisis de partes y fusiones
</div>

<div id="currently-active-parts-by-table">
  ### Partes activas por tabla
</div>

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

```sql theme={null}
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
```

<div id="partitions-with-too-many-parts">
  ### Particiones con demasiadas partes
</div>

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

```sql theme={null}
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
```

<div id="detached-parts">
  ### Partes desasociadas
</div>

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

```sql theme={null}
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
```

<div id="system-information-queries">
  ## Consultas sobre la información del sistema
</div>

<div id="cluster-wide-memory-usage-by-node">
  ### Uso de memoria por nodo en todo el clúster
</div>

Supervise el consumo de memoria en todos los nodos:

```sql theme={null}
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
```

<div id="running-queries-on-the-cluster">
  ### Ejecutar consultas en el clúster
</div>

Compruebe qué consultas se están ejecutando actualmente:

```sql theme={null}
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
```

<div id="modified-settings-from-defaults">
  ### Ajustes modificados respecto de los valores predeterminados
</div>

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

```sql theme={null}
SELECT
    hostName() AS host,
    name,
    value
FROM clusterAllReplicas(default, system.settings)
WHERE changed = 1
ORDER BY hostName(), name
```

<div id="replication-queue-status">
  ### Estado de la cola de replicación
</div>

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

```sql theme={null}
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
```