}`. Pase los valores como un diccionario de Python.
Use `None` de Python para valores que admiten valores nulos. Se admiten valores `None` anidados dentro de parámetros `Array` y `Tuple`, y dentro de literales `Map` cuando `dict_parameter_format` se establece en `"map"`.
* Vinculación del lado del servidor con diccionario de Python, valor DateTime y valor de cadena
```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,
)
```
Esto equivale a:
```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 vinculación del lado del servidor es compatible con las consultas `SELECT`. No funciona con `ALTER`, `DELETE`, `INSERT` ni con otros tipos de sentencias.
#### Vinculación en el cliente
ClickHouse Connect también admite la vinculación de parámetros en el cliente, lo que permite una mayor flexibilidad al generar consultas SQL con plantillas. Para la vinculación en el cliente, el argumento `parameters` debe ser un diccionario o una secuencia. La vinculación en el cliente utiliza el formato de cadenas [estilo "printf"](https://docs.python.org/3/library/stdtypes.html#old-string-formatting) de Python para la sustitución de parámetros.
Ten en cuenta que, a diferencia de la vinculación del lado del servidor, la vinculación en el cliente no funciona con identificadores de bases de datos, como nombres de bases de datos, tablas o columnas, ya que el formato de estilo Python no puede distinguir entre los distintos tipos de cadenas y estos deben formatearse de forma diferente (backticks o comillas dobles para identificadores de bases de datos, comillas simples para valores de datos).
* Ejemplo con un diccionario de Python, un valor DateTime y escape de cadenas
```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,
)
```
Esto genera la siguiente consulta en el servidor:
```sql theme={null}
SELECT *
FROM my_table
WHERE date >= '2022-10-01 15:20:05'
AND string ILIKE 'a string with a single quote\''
```
* Ejemplo con una secuencia de Python (Tuple), Float64 e 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,
)
```
Esto genera la siguiente consulta en el servidor:
```sql theme={null}
SELECT *
FROM some_table
WHERE metric >= 35200.44
AND ip_address = '68.61.4.254'
```
La vinculación de valores DateTime trata los valores sin zona horaria como hora de pared. El client formatea un `datetime` sin zona horaria literalmente. ClickHouse lo interpreta usando la zona horaria declarada en un placeholder del lado del servidor, como `{dt:DateTime('Europe/Berlin')}`, después `session_timezone` si está configurada y, por último, la zona horaria del servidor. Un `datetime` con zona horaria se convierte a la zona horaria declarada en el placeholder cuando está presente; de lo contrario, a la zona horaria del servidor indicada al momento de la conexión. Si la configuración `session_timezone` difiere de la zona horaria del servidor indicada, declare una zona horaria en el placeholder para mantener el instante previsto para los valores con zona horaria.
Para compatibilidad temporal con la conversión heredada de la hora local del host, establezca `common.set_setting("naive_datetime_binding", "legacy")` antes de vincular parámetros. Para preservar un instante, adjunte el `tzinfo` previsto al valor `datetime` antes de pasarlo como parámetro. Los inserts mediante `client.insert` interpretan de forma predeterminada los valores `datetime` sin zona horaria en la zona horaria local del proceso. Establezca la configuración global `naive_datetime_insert` en `"server"` para interpretarlos como hora de pared en la zona horaria de la columna o, si la columna no tiene ninguna, en la zona horaria del servidor. Consulte [Objetos datetime sin zona horaria](/es/integrations/language-clients/python/advanced-inserting#timezone-naive-datetime-objects).
Para un placeholder `{value:DateTime64(precision)}` del lado del servidor, el tipo declarado conserva automáticamente la precisión de fracciones de segundo, incluso dentro de las pistas `Array` y `Tuple`.
La vinculación `%s` en el cliente no tiene un tipo declarado. Envuelva un `datetime` en `DT64Param` cuando deba representarse con precisión de fracciones de segundo:
```python theme={null}
from datetime import datetime
from clickhouse_connect.driver.binding import DT64Param
query = "SELECT toDateTime64(%s, 6)"
parameters = [DT64Param(datetime.now())]
client.query(query, parameters=parameters)
```
Por compatibilidad con versiones anteriores, un nombre de parámetro de diccionario que termina en `_64` también solicita el formato DateTime64 cuando ese nombre exacto con sufijo no está presente en la consulta.
Un parámetro `datetime.time` o `datetime.timedelta` se formatea como un literal `[-]HH:MM:SS[.ffffff]` para las columnas `Time` y `Time64` de ClickHouse, en ambos estilos de vinculación y dentro de valores `Array` y `Tuple`. El client añade las comillas, así que no incluya el placeholder entre comillas en la consulta. Un `timedelta` puede ser negativo y superar las 24 horas. Un `Timedelta` de pandas conserva sus nanosegundos y se formatea con una fracción de nueve dígitos para `Time64(9)`. La información de zona horaria de un `time` con zona horaria se ignora porque `Time` de ClickHouse no tiene zona horaria.
### Argumento `settings`
Todos los métodos principales "insert" y "select" del cliente ClickHouse Connect aceptan un argumento de palabra clave opcional, `settings`, para pasar [ajustes de usuario](/es/reference/settings/session-settings) del servidor ClickHouse a la sentencia SQL incluida. El argumento `settings` debe ser un diccionario. Cada elemento debe contener el nombre de un ajuste de ClickHouse y su valor asociado. Ten en cuenta que los valores se convertirán en cadenas al enviarse al servidor como parámetros de consulta.
Al igual que con los ajustes a nivel de cliente, ClickHouse Connect descartará cualquier ajuste que el servidor marque como *readonly*=*1*, con el correspondiente mensaje de log. Los ajustes que se aplican solo a consultas a través de la interfaz HTTP de ClickHouse siempre son válidos. Esos ajustes se describen en la [API](#settings-argument) `get_client`.
Ejemplo de uso de ajustes de 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étodo `command` del Client
Use `Client.command` para sentencias que no devuelven un conjunto de datos tabular, o para consultas que devuelven un valor primitivo o una fila. Según la respuesta, devuelve una cadena, un entero, una secuencia de cadenas o `QuerySummary`. Una lectura que produce un conjunto de resultados vacío devuelve una cadena vacía.
| Parámetro | Tipo | Predeterminado | Descripción |
| ------------------- | ---------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| cmd | str | *Obligatorio* | Una sentencia de ClickHouse SQL que devuelve un único valor o una única fila de valores. |
| parameters | dict or sequence | *None* | Consulte la [descripción de los parámetros](#parameters-argument). |
| data | str or bytes | *None* | Datos opcionales para incluir con el comando como cuerpo de la solicitud POST. |
| settings | dict | *None* | Consulte la [descripción del ajuste](#settings-argument-1). |
| use\_database | bool | True | Usa la base de datos del Client (especificada al crear el Client). False significa que el comando usará la base de datos predeterminada del servidor de ClickHouse para el usuario conectado. |
| external\_data | ExternalData | *None* | Un objeto `ExternalData` que contiene datos de archivo o binarios para usar con la consulta. Consulte [Advanced Queries (External Data)](/es/integrations/language-clients/python/advanced-querying#external-data) |
| transport\_settings | dict | *None* | Diccionario opcional de encabezados HTTP para incluir con esta solicitud. Cada par clave-valor se añade como un encabezado HTTP (p. ej., `{'X-Custom-Header': 'value'}`). Resulta útil para la autenticación del proxy, el tracing de solicitudes o para pasar encabezados requeridos por la infraestructura intermedia. |
### Ejemplos del comando
#### Sentencias DDL
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Create a table. A successful DDL returns QuerySummary.
summary = client.command(
"CREATE TABLE test_command "
"(col_1 String, col_2 DateTime) "
"ENGINE MergeTree ORDER BY tuple()"
)
print(summary.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")
```
#### Consultas sencillas que devuelven valores individuales
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Single value result
count = client.command("SELECT count() FROM system.tables")
print(count)
# Server version
version = client.command("SELECT version()")
print(version)
```
#### Comandos con parámetros
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Usando parámetros del lado del cliente
table_name = "system"
result = client.command(
"SELECT count() FROM system.tables WHERE database = %(db)s",
parameters={"db": table_name}
)
# Usando parámetros del lado del servidor
result = client.command(
"SELECT count() FROM system.tables WHERE database = {db:String}",
parameters={"db": "system"}
)
```
#### Comandos con ajustes
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Ejecutar comando con configuraciones específicas
result = client.command(
"OPTIMIZE TABLE large_table FINAL",
settings={"optimize_throw_if_noop": 1}
)
```
## Método `query` de Client
`Client.query` recupera un conjunto de datos tabular en formato Native de ClickHouse y devuelve un `QueryResult`. El resultado completo se materializa al acceder a una propiedad del resultado. Use un método de streaming para resultados que no deban mantenerse en memoria.
| Parámetro | Tipo | Predeterminado | Descripción |
| -------------------- | ---------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query` | str | Required | consulta de ClickHouse que devuelve un resultado tabular, normalmente `SELECT` o `DESCRIBE`. Puede omitirse cuando se proporciona mediante `context`. |
| `parameters` | dict or sequence | `None` | Consulte [Parameters argument](#parameters-argument). |
| `settings` | dict | `None` | Consulte [Settings argument](#settings-argument-1). |
| `query_formats` | dict | `None` | Formato de lectura por tipo de ClickHouse. Consulte [Read formats](/es/integrations/language-clients/python/advanced-querying#read-formats). |
| `column_formats` | dict | `None` | Formato de lectura por columna del resultado, incluidas las correspondencias de formato para Nested type. |
| `encoding` | str | `None` | Codificación de columna String. El valor predeterminado es UTF-8. |
| `use_none` | bool | `True` | Devuelve `None` para SQL NULL. Cuando es `false`, devuelve el valor nulo predeterminado del tipo. Los methods de NumPy/Pandas eligen valores predeterminados orientados al rendimiento. |
| `column_oriented` | bool | `False` | Orienta el resultado por columnas en lugar de por filas. |
| `use_numpy` | bool | `False` | Lee las columnas de resultado compatibles en arrays de NumPy dentro de `QueryResult`. Prefiera `query_np` cuando el resultado deseado sea una sola matriz de NumPy. |
| `max_str_len` | int | `0` | Con `use_numpy`, usa un `dtype` Unicode de ancho fijo para columna String de hasta esta longitud. Cero usa arrays de objetos. |
| `context` | `QueryContext` | `None` | Contexto de consulta reutilizable. Los argumentos explícitos del método prevalecen sobre los valores del contexto. |
| `query_tz` | str or `tzinfo` | `None` | Zona horaria aplicada a todas las columnas de resultado `DateTime` y `DateTime64`. |
| `column_tzs` | dict | `None` | correspondencia de zona horaria por columna. |
| `external_data` | `ExternalData` | `None` | Archivo externo o datos binarios. Consulte [External data](/es/integrations/language-clients/python/advanced-querying#external-data). |
| `transport_settings` | dict | `None` | HTTP headers añadidos a esta solicitud. |
| `tz_mode` | str | Client default | sobrescritura por consulta para el manejo de zona horaria `"naive_utc"`, `"aware"` o `"schema"`. |
### Ejemplos de consultas
#### Consulta básica
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Simple SELECT query
result = client.query(
"SELECT number, toString(number) AS label FROM numbers(3)"
)
# Access results as rows
for row in result.result_rows:
print(row)
# Output:
# (0, '0')
# (1, '1')
# (2, '2')
# Access column names and types
print(result.column_names)
# Output: ('number', 'label')
print([col_type.name for col_type in result.column_types])
# Output: ['UInt64', 'String']
```
#### Acceder a los resultados de la consulta
```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')
```
#### Consulta con parámetros en el cliente
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Uso de parámetros de diccionario (estilo printf)
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)
# Uso de parámetros de tupla
query = "SELECT * FROM system.tables WHERE database = %s LIMIT %s"
parameters = ("system", 5)
result = client.query(query, parameters=parameters)
```
#### Consulta con parámetros del servidor
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Vinculación del lado del servidor (más segura, mejor rendimiento para consultas SELECT)
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)
```
#### Consulta con ajustes
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Pasa los ajustes de ClickHouse con la consulta
result = client.query(
"SELECT sum(number) FROM numbers(1000000)",
settings={
"max_block_size": 100000,
"max_execution_time": 30
}
)
```
### El objeto `QueryResult`
El método base `query` devuelve un objeto `QueryResult` con las siguientes propiedades públicas:
* `result_rows` -- Matriz de resultados orientada por filas.
* `result_columns` -- Matriz de resultados orientada por columnas.
* `result_set` -- `result_rows` o `result_columns`, según la orientación de la consulta.
* `column_names` -- `Tuple` con los nombres de las columnas del resultado.
* `column_types` -- `Tuple` de objetos `ClickHouseType`.
* `row_count` -- Número de filas de resultados materializadas.
* `query_id` -- ID de consulta informado o generado para la solicitud. Una cadena vacía significa que no había ninguno disponible.
* `summary` -- Diccionario decodificado del header de respuesta `X-ClickHouse-Summary`.
* `first_item` -- Primera fila como diccionario, o `None` si el resultado está vacío.
* `first_row` -- Primera fila como secuencia, o `None` si el resultado está vacío.
* `column_block_stream`, `row_block_stream` y `rows_stream` -- Contextos internos de stream. Use en su lugar los métodos de streaming correspondientes del Client.
Consulte [Consultas en streaming](/es/integrations/language-clients/python/advanced-querying#streaming-queries) para conocer las API de `StreamContext` compatibles.
## Consumo de resultados de consultas con NumPy, Pandas o Arrow
ClickHouse Connect proporciona métodos de consulta específicos para trabajar con los formatos de datos NumPy, Pandas y Arrow. Para obtener información detallada sobre cómo usar estos métodos, incluidos ejemplos, streaming y gestión avanzada de tipos, consulte [Consultas avanzadas (consultas de NumPy, Pandas y Arrow)](/es/integrations/language-clients/python/advanced-querying#numpy-pandas-and-arrow-queries).
## Métodos del cliente para consultas en streaming
Para transmitir grandes conjuntos de resultados, ClickHouse Connect ofrece varios métodos de streaming. Consulta [Consultas avanzadas (Streaming Queries)](/es/integrations/language-clients/python/advanced-querying#streaming-queries) para obtener más información y ejemplos.
## Método `insert` del Client
Para el caso de uso habitual de insertar varios registros en ClickHouse, está el método `Client.insert`. Acepta los siguientes parámetros:
| Parámetro | Tipo | Predeterminado | Descripción |
| -------------------- | --------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `table` | str | Required | Tabla de destino. Se permite un nombre completo con la base de datos. Puede omitirse cuando lo proporciona `context`. |
| `data` | Sequence of Sequences | Required | Matriz de datos orientada a filas o orientada a columna. Puede proporcionarse más adelante mediante un `InsertContext`. |
| `column_names` | str or Sequence\[str] | `"*"` | Columnas ordenadas. `"*"` ejecuta una consulta de metadatos para detectar todas las columnas insertables. |
| `database` | str or None | Base de datos del Client | Base de datos de destino cuando `table` no está calificada. |
| `column_types` | Sequence\[`ClickHouseType`] | `None` | Tipos de columna explícitos. Evita la consulta de metadatos cuando se proporcionan. |
| `column_type_names` | Sequence\[str] | `None` | Nombres de tipos de ClickHouse explícitos. Alternativa a `column_types`. |
| `column_oriented` | bool | `False` | Interpreta `data` como columnas en lugar de filas. |
| `settings` | dict | `None` | Consulte [argumento Settings](#settings-argument-1). |
| `context` | `InsertContext` | `None` | Contexto de inserción reutilizable. Consulte [InsertContexts](/es/integrations/language-clients/python/advanced-inserting#insertcontexts). |
| `transport_settings` | dict | `None` | headers HTTP añadidos a esta solicitud. |
Este método devuelve `QuerySummary`. Su diccionario `summary` contiene valores informados por el server. `written_rows` es una propiedad de conveniencia, mientras que `written_bytes()` y `query_id()` devuelven los valores correspondientes. Un fallo en la inserción genera una excepción.
Para métodos de inserción especializados que funcionan con Pandas DataFrames, tablas PyArrow y DataFrames respaldados por Arrow, consulte [Inserciones avanzadas (Métodos de inserción especializados)](/es/integrations/language-clients/python/advanced-inserting#specialized-insert-methods).
Una matriz de NumPy es una Sequence of Sequences válida y puede usarse como argumento `data` para el método principal `insert`, por lo que no se requiere un método especializado.
### Ejemplos
Los ejemplos a continuación suponen que existe una tabla `users` con el esquema `(id UInt32, name String, age UInt8)`.
#### Inserción básica por filas
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Row-oriented data: each inner list is a row
data = [
[13, "user_1", 25],
[79, "user_2", 30],
]
client.insert("users", data, column_names=["id", "name", "age"])
```
#### Inserción orientada a columnas
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Column-oriented data: each inner list is a column
data = [
[13, 79], # id column
["user_1", "user_2"], # name column
[25, 30], # age column
]
client.insert("users", data, column_names=["id", "name", "age"], column_oriented=True)
```
#### Inserción con tipos explícitos de columnas
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
# Useful when you want to avoid a DESCRIBE query to the server
data = [
[13, "user_1", 25],
[79, "user_2", 30],
]
client.insert(
"users",
data,
column_names=["id", "name", "age"],
column_type_names=["UInt32", "String", "UInt8"],
)
```
#### Insertar en una base de datos específica
```python theme={null}
import clickhouse_connect
client = clickhouse_connect.get_client()
data = [
[13, "user_1", 25],
[79, "user_2", 30],
]
# Insert into a table in a specific database
client.insert(
"users",
data,
column_names=["id", "name", "age"],
database="production",
)
```
## Inserciones desde archivos
Para insertar datos directamente desde archivos en tablas de ClickHouse, consulte [Inserción avanzada (Inserciones desde archivos)](/es/integrations/language-clients/python/advanced-inserting#file-inserts).
## API en bruto
Para casos de uso avanzados que requieran acceso directo a las interfaces HTTP de ClickHouse sin transformaciones de tipos, consulte [Uso avanzado (Raw API)](/es/integrations/language-clients/python/advanced-usage#raw-api).
## Python DB-API 2.0
El módulo `clickhouse_connect.dbapi` implementa la interfaz de conexión y cursor definida por PEP 249. Declara el nivel de API 2.0, `threadsafety=2` y `paramstyle="pyformat"`. El módulo también proporciona los constructores de tipos PEP 249 `Date`, `Time`, `Timestamp` y `Binary`, y las funciones `DateFromTicks`, `TimeFromTicks` y `TimestampFromTicks`.
```python theme={null}
from clickhouse_connect import dbapi
connection = dbapi.connect(
host="localhost",
username="default",
password="password",
database="default",
)
cursor = connection.cursor()
try:
cursor.execute(
"SELECT name FROM system.tables "
"WHERE database = %(database)s ORDER BY name LIMIT 5",
{"database": "system"},
)
print(cursor.description)
print(cursor.fetchall())
finally:
cursor.close()
connection.close()
```
`Cursor.execute` y `Cursor.executemany` aceptan argumentos adicionales de palabra clave, `settings` y `query_formats`. `settings` pasa ajustes de ClickHouse. `query_formats` aplica formatos de lectura según el tipo de ClickHouse cuando una sentencia devuelve filas, usando la misma correspondencia que `Client.query`. `executemany` usa la ruta nativa de inserción masiva del driver para las sentencias `INSERT ... VALUES` compatibles con una secuencia materializada de filas. `fetchone`, `fetchmany` y `fetchall` consumen el resultado materializado actual.
`Cursor.description` deriva `null_ok` del tipo de cada columna de resultado. Los tipos que no admiten valores NULL informan `False`, y los tipos que admiten valores NULL informan `True`, incluidos los envoltorios `Nullable`, `Variant` y `Dynamic`. `None` significa que se desconoce la nulabilidad. Cuando una consulta que comienza con `SELECT` o `WITH`, ignorando los comentarios iniciales, no devuelve filas ni metadatos de columnas, el cursor ejecuta una consulta de metadatos `LIMIT 0` para poblar `description`. Si esa consulta de metadatos falla, `description` se deja vacío.
ClickHouse no proporciona transacciones tradicionales a través de esta interfaz HTTP. `Connection.commit()` y `Connection.rollback()` no tienen efecto. Las [reglas de concurrencia del ID de sesión](/es/integrations/language-clients/python/advanced-usage#managing-clickhouse-session-ids) siguen aplicándose cuando se comparte una conexión.
## Clases y funciones de utilidad
Los siguientes módulos proporcionan funciones auxiliares públicas adicionales que usan las aplicaciones Client.
La versión del paquete instalado se expone como la cadena `clickhouse_connect.__version__`.
### Excepciones
Las excepciones personalizadas, incluida la jerarquía de excepciones de DB-API 2.0, se definen en `clickhouse_connect.driver.exceptions`. `DatabaseError` y `OperationalError` exponen un atributo numérico `code` con el código de error de ClickHouse y un atributo `name` con el nombre simbólico, como `UNKNOWN_TABLE`, para que las aplicaciones puedan basarse en `exc.code` en lugar de tener que analizar el mensaje. `code` se establece incluso cuando `show_clickhouse_errors` está deshabilitado, mientras que `name` requiere detalles del error (`True` o `"scrub"`). Ambos son `None` cuando no están disponibles, por ejemplo, en errores de transporte. Use `show_clickhouse_errors="scrub"` cuando los usuarios finales deban ver errores de SQL sin información del host ni de la versión del servidor. Esta configuración también controla los mensajes de `StreamFailureError` durante la transmisión y los mensajes de transporte genéricos. Solo afecta a `str(exc)`. Los errores de transporte siguen adjuntos como `__cause__`, y los seguimientos de pila pueden contener el texto original del error del host, la URL o la biblioteca.
### Utilidades de ClickHouse SQL
Las funciones y la clase DT64Param del módulo `clickhouse_connect.driver.binding` pueden usarse para construir y escapar correctamente consultas en ClickHouse SQL. Del mismo modo, las funciones del módulo `clickhouse_connect.driver.parser` pueden usarse para analizar nombres de tipos de datos de ClickHouse.
## Casos de uso multihilo, multiproceso y asíncronos/orientados a eventos
Para obtener información sobre el uso de ClickHouse Connect en aplicaciones multihilo, multiproceso y asíncronas/orientadas a eventos, consulte [Uso avanzado (casos de uso multihilo, multiproceso y asíncronos/orientados a eventos)](/es/integrations/language-clients/python/advanced-usage#multithreaded-multiprocess-and-asyncevent-driven-use-cases).
## AsyncClient
Para obtener información sobre el uso nativo de asyncio, consulte [Uso avanzado (AsyncClient)](/es/integrations/language-clients/python/advanced-usage#asyncclient).
## Gestión de los IDs de sesión de ClickHouse
Para obtener información sobre cómo gestionar los IDs de sesión de ClickHouse en aplicaciones multihilo o concurrentes, consulte [Uso avanzado (Gestión de los IDs de sesión de ClickHouse)](/es/integrations/language-clients/python/advanced-usage#managing-clickhouse-session-ids).
## Personalización del pool de conexiones HTTP
Para obtener información sobre cómo personalizar el pool de conexiones HTTP para aplicaciones grandes con varios hilos, consulte [Uso avanzado (Personalización del pool de conexiones HTTP)](/es/integrations/language-clients/python/advanced-usage#customizing-the-http-connection-pool).