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

# paramètres de session max_insert_*

> Paramètres de session ClickHouse du groupe généré max_insert_*.

export const VersionHistory = ({rows = []}) => {
  if (rows.length === 0) {
    return null;
  }
  const headers = ["Version", "Valeur par défaut", "Commentaire"];
  const border = "1px solid rgba(128, 128, 128, 0.3)";
  const cell = {
    border,
    padding: "0.25rem 0.5rem",
    textAlign: "start",
    verticalAlign: "top"
  };
  return <details className="not-prose" style={{
    border,
    borderRadius: "0.5rem",
    margin: "0.5rem 0",
    padding: "0.5rem 0.75rem",
    fontSize: "0.8125rem",
    lineHeight: "1.125rem"
  }}>
      <summary style={{
    cursor: "pointer",
    fontWeight: 600,
    opacity: 0.72
  }}>
        Historique des versions
      </summary>
      <table style={{
    borderCollapse: "collapse",
    width: "100%",
    margin: "0.5rem 0 0"
  }}>
        <thead>
          <tr>
            {headers.map(header => <th key={header} style={{
    ...cell,
    fontWeight: 600,
    opacity: 0.72
  }}>
                {header}
              </th>)}
          </tr>
        </thead>
        <tbody>
          {rows.map((row, row_index) => <tr key={row.id ?? row_index}>
              {(row.items ?? []).map((item, item_index) => <td key={item_index} style={{
    ...cell,
    overflowWrap: "anywhere"
  }}>
                  {item?.label}
                </td>)}
            </tr>)}
        </tbody>
      </table>
    </details>;
};

export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
  return <div className="not-prose" style={{
    display: "flex",
    flexWrap: "wrap",
    alignItems: "baseline",
    columnGap: "0.5rem",
    rowGap: "0.125rem",
    margin: "0.375rem 0",
    fontSize: "0.8125rem",
    lineHeight: "1.125rem"
  }}>
      <div style={{
    fontWeight: 600,
    opacity: 0.72
  }}>Type</div>
      <div style={{
    overflowWrap: "anywhere"
  }}>{type}</div>
      <div style={{
    fontWeight: 600,
    opacity: 0.72,
    marginInlineStart: "0.5rem"
  }}>Par défaut</div>
      <div style={{
    overflowWrap: "anywhere"
  }}>{default_value}</div>
      {changeable_without_restart && <div style={{
    fontWeight: 600,
    opacity: 0.72,
    marginInlineStart: "0.5rem"
  }}>
          Modifiable sans redémarrage
        </div>}
      {changeable_without_restart && <div style={{
    overflowWrap: "anywhere"
  }}>
          {changeable_without_restart}
        </div>}
    </div>;
};

Ces paramètres sont disponibles dans [system.settings](/fr/reference/system-tables/settings) et sont générés automatiquement à partir du [code source](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/Settings.cpp).

<div id="max_insert_block_size">
  ## max\_insert\_block\_size
</div>

**Alias** : `max_insert_block_size_rows`

<SettingsInfoBlock type="NonZeroUInt64" default_value="1048449" />

Taille maximale des blocs (en nombre de lignes) à former pour l'insertion dans une table.

Ce paramètre contrôle la formation des blocs dans deux contextes :

1. Analyse des formats : lorsque le serveur analyse des formats d'entrée orientés lignes (CSV, TSV, JSONEachRow, etc.) depuis n'importe quelle interface (HTTP, clickhouse-client avec des données intégrées, gRPC, protocole wire de PostgreSQL), les blocs sont émis lorsque :

   * Les deux seuils min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes sont atteints, OR
   * L'un des deux seuils max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes est atteint

   Remarque : lorsque vous utilisez clickhouse-client ou clickhouse-local pour lire à partir d'un fichier, c'est le client lui-même qui analyse les données, et ce paramètre s'applique côté client.

2. Opérations INSERT : pendant les requêtes INSERT et lorsque les données transitent par des vues matérialisées, le comportement de ce paramètre dépend de `use_strict_insert_block_limits` :

   * Lorsqu'il est activé : les blocs sont émis lorsque :
     * Seuils minimums (AND) : les deux seuils min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes sont atteints
     * Seuils maximums (OR) : l'un des deux seuils max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes est atteint

   * Lorsqu'il est désactivé : les blocs sont émis lorsque min\_insert\_block\_size\_rows OR min\_insert\_block\_size\_bytes est atteint. Les paramètres max\_insert\_block\_size ne sont pas appliqués.

Valeurs possibles :

* Entier positif.

<div id="max_insert_block_size_bytes">
  ## max\_insert\_block\_size\_bytes
</div>

<SettingsInfoBlock type="UInt64" default_value="0" />

<VersionHistory rows={[{"id": "row-1","items": [{"label": "26.1"},{"label": "0"},{"label": "Nouveau paramètre permettant de contrôler la taille des blocs, en octets, lors de l'analyse des données dans un format d'entrée de type ligne."}]}]} />

Taille maximale des blocs (en octets) à former pour l'insertion dans une table.

Ce paramètre fonctionne avec max\_insert\_block\_size\_rows et contrôle la formation des blocs dans le même contexte. Consultez max\_insert\_block\_size\_rows pour savoir en détail quand et comment ces paramètres sont appliqués.

Valeurs possibles :

* Entier positif.
* 0 — le paramètre n'entre pas en compte dans la formation des blocs.

<div id="max_insert_delayed_streams_for_parallel_write">
  ## max\_insert\_delayed\_streams\_for\_parallel\_write
</div>

<SettingsInfoBlock type="UInt64" default_value="0" />

Le nombre maximal de flux (colonnes) pour lesquels le flush final des parts est retardé. Par défaut : auto (100 si le stockage sous-jacent prend en charge l’écriture parallèle, par exemple S3, et désactivé dans le cas contraire)

Valeur par défaut dans Cloud : `50`.

<div id="max_insert_threads">
  ## max\_insert\_threads
</div>

<SettingsInfoBlock type="MaxThreads" default_value="auto(N)" />

<VersionHistory rows={[{"id": "row-1","items": [{"label": "26.8"},{"label": "0"},{"label": "La valeur par défaut est passée de 1 (sans exécution parallèle) à auto (0), qui correspond au nombre de cœurs de processeur disponibles sur le serveur, réduit en cas de pression mémoire par `max_insert_threads_min_free_memory_per_thread`. Cela parallélise `INSERT SELECT` par défaut. Définissez cette valeur sur 1 pour restaurer l'ancien comportement monothread."}]}]} />

Le nombre maximal de threads utilisés pour exécuter la requête `INSERT`.

Ce paramètre s'applique à la fois à `INSERT SELECT` et à un simple `INSERT` dont les données sont envoyées depuis
`clickhouse-client` ou via l'interface HTTP. La partie écriture du pipeline
(regroupement des blocs et écriture dans la table de destination) est parallélisée
sur un maximum de ce nombre de threads.

Valeurs possibles :

* 0 — Auto. Utilise le nombre de cœurs de processeur disponibles sur le serveur (la même valeur automatique que [`max_threads`](/fr/reference/settings/session-settings/max-threads#max_threads)), réduit en cas de pression mémoire par [`max_insert_threads_min_free_memory_per_thread`](/fr/reference/settings/session-settings/max-insert#max_insert_threads_min_free_memory_per_thread).
* 1 — l'`INSERT` est exécuté dans un seul thread (sans exécution parallèle). Utilisez cette valeur pour préserver l'ordre d'insertion de `INSERT ... SELECT`.
* Entier positif supérieur à 1 — Exécution parallèle avec le nombre de threads indiqué.

Avant la version 26.8, la valeur par défaut était `1` (sans exécution parallèle). Depuis la version 26.8, la valeur par défaut (`0`) correspond au nombre de cœurs de processeur ; `INSERT` est donc parallélisé par défaut. Définissez `max_insert_threads` sur `1` (ou utilisez le paramètre `compatibility`) pour restaurer le comportement précédent.

Valeur par défaut dans Cloud :

* `1` pour les nœuds disposant de 8 Gio de mémoire
* `2` pour les nœuds disposant de 16 Gio de mémoire
* `4` pour les nœuds plus grands

L'`INSERT SELECT` parallèle n'a d'effet que si la partie `SELECT` est exécutée en parallèle ; consultez le paramètre [`max_threads`](/fr/reference/settings/session-settings/max-threads#max_threads).
Pour un simple `INSERT`, les données d'entrée sont lues et analysées dans un seul flux, puis le pipeline est redimensionné en ce nombre de flux pour l'écriture.
La parallélisation de la partie écriture s'applique uniquement aux simples `INSERT` synchrones : les insertions asynchrones ([`async_insert`](/fr/reference/settings/session-settings/async-insert#async_insert) `= 1`) sont placées dans une file d'attente et flushées en arrière-plan ; elles ne sont donc pas affectées par ce paramètre et restent toujours sur un seul flux.
La partie écriture n'est parallélisée que lorsque cela ne pose aucun risque ; sinon, elle reste sur un seul flux et ce paramètre n'a aucun effet. En particulier, l'écriture reste sur un seul flux lorsque [`use_strict_insert_block_limits`](/fr/reference/settings/session-settings/use#use_strict_insert_block_limits) est activé, qu'une table de destination (ou une table vers laquelle elle redirige) déduplique les blocs insérés et que la déduplication des insertions est activée pour la requête (consultez [`deduplicate_insert`](/fr/reference/settings/session-settings/deduplicate-insert#deduplicate_insert)), lorsque la destination possède des vues matérialisées dépendantes — y compris des vues d'une table vers laquelle la destination redirige, par exemple derrière un `Alias` — (sauf si [`parallel_view_processing`](/fr/reference/settings/session-settings/parallel#parallel_view_processing) est activé et que les chaînes de vues dépendantes ne présentent aucun risque de déduplication — la déduplication dans les vues est désactivée ([`deduplicate_blocks_in_dependent_materialized_views`](/fr/reference/settings/session-settings/other#deduplicate_blocks_in_dependent_materialized_views)) ou aucun chemin de vue dépendante ne peut dédupliquer), et systématiquement pour les destinations `Buffer` et `Distributed`. Un `Buffer` effectue son flush dans son propre contexte et un `Distributed` transmet l'écriture à un fragment distant (qui peut lui-même mettre les données en mémoire tampon) ; les paramètres de déduplication de cette requête ne régissent donc pas l'écriture finale, qui reste sur un seul flux indépendamment de ces paramètres. Une insertion par quorum non parallèle ([`insert_quorum`](/fr/reference/settings/session-settings/insert-quorum#insert_quorum) est égal à `2` ou plus, ou à `'auto'`, et [`insert_quorum_parallel`](/fr/reference/settings/session-settings/insert-quorum#insert_quorum_parallel) est désactivé) reste également sur un seul flux, car elle n'autorise qu'une seule part de quorum en cours par table.
Des valeurs plus élevées entraînent une utilisation accrue de la mémoire.

<div id="max_insert_threads_min_free_memory_per_thread">
  ## max\_insert\_threads\_min\_free\_memory\_per\_thread
</div>

<SettingsInfoBlock type="UInt64" default_value="4294967296" />

<VersionHistory rows={[{"id": "row-1","items": [{"label": "26.5"},{"label": "4294967296"},{"label": "Nouveau paramètre pour limiter le nombre de threads d’insertion en fonction de la mémoire libre disponible"}]}]} />

Identique à `max_threads_min_free_memory_per_thread`, mais appliqué à `max_insert_threads` plutôt qu’à `max_threads`. La valeur par défaut est plus élevée, car les pipelines d’insertion utilisent généralement des buffers par thread plus volumineux (parts MergeTree, blocs de compression) que les pipelines de lecture.

Si la quantité de mémoire libre est inférieure à `max_insert_threads` multiplié par cette valeur, `max_insert_threads` est réduit en conséquence, avec un minimum de `1`.

Définissez cette valeur sur `0` pour désactiver cette limite.