}`. Pour la liaison côté serveur, l’argument `parameters` doit être un dictionnaire Python.
* Liaison côté serveur avec dictionnaire Python, valeur DateTime et valeur de chaîne de caractères
```python theme={null}
import datetime
my_date = datetime.datetime(2022, 10, 1, 15, 20, 5)
parameters = {'table': 'my_table', 'v1': my_date, 'v2': "a string with a single quote'"}
client.query('SELECT * FROM {table:Identifier} WHERE date >= {v1:DateTime} AND string ILIKE {v2:String}', parameters=parameters)
```
Cela génère la requête suivante sur le serveur :
```sql theme={null}
SELECT *
FROM my_table
WHERE date >= '2022-10-01 15:20:05'
AND string ILIKE 'a string with a single quote\''
```
La liaison côté serveur n’est prise en charge (par le serveur ClickHouse) que pour les requêtes `SELECT`. Elle ne fonctionne pas pour `ALTER`, `DELETE`, `INSERT` ni pour d’autres types de requêtes. Cela pourrait changer à l’avenir ; voir [https://github.com/ClickHouse/ClickHouse/issues/42092](https://github.com/ClickHouse/ClickHouse/issues/42092).
#### Liaison côté client
ClickHouse Connect prend également en charge la liaison de paramètres côté client, ce qui offre davantage de souplesse pour générer des requêtes SQL basées sur des modèles. Pour la liaison côté client, l’argument `parameters` doit être un dictionnaire ou une séquence. La liaison côté client utilise le formatage de chaînes Python [de style "printf"](https://docs.python.org/3/library/stdtypes.html#old-string-formatting) pour la substitution des paramètres.
Notez que, contrairement à la liaison côté serveur, la liaison côté client ne fonctionne pas pour les identifiants de base de données tels que les noms de base de données, de table ou de colonne, car le formatage de style Python ne permet pas de distinguer les différents types de chaînes, qui doivent être mis en forme différemment (backticks ou guillemets doubles pour les identifiants de base de données, guillemets simples pour les valeurs de données).
* Exemple avec un dictionnaire Python, une valeur DateTime et l’échappement des chaînes
```python theme={null}
import datetime
my_date = datetime.datetime(2022, 10, 1, 15, 20, 5)
parameters = {'v1': my_date, 'v2': "a string with a single quote'"}
client.query('SELECT * FROM my_table WHERE date >= %(v1)s AND string ILIKE %(v2)s', parameters=parameters)
```
Cela génère la requête suivante sur le serveur :
```sql theme={null}
SELECT *
FROM my_table
WHERE date >= '2022-10-01 15:20:05'
AND string ILIKE 'a string with a single quote\''
```
* Exemple avec une séquence Python (Tuple), Float64 et IPv4Address
```python theme={null}
import ipaddress
parameters = (35200.44, ipaddress.IPv4Address(0x443d04fe))
client.query('SELECT * FROM some_table WHERE metric >= %s AND ip_address = %s', parameters=parameters)
```
Cela génère la requête suivante sur le serveur :
```sql theme={null}
SELECT *
FROM some_table
WHERE metric >= 35200.44
AND ip_address = '68.61.4.254''
```
Pour lier des arguments DateTime64 (types ClickHouse avec une précision à la sous-seconde), il faut recourir à l’une des deux approches personnalisées suivantes :
* Enveloppez la valeur Python `datetime.datetime` dans la nouvelle classe DT64Param, par ex.
```python theme={null}
query = 'SELECT {p1:DateTime64(3)}' # Liaison côté serveur avec un dictionnaire
parameters={'p1': DT64Param(dt_value)}
query = 'SELECT %s as string, toDateTime64(%s,6) as dateTime' # Liaison côté client avec une liste
parameters=['a string', DT64Param(datetime.now())]
```
* Si vous utilisez un dictionnaire de valeurs de paramètres, ajoutez la chaîne `_64` au nom du paramètre
```python theme={null}
query = 'SELECT {p1:DateTime64(3)}, {a1:Array(DateTime(3))}' # Liaison côté serveur avec un dictionnaire
parameters={'p1_64': dt_value, 'a1_64': [dt_value1, dt_value2]}
```
### Argument `settings`
Toutes les principales méthodes "insert" et "select" de ClickHouse Connect Client acceptent un argument de mot-clé `settings` facultatif pour transmettre les [settings utilisateur](/fr/reference/settings/session-settings) du serveur ClickHouse pour l’instruction SQL concernée. L’argument `settings` doit être un dictionnaire. Chaque élément doit contenir un nom de setting ClickHouse et la valeur associée. Notez que les valeurs seront converties en chaînes de caractères lorsqu’elles seront envoyées au serveur comme paramètres de requête.
Comme pour les settings au niveau du client, ClickHouse Connect ignorera tous les settings que le serveur marque comme *readonly*=*1*, avec un message de log associé. Les settings qui s’appliquent uniquement aux requêtes via l’interface HTTP de ClickHouse sont toujours valides. Ces settings sont décrits dans l’[API](#settings-argument) `get_client`.
Exemple d’utilisation des settings ClickHouse :
```python theme={null}
settings = {'merge_tree_min_rows_for_concurrent_read': 65535,
'session_id': 'session_1234',
'use_skip_indexes': False}
client.query("SELECT event_type, sum(timeout) FROM event_errors WHERE event_time > '2022-08-01'", settings=settings)
```
## Méthode `command` du Client
Utilisez la méthode `Client.command` pour envoyer au serveur ClickHouse des requêtes SQL qui ne renvoient généralement pas de données, ou qui renvoient une seule valeur primitive ou un Array plutôt qu’un jeu de données complet. Cette méthode accepte les paramètres suivants :
| Paramètre | Type | Par défaut | Description |
| ------------------- | ---------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| cmd | str | *Obligatoire* | Une instruction ClickHouse SQL qui renvoie une seule valeur ou une seule ligne de valeurs. |
| parameters | dict or iterable | *None* | Voir la [description des paramètres](#parameters-argument). |
| data | str or bytes | *None* | Données facultatives à inclure avec la commande dans le corps de la requête POST. |
| settings | dict | *None* | Voir la [description des settings](#settings-argument). |
| use\_database | bool | True | Utilise la base de données du client (spécifiée lors de la création du client). False signifie que la commande utilisera la base de données par défaut du serveur ClickHouse pour l’utilisateur connecté. |
| external\_data | ExternalData | *None* | Objet `ExternalData` contenant des fichiers ou des données binaires à utiliser avec la requête. Voir [Advanced Queries (External Data)](/fr/integrations/language-clients/python/advanced-querying#external-data) |
| transport\_settings | dict | *None* | Dictionnaire facultatif d’en-têtes HTTP à inclure dans cette requête. Chaque paire clé-valeur est ajoutée comme un en-tête HTTP (par ex., `{'X-Custom-Header': 'value'}`). Utile pour l’authentification du proxy, le traçage des requêtes ou la transmission d’en-têtes requis par l’infrastructure intermédiaire. |
### Exemples de commandes
#### Instructions DDL
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Create a table
result = client.command("CREATE TABLE test_command (col_1 String, col_2 DateTime) ENGINE MergeTree ORDER BY tuple()")
print(result) # Returns QuerySummary with query_id
# Show table definition
result = client.command("SHOW CREATE TABLE test_command")
print(result)
# Output:
# CREATE TABLE default.test_command
# (
# `col_1` String,
# `col_2` DateTime
# )
# ENGINE = MergeTree
# ORDER BY tuple()
# Drop table
client.command("DROP TABLE test_command")
```
#### Requêtes simples renvoyant une seule valeur
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Single value result
count = client.command("SELECT count() FROM system.tables")
print(count)
# Output: 151
# Server version
version = client.command("SELECT version()")
print(version)
# Output: "25.8.2.29"
```
#### Commandes avec paramètres
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Using client-side parameters
table_name = "system"
result = client.command(
"SELECT count() FROM system.tables WHERE database = %(db)s",
parameters={"db": table_name}
)
# Using server-side parameters
result = client.command(
"SELECT count() FROM system.tables WHERE database = {db:String}",
parameters={"db": "system"}
)
```
#### Commandes avec settings
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Execute command with specific settings
result = client.command(
"OPTIMIZE TABLE large_table FINAL",
settings={"optimize_throw_if_noop": 1}
)
```
## Méthode `query` du Client
La méthode `Client.query` est le principal moyen de récupérer un seul jeu de données « batch » depuis le serveur ClickHouse. Elle utilise le format natif ClickHouse sur HTTP pour transmettre efficacement de grands jeux de données (jusqu’à environ un million de lignes). Cette méthode accepte les paramètres suivants :
| Paramètre | Type | Par défaut | Description |
| --------------------- | ---------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| query | str | *Obligatoire* | Requête ClickHouse SQL SELECT ou DESCRIBE. |
| parameters | dict or iterable | *None* | Voir la [description des paramètres](#parameters-argument). |
| settings | dict | *None* | Voir la [description des settings](#settings-argument). |
| query\_formats | dict | *None* | Spécification du formatage des types de données pour les valeurs de résultat. Voir Utilisation avancée (Formats de lecture) |
| column\_formats | dict | *None* | Formatage des types de données par colonne. Voir Utilisation avancée (Formats de lecture) |
| encoding | str | *None* | Encodage utilisé pour convertir les colonnes ClickHouse String en chaînes Python. Python utilise `UTF-8` par défaut si aucune valeur n’est définie. |
| use\_none | bool | True | Utilise le type Python *None* pour les valeurs nulles ClickHouse. Si False, utilise une valeur par défaut du type de données (par exemple 0) pour les valeurs nulles ClickHouse. Remarque : la valeur par défaut est False pour NumPy/Pandas pour des raisons de performances. |
| column\_oriented | bool | False | Renvoie les résultats sous forme de séquence de colonnes plutôt que de séquence de lignes. Utile pour convertir des données Python vers d’autres formats de données orientés colonnes. |
| query\_tz | str | *None* | Nom de fuseau horaire issu de la base de données `zoneinfo`. Ce fuseau horaire sera appliqué à tous les objets datetime ou Pandas Timestamp renvoyés par la requête. |
| column\_tzs | dict | *None* | Dictionnaire associant des noms de colonnes à des noms de fuseaux horaires. Comme `query_tz`, mais permet de spécifier différents fuseaux horaires pour différentes colonnes. |
| use\_extended\_dtypes | bool | True | Utilise les Dtype étendus de Pandas (comme StringArray), ainsi que pandas.NA et pandas.NaT pour les valeurs ClickHouse NULL. S’applique uniquement aux méthodes `query_df` et `query_df_stream`. |
| external\_data | ExternalData | *None* | Objet ExternalData contenant des données de fichier ou binaires à utiliser avec la requête. Voir [Requêtes avancées (Données externes)](/fr/integrations/language-clients/python/advanced-querying#external-data) |
| context | QueryContext | *None* | Un objet QueryContext réutilisable peut être utilisé pour encapsuler les arguments de méthode ci-dessus. Voir [Requêtes avancées (QueryContexts)](/fr/integrations/language-clients/python/advanced-querying#querycontexts) |
| transport\_settings | dict | *None* | Dictionnaire facultatif d’en-têtes HTTP à inclure dans cette requête. Chaque paire clé-valeur est ajoutée comme en-tête HTTP (par ex. `{'X-Custom-Header': 'value'}`). Utile pour l’authentification du proxy, le traçage des requêtes ou la transmission d’en-têtes requis par une infrastructure intermédiaire. |
### Exemples de requêtes
#### Requête de base
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Simple SELECT query
result = client.query("SELECT name, database FROM system.tables LIMIT 3")
# Access results as rows
for row in result.result_rows:
print(row)
# Output:
# ('CHARACTER_SETS', 'INFORMATION_SCHEMA')
# ('COLLATIONS', 'INFORMATION_SCHEMA')
# ('COLUMNS', 'INFORMATION_SCHEMA')
# Access column names and types
print(result.column_names)
# Output: ("name", "database")
print([col_type.name for col_type in result.column_types])
# Output: ['String', 'String']
```
#### Accéder au résultat de la requête
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
result = client.query("SELECT number, toString(number) AS str FROM system.numbers LIMIT 3")
# Row-oriented access (default)
print(result.result_rows)
# Output: [[0, "0"], [1, "1"], [2, "2"]]
# Column-oriented access
print(result.result_columns)
# Output: [[0, 1, 2], ["0", "1", "2"]]
# Named results (list of dictionaries)
for row_dict in result.named_results():
print(row_dict)
# Output:
# {"number": 0, "str": "0"}
# {"number": 1, "str": "1"}
# {"number": 2, "str": "2"}
# First row as dictionary
print(result.first_item)
# Output: {"number": 0, "str": "0"}
# First row as tuple
print(result.first_row)
# Output: (0, "0")
```
#### Requête avec paramètres côté client
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Using dictionary parameters (printf-style)
query = "SELECT * FROM system.tables WHERE database = %(db)s AND name LIKE %(pattern)s"
parameters = {"db": "system", "pattern": "%query%"}
result = client.query(query, parameters=parameters)
# Using tuple parameters
query = "SELECT * FROM system.tables WHERE database = %s LIMIT %s"
parameters = ("system", 5)
result = client.query(query, parameters=parameters)
```
#### Requête avec paramètres côté serveur
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Server-side binding (more secure, better performance for SELECT queries)
query = "SELECT * FROM system.tables WHERE database = {db:String} AND name = {tbl:String}"
parameters = {"db": "system", "tbl": "query_log"}
result = client.query(query, parameters=parameters)
```
#### Requête avec setting
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Pass ClickHouse settings with the query
result = client.query(
"SELECT sum(number) FROM numbers(1000000)",
settings={
"max_block_size": 100000,
"max_execution_time": 30
}
)
```
### L’objet `QueryResult`
La méthode `query` de base renvoie un objet `QueryResult` avec les propriétés publiques suivantes :
* `result_rows` -- Une matrice des données renvoyées sous la forme d’une séquence de lignes, chaque ligne étant elle-même une séquence de valeurs de colonnes.
* `result_columns` -- Une matrice des données renvoyées sous la forme d’une séquence de colonnes, chaque colonne étant elle-même une séquence des valeurs de ligne de cette colonne
* `column_names` -- Un tuple de chaînes représentant les noms des colonnes dans le `result_set`
* `column_types` -- Un tuple d’instances `ClickHouseType` représentant le type de données ClickHouse de chaque colonne dans `result_columns`
* `query_id` -- Le `query_id` ClickHouse (utile pour examiner la requête dans la table `system.query_log`)
* `summary` -- Toutes les données renvoyées par l’en-tête de réponse HTTP `X-ClickHouse-Summary`
* `first_item` -- Une propriété pratique pour récupérer la première ligne de la réponse sous forme de dictionnaire (les clés sont les noms des colonnes)
* `first_row` -- Une propriété pratique pour renvoyer la première ligne du résultat
* `column_block_stream` -- Un générateur de résultats de la requête au format orienté colonnes. Cette propriété ne doit pas être utilisée directement (voir ci-dessous).
* `row_block_stream` -- Un générateur de résultats de la requête au format orienté lignes. Cette propriété ne doit pas être utilisée directement (voir ci-dessous).
* `rows_stream` -- Un générateur de résultats de la requête qui renvoie une seule ligne à chaque appel. Cette propriété ne doit pas être utilisée directement (voir ci-dessous).
* `summary` -- Comme décrit dans la méthode `command`, un dictionnaire d’informations récapitulatives renvoyé par ClickHouse
Les propriétés `*_stream` renvoient un Context Python pouvant être utilisé comme itérateur pour les données renvoyées. Elles ne doivent être utilisées qu’indirectement via les méthodes `*_stream` du Client.
Tous les détails sur le streaming des résultats de requête (à l’aide d’objets StreamContext) sont présentés dans [Advanced Queries (Streaming Queries)](/fr/integrations/language-clients/python/advanced-querying#streaming-queries).
## Consommer les résultats des requêtes avec NumPy, Pandas ou Arrow
ClickHouse Connect fournit des méthodes de requête spécialisées pour les formats de données NumPy, Pandas et Arrow. Pour plus d’informations sur l’utilisation de ces méthodes, notamment des exemples, la prise en charge du streaming et la gestion avancée des types, consultez [Requêtes avancées (requêtes NumPy, Pandas et Arrow)](/fr/integrations/language-clients/python/advanced-querying#numpy-pandas-and-arrow-queries).
## Méthodes du Client pour les requêtes en streaming
Pour le streaming de grands ensembles de résultats, ClickHouse Connect propose plusieurs méthodes de streaming. Consultez [Requêtes avancées (requêtes en streaming)](/fr/integrations/language-clients/python/advanced-querying#streaming-queries) pour plus de détails et d'exemples.
## Méthode `insert` du Client
Pour le cas d’usage courant consistant à insérer plusieurs enregistrements dans ClickHouse, il existe la méthode `Client.insert`. Elle accepte les paramètres suivants :
| Paramètre | Type | Par défaut | Description |
| ------------------- | --------------------------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| table | str | *Obligatoire* | La table ClickHouse dans laquelle insérer les données. Le nom complet de la table (y compris la base de données) est accepté. |
| data | Sequence of Sequences | *Obligatoire* | La matrice de données à insérer : soit une Sequence de lignes, chacune étant une séquence de valeurs de colonnes, soit une Sequence de colonnes, chacune étant une séquence de valeurs de lignes. |
| column\_names | Sequence of str, or str | '\*' | Une liste de `column_names` pour la matrice de données. Si `'*'` est utilisé à la place, ClickHouse Connect exécutera une « pré-requête » pour récupérer tous les noms de colonnes de la table. |
| database | str | '' | La base de données cible de l’insertion. Si elle n’est pas spécifiée, celle du client sera utilisée. |
| column\_types | Sequence of ClickHouseType | *None* | Une liste d’instances de ClickHouseType. Si ni `column_types` ni `column_type_names` n’est spécifié, ClickHouse Connect exécutera une « pré-requête » pour récupérer tous les types de colonnes de la table. |
| column\_type\_names | Sequence of ClickHouse type names | *None* | Une liste de noms de types de données ClickHouse. Si ni `column_types` ni `column_type_names` n’est spécifié, ClickHouse Connect exécutera une « pré-requête » pour récupérer tous les types de colonnes de la table. |
| column\_oriented | bool | False | Si True, l’argument `data` est supposé être une Sequence de colonnes (et aucun « pivot » ne sera nécessaire pour insérer les données). Sinon, `data` est interprété comme une Sequence de lignes. |
| settings | dict | *None* | Voir la [description des settings](#settings-argument). |
| context | InsertContext | *None* | Un objet InsertContext réutilisable peut être utilisé pour encapsuler les arguments de méthode ci-dessus. Voir [Insertions avancées (InsertContexts)](/fr/integrations/language-clients/python/advanced-inserting#insertcontexts) |
| transport\_settings | dict | *None* | Dictionnaire facultatif d’en-têtes HTTP à inclure dans cette requête. Chaque paire clé-valeur est ajoutée comme en-tête HTTP (par ex. `{'X-Custom-Header': 'value'}`). Utile pour l’authentification du proxy, le traçage des requêtes ou la transmission d’en-têtes requis par une infrastructure intermédiaire. |
Cette méthode renvoie un dictionnaire de « résumé de requête », comme décrit pour la méthode « command ». Une exception sera levée si l’insertion échoue, quelle qu’en soit la raison.
Pour les méthodes d’insertion spécialisées qui fonctionnent avec les Pandas DataFrames, les tables PyArrow et les DataFrames basés sur Arrow, voir [Insertion avancée (méthodes d’insertion spécialisées)](/fr/integrations/language-clients/python/advanced-inserting#specialized-insert-methods).
Un tableau NumPy est une Sequence of Sequences valide et peut être utilisé comme argument `data` de la méthode principale `insert` ; une méthode spécialisée n’est donc pas nécessaire.
### Exemples
Les exemples ci-dessous partent du principe qu'une table `users` existe déjà, avec le schéma `(id UInt32, name String, age UInt8)`.
#### Insertion simple par ligne
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Row-oriented data: each inner list is a row
data = [
[1, "Alice", 25],
[2, "Bob", 30],
[3, "Joe", 28],
]
client.insert("users", data, column_names=["id", "name", "age"])
```
#### Insertion par colonnes
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Column-oriented data: each inner list is a column
data = [
[1, 2, 3], # id column
["Alice", "Bob", "Joe"], # name column
[25, 30, 28], # age column
]
client.insert("users", data, column_names=["id", "name", "age"], column_oriented=True)
```
#### Insertion avec des types de colonnes explicitement spécifiés
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Useful when you want to avoid a DESCRIBE query to the server
data = [
[1, "Alice", 25],
[2, "Bob", 30],
[3, "Joe", 28],
]
client.insert(
"users",
data,
column_names=["id", "name", "age"],
column_type_names=["UInt32", "String", "UInt8"],
)
```
#### Insérer dans une base de données spécifique
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
data = [
[1, "Alice", 25],
[2, "Bob", 30],
]
# Insert into a table in a specific database
client.insert(
"users",
data,
column_names=["id", "name", "age"],
database="production",
)
```
## Insertions depuis des fichiers
Pour insérer des données directement depuis des fichiers dans des tables ClickHouse, consultez [Insertion avancée (insertions depuis des fichiers)](/fr/integrations/language-clients/python/advanced-inserting#file-inserts).
## API brute
Pour les cas d’usage avancés nécessitant un accès direct à l’interface HTTP de ClickHouse, sans transformation de type, consultez [Utilisation avancée (API brute)](/fr/integrations/language-clients/python/advanced-usage#raw-api).
## Classes et fonctions utilitaires
Les classes et fonctions suivantes sont également considérées comme faisant partie de l’API `clickhouse-connect` « publique » et sont, comme les classes et les méthodes documentées ci-dessus, stables d’une version mineure à l’autre. Des changements incompatibles dans ces classes et fonctions ne seront introduits que dans une version mineure (et non dans un patch) et resteront disponibles avec le statut « Deprecated » pendant au moins une version mineure.
### Exceptions
Toutes les exceptions personnalisées (y compris celles définies dans la spécification DB API 2.0) sont définies dans le module `clickhouse_connect.driver.exceptions`. Les exceptions effectivement détectées par le driver utiliseront l’un de ces types.
### Utilitaires SQL ClickHouse
Les fonctions et la classe DT64Param du module `clickhouse_connect.driver.binding` peuvent être utilisées pour construire correctement les requêtes ClickHouse SQL et en échapper correctement le contenu. De même, les fonctions du module `clickhouse_connect.driver.parser` peuvent être utilisées pour analyser les noms de types de données ClickHouse.
## Cas d’utilisation pour les applications multithread, multiprocessus et asynchrones/événementielles
Pour savoir comment utiliser ClickHouse Connect dans des applications multithread, multiprocessus et asynchrones/événementielles, consultez [Utilisation avancée (cas d’utilisation pour les applications multithread, multiprocessus et asynchrones/événementielles)](/fr/integrations/language-clients/python/advanced-usage#multithreaded-multiprocess-and-asyncevent-driven-use-cases).
## Wrapper AsyncClient
Pour plus d’informations sur l’utilisation du wrapper AsyncClient dans des environnements asyncio, consultez [Utilisation avancée (wrapper AsyncClient)](/fr/integrations/language-clients/python/advanced-usage#asyncclient-wrapper).
## Gestion des ID de session de ClickHouse
Pour savoir comment gérer les ID de session de ClickHouse dans des applications multithreadées ou concurrentes, consultez [Utilisation avancée (Gestion des ID de session de ClickHouse)](/fr/integrations/language-clients/python/advanced-usage#managing-clickhouse-session-ids).
## Personnaliser le pool de connexions HTTP
Pour plus d’informations sur la personnalisation du pool de connexions HTTP pour les applications multithread de grande taille, consultez [Utilisation avancée (Personnaliser le pool de connexions HTTP)](/fr/integrations/language-clients/python/advanced-usage#customizing-the-http-connection-pool).