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

# Lectura síncrona de datos

> El nuevo ajuste `allow_asynchronous_read_from_io_pool_for_merge_tree` permite que el número de hilos de lectura (stream) sea mayor que el número de hilos en el resto del pipeline de ejecución de la consulta.

El nuevo ajuste allow\_asynchronous\_read\_from\_io\_pool\_for\_merge\_tree permite que el número de hilos de lectura (stream) sea mayor que el número de hilos en el resto del pipeline de ejecución de la consulta.

Normalmente, el ajuste [max\_threads](/es/reference/settings/session-settings#settings-max_threads) [controla](https://clickhouse.com/company/events/query-performance-introspection) el número de hilos de lectura en paralelo y de hilos de procesamiento de consultas en paralelo:

<Image img={sync_read} size="md" alt="Diagrama de lectura síncrona de datos" />

Los datos se leen «en orden», columna a columna, desde el disco.

<div id="asynchronous-data-reading">
  ### Lectura asíncrona de datos
</div>

La nueva configuración [allow\_asynchronous\_read\_from\_io\_pool\_for\_merge\_tree](https://github.com/ClickHouse/ClickHouse/pull/43260) permite que el número de hilos de lectura (streams) sea mayor que el número de hilos del resto del pipeline de ejecución de la consulta para **acelerar las consultas en frío en servicios de ClickHouse Cloud con pocos recursos de CPU** y **aumentar el rendimiento de las consultas limitadas por la E/S**.
Cuando esta configuración está habilitada, el número de hilos de lectura se controla mediante la configuración [max\_streams\_for\_merge\_tree\_reading](https://github.com/ClickHouse/ClickHouse/pull/43260):

<Image img={async_read} size="md" alt="Diagrama de lectura asíncrona de datos" />

Los datos se leen de forma asíncrona, en paralelo, desde distintas columnas.

Tenga en cuenta que también existe la configuración [max\_streams\_to\_max\_threads\_ratio](https://github.com/ClickHouse/ClickHouse/pull/43260) para definir la proporción entre el número de hilos de lectura (streams) y el número de hilos del resto del pipeline de ejecución de la consulta. Sin embargo, en las pruebas de rendimiento no resultó tan útil como la configuración `max_streams_for_merge_tree_reading`

<div id="what-about-optimize_read_in_order">
  ### ¿Y optimize\_read\_in\_order?
</div>

Con la [optimización optimize\_read\_in\_order](/es/reference/statements/select/order-by#optimization-of-data-reading), ClickHouse puede [evitar](https://clickhouse.com/blog/clickhouse-faster-queries-with-projections-and-primary-indexes) reordenar los datos en memoria si el orden de clasificación de las consultas refleja el orden físico de los datos en disco, **pero eso requiere leer los datos en orden (a diferencia de la lectura asíncrona)**:

<Image img={optimize_read} size="md" alt="Diagrama de optimize_read_in_order" />

<div id="optimize_read_in_order-has-precedence-over-asynchronous-reading">
  ### La optimización optimize\_read\_in\_order tiene prioridad sobre la lectura asíncrona
</div>

Cuando ClickHouse detecta que puede aplicarse la optimización `optimize_read_in_order`, se ignorará o deshabilitará la configuración `allow_asynchronous_read_from_io_pool_for_merge_tree`.

<div id="example-demonstrating-all-of-the-above">
  ### Ejemplo que demuestra todo lo anterior
</div>

* Cree y cargue la [tabla UK Property Price Paid](/es/get-started/sample-datasets/uk-price-paid)

* Compruebe el valor configurado de max\_threads (de forma predeterminada, es la cantidad de núcleos de CPU que ClickHouse ve en el nodo que ejecuta la consulta

```
SELECT getSetting('max_threads');

┌─getSetting('max_threads')─┐
│                        10 │
└───────────────────────────┘
```

* Comprueba el pipeline de consulta con el número predeterminado de hilos tanto para leer como para procesar los datos

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid;

┌─explain──────────────────────┐
│ (Expression)                 │
│ ExpressionTransform × 10     │
│   (ReadFromMergeTree)        │
│   MergeTreeThread × 10 0 → 1 │
└──────────────────────────────┘
```

* Compruebe el pipeline de la consulta con 60 hilos de lectura asíncrona y el número predeterminado de hilos para el resto del pipeline de ejecución de la consulta

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid
SETTINGS
    allow_asynchronous_read_from_io_pool_for_merge_tree = 1,
    max_streams_for_merge_tree_reading = 60;

┌─explain────────────────────────┐
│ (Expression)                   │
│ ExpressionTransform × 10       │
│   (ReadFromMergeTree)          │
│   Resize 60 → 10               │
│     MergeTreeThread × 60 0 → 1 │
└────────────────────────────────┘
```

* Compruebe el pipeline de consulta con 20 hilos tanto para leer como para procesar los datos

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid
SETTINGS
    max_threads = 20;

┌─explain──────────────────────┐
│ (Expression)                 │
│ ExpressionTransform × 20     │
│   (ReadFromMergeTree)        │
│   MergeTreeThread × 20 0 → 1 │
└──────────────────────────────┘
```

* Compruebe el pipeline de consulta con 60 hilos de lectura asíncrona y 20 hilos para el resto del pipeline de ejecución de la consulta

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid
SETTINGS
    max_threads = 20,
    allow_asynchronous_read_from_io_pool_for_merge_tree = 1,
    max_streams_for_merge_tree_reading = 60;

┌─explain────────────────────────┐
│ (Expression)                   │
│ ExpressionTransform × 20       │
│   (ReadFromMergeTree)          │
│   Resize 60 → 20               │
│     MergeTreeThread × 60 0 → 1 │
└────────────────────────────────┘
```

* Verifique el pipeline de consulta con 60 hilos de lectura asíncrona y 20 hilos para el resto del pipeline de ejecución de la consulta
  cuando puede aplicarse `optimize_read_in_order optimization`

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid
ORDER BY postcode1, postcode2
SETTINGS
    max_threads = 20,
    allow_asynchronous_read_from_io_pool_for_merge_tree= 1,
    max_streams_for_merge_tree_reading= 60;

┌─explain───────────────────────────┐
│ (Expression)                      │
│ ExpressionTransform               │
│   (Sorting)                       │
│   MergingSortedTransform 20 → 1   │
│     (Expression)                  │
│     ExpressionTransform × 20      │
│       (ReadFromMergeTree)         │
│       MergeTreeInOrder × 20 0 → 1 │
└───────────────────────────────────┘

-- nota: esto es equivalente a deshabilitar allow_asynchronous_read_from_io_pool_for_merge_tree

EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid
ORDER BY postcode1, postcode2
SETTINGS
    max_threads = 20,
    allow_asynchronous_read_from_io_pool_for_merge_tree = 0,
    max_streams_for_merge_tree_reading = 0;

┌─explain───────────────────────────┐
│ (Expression)                      │
│ ExpressionTransform               │
│   (Sorting)                       │
│   MergingSortedTransform 20 → 1   │
│     (Expression)                  │
│     ExpressionTransform × 20      │
│       (ReadFromMergeTree)         │
│       MergeTreeInOrder × 20 0 → 1 │
└───────────────────────────────────┘

-- nota: puedes forzar allow_asynchronous_read_from_io_pool_for_merge_tree deshabilitando optimize_read_in_order

EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid
ORDER BY
    postcode1 ASC,
    postcode2 ASC
SETTINGS
    max_threads = 20,
    allow_asynchronous_read_from_io_pool_for_merge_tree = 1,
    max_streams_for_merge_tree_reading = 60,
    optimize_read_in_order = 0;

┌─explain──────────────────────────────┐
│ (Expression)                         │
│ ExpressionTransform                  │
│   (Sorting)                          │
│   MergingSortedTransform 20 → 1      │
│     MergeSortingTransform × 20       │
│       (Expression)                   │
│       ExpressionTransform × 20       │
│         (ReadFromMergeTree)          │
│         Resize 60 → 20               │
│           MergeTreeThread × 60 0 → 1 │
└──────────────────────────────────────┘

```