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

# Leitura síncrona de dados

> A nova configuração `allow_asynchronous_read_from_io_pool_for_merge_tree` permite que o número de threads de leitura (streams) seja maior do que o número de threads no restante do pipeline de execução da consulta.

A nova configuração allow\_asynchronous\_read\_from\_io\_pool\_for\_merge\_tree permite que o número de threads de leitura (streams) seja maior do que o número de threads no restante do pipeline de execução da consulta.

Normalmente, a configuração [max\_threads](/pt-BR/reference/settings/session-settings#max_threads) [controla](https://clickhouse.com/company/events/query-performance-introspection) o número de threads de leitura paralelas e de processamento paralelo da consulta:

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

Os dados são lidos 'em ordem', coluna por coluna, do disco.

<div id="asynchronous-data-reading">
  ### Leitura assíncrona de dados
</div>

A nova configuração [allow\_asynchronous\_read\_from\_io\_pool\_for\_merge\_tree](https://github.com/ClickHouse/ClickHouse/pull/43260) permite que o número de threads de leitura (streams) seja maior do que o número de threads no restante do pipeline de execução da consulta para **acelerar consultas sem cache em serviços ClickHouse Cloud com pouca CPU** e **aumentar o desempenho de consultas limitadas por I/O**.
Quando a configuração está habilitada, a quantidade de threads de leitura é controlada pela configuração [max\_streams\_for\_merge\_tree\_reading](https://github.com/ClickHouse/ClickHouse/pull/43260):

<Image img={async_read} size="md" alt="Diagrama de leitura assíncrona de dados" />

Os dados são lidos de forma assíncrona, em paralelo, a partir de diferentes colunas.

Observe que também existe a configuração [max\_streams\_to\_max\_threads\_ratio](https://github.com/ClickHouse/ClickHouse/pull/43260) para configurar a proporção entre o número de threads de leitura (streams) e o número de threads no restante do pipeline de execução da consulta. No entanto, em benchmarks, ela não ajudou tanto quanto a configuração `max_streams_for_merge_tree_reading`

<div id="what-about-optimize_read_in_order">
  ### E quanto ao optimize\_read\_in\_order?
</div>

Com a [otimização optimize\_read\_in\_order](/pt-BR/reference/statements/select/order-by#optimization-of-data-reading), o ClickHouse pode [evitar](https://clickhouse.com/blog/clickhouse-faster-queries-with-projections-and-primary-indexes) reordenar os dados na memória se a ordenação das consultas refletir a ordem física dos dados em disco, **mas isso exige ler os dados em ordem (em contraste com a leitura assíncrona)**:

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

<div id="optimize_read_in_order-has-precedence-over-asynchronous-reading">
  ### A otimização optimize\_read\_in\_order tem precedência sobre a leitura assíncrona
</div>

Quando o ClickHouse detecta que `otimização optimize_read_in_order` pode ser aplicada, a configuração `allow_asynchronous_read_from_io_pool_for_merge_tree` será ignorada/desativada.

<div id="example-demonstrating-all-of-the-above">
  ### Exemplo que demonstra tudo o que foi explicado acima
</div>

* Crie e carregue a [tabela UK Property Price Paid](/pt-BR/get-started/sample-datasets/uk-price-paid)

* Verifique o valor configurado de max\_threads (por padrão, a quantidade de núcleos de CPU que o ClickHouse vê no nó que executa a consulta

```
SELECT getSetting('max_threads');

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

* Verifique o pipeline da consulta com o número padrão de threads para leitura e processamento dos dados

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid;

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

* Verifique o pipeline da consulta com 60 threads de leitura assíncrona e o número padrão de threads para o restante do pipeline de execução da 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 │
└────────────────────────────────┘
```

* Verifique o pipeline da consulta com 20 threads, tanto para a leitura quanto para o processamento dos dados

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

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

* Verifique o pipeline da consulta com 60 threads para leitura assíncrona e 20 threads para o restante do pipeline de execução da 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 o pipeline da consulta com 60 threads de leitura assíncrona e 20 threads para o restante do pipeline de execução da consulta
  quando a otimização `optimize_read_in_order` puder ser aplicada

```
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 │
└───────────────────────────────────┘

-- observe que isso é equivalente a desabilitar 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 │
└───────────────────────────────────┘

-- observe que você pode forçar allow_asynchronous_read_from_io_pool_for_merge_tree desabilitando 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 │
└──────────────────────────────────────┘

```