> ## 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.

# Lecture synchrone des données

> Le nouveau paramètre `allow_asynchronous_read_from_io_pool_for_merge_tree` permet que le nombre de threads de lecture (flux) soit supérieur au nombre de threads dans le reste du pipeline d’exécution de la requête.

Le nouveau paramètre allow\_asynchronous\_read\_from\_io\_pool\_for\_merge\_tree permet que le nombre de threads de lecture (flux) soit supérieur au nombre de threads dans le reste du pipeline d’exécution de la requête.

Normalement, le paramètre [max\_threads](/fr/reference/settings/session-settings#max_threads) [contrôle](https://clickhouse.com/company/events/query-performance-introspection) le nombre de threads de lecture parallèles et de threads de traitement des requêtes parallèles :

<Image img={sync_read} size="md" alt="Schéma de lecture synchrone des données" />

Les données sont lues « dans l’ordre », colonne après colonne, à partir du disque.

<div id="asynchronous-data-reading">
  ### Lecture asynchrone des données
</div>

Le nouveau paramètre [allow\_asynchronous\_read\_from\_io\_pool\_for\_merge\_tree](https://github.com/ClickHouse/ClickHouse/pull/43260) permet d’avoir plus de threads de lecture (flux) que de threads dans le reste du pipeline d’exécution des requêtes afin d’**accélérer les requêtes à froid sur des services ClickHouse Cloud à faible capacité CPU** et d’**améliorer les performances des requêtes limitées par les E/S**.
Lorsque ce paramètre est activé, le nombre de threads de lecture est contrôlé par le paramètre [max\_streams\_for\_merge\_tree\_reading](https://github.com/ClickHouse/ClickHouse/pull/43260) :

<Image img={async_read} size="md" alt="Schéma de lecture asynchrone des données" />

Les données sont lues de manière asynchrone, en parallèle, à partir de différentes colonnes.

Notez qu’il existe également le paramètre [max\_streams\_to\_max\_threads\_ratio](https://github.com/ClickHouse/ClickHouse/pull/43260) pour configurer le ratio entre le nombre de threads de lecture (flux) et le nombre de threads dans le reste du pipeline d’exécution des requêtes. Cependant, lors des benchmarks, il n’a pas été aussi utile que le paramètre `max_streams_for_merge_tree_reading`

<div id="what-about-optimize_read_in_order">
  ### Qu’en est-il d’optimize\_read\_in\_order ?
</div>

Avec l’[optimize\_read\_in\_order optimization](/fr/reference/statements/select/order-by#optimization-of-data-reading), ClickHouse peut [éviter](https://clickhouse.com/blog/clickhouse-faster-queries-with-projections-and-primary-indexes) de retrier les données en mémoire si l’ordre de tri des requêtes reflète l’ordre physique des données sur le disque, **mais cela exige de lire les données dans l’ordre (par opposition à une lecture asynchrone)** :

<Image img={optimize_read} size="md" alt="Schéma d’optimisation de la lecture dans l’ordre" />

<div id="optimize_read_in_order-has-precedence-over-asynchronous-reading">
  ### optimize\_read\_in\_order est prioritaire sur la lecture asynchrone
</div>

Lorsque ClickHouse constate que `optimize_read_in_order optimization` peut être appliquée, le paramètre `allow_asynchronous_read_from_io_pool_for_merge_tree` est alors ignoré / désactivé.

<div id="example-demonstrating-all-of-the-above">
  ### Exemple illustrant tout ce qui précède
</div>

* Créez et chargez la [table UK Property Price Paid](/fr/get-started/sample-datasets/uk-price-paid)

* Vérifiez la valeur définie de max\_threads (par défaut, le nombre de cœurs de CPU que ClickHouse voit sur le nœud exécutant la requête

```
SELECT getSetting('max_threads');

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

* Vérifier le pipeline d’exécution de la requête avec le nombre de threads par défaut, pour la lecture comme pour le traitement des données

```
EXPLAIN PIPELINE
SELECT *
FROM uk_price_paid;

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

* Vérifiez le pipeline de la requête avec 60 threads de lecture asynchrones et le nombre de threads par défaut pour le reste du pipeline d’exécution de la requête

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

* Vérifiez le pipeline d’exécution de la requête avec 20 threads pour la lecture et le traitement des données

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

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

* Vérifiez le pipeline de requête avec 60 threads de lecture asynchrone et 20 autres pour le reste du pipeline d’exécution de la requête

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

* Vérifiez le pipeline de requête avec 60 threads de lecture asynchrone et 20 threads pour le reste du pipeline d’exécution de la requête
  lorsque l’optimisation `optimize_read_in_order optimization` peut être appliquée

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

-- note that this is equivalent to disabling 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 │
└───────────────────────────────────┘

-- note that you can enforce allow_asynchronous_read_from_io_pool_for_merge_tree by disabling 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 │
└──────────────────────────────────────┘

```