hare-orm 0.9.0__py3-none-any.whl

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_query_result.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+from clickhouse_driver.protocol import ServerPacketTypes
+from clickhouse_driver.result import QueryResult
+
+
+class ClickhouseDriverQueryResult(QueryResult):  # type: ignore[misc]  # the library ships no types
+    """clickhouse-driver's result of a statement, the totals row of ``GROUP BY ... WITH TOTALS`` kept apart
+    - the library adds it to the rows."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        #: The rows of the totals block - one for a statement ``WITH TOTALS``, none for another.
+        self.totals_rows: list[Any] = []
+
+    def store(self, packet: Any) -> None:
+        if getattr(packet, "type", None) == ServerPacketTypes.TOTALS:
+            block = getattr(packet, "block", None)
+            if block is not None and block.num_rows:
+                self.totals_rows.extend(block.get_rows())
+            return
+        super().store(packet)

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_row_stream.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import threading
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from clickhouse_driver import Client
+
+from hare.dialects.clickhouse.client.clickhouse_streamed_row import ClickhouseStreamedRow
+from hare.dialects.clickhouse.drivers.clickhouse_driver.client.clickhouse_driver_connections import (
+    ClickhouseDriverConnections,
+)
+from hare.dialects.clickhouse.drivers.clickhouse_driver.constants import (
+    CLICKHOUSE_DRIVER_STREAM_QUEUE_SIZE,
+    CLICKHOUSE_DRIVER_STREAM_WAIT_SECONDS,
+)
+
+
+class ClickhouseDriverRowStream:
+    """The rows of one query read on a worker thread of the connections as the server sends them, and
+    handed over a batch at a time - the thread waits while the reader holds the batches it hasn't read
+    yet. A reader that stops early has the thread drop its connection: the server stops sending.
+
+    Args:
+        connections: The connections the query runs on.
+        sql: The query.
+        batch_size: How many rows a batch holds.
+    """
+
+    __slots__ = ("connections", "sql", "batch_size", "stopped")
+
+    #: What the thread puts after the last batch.
+    END: object = object()
+
+    def __init__(self, connections: ClickhouseDriverConnections, sql: str, batch_size: int) -> None:
+        self.connections = connections
+        self.sql = sql
+        self.batch_size = batch_size
+        #: Set once the reader stops reading.
+        self.stopped = threading.Event()
+
+    async def read_batches(self) -> AsyncGenerator[list[ClickhouseStreamedRow]]:
+        """The rows, a batch at a time.
+
+        Yields:
+            The rows of a batch, by position and by column name.
+
+        Raises:
+            Exception: The driver's error the query failed with.
+        """
+        loop = asyncio.get_running_loop()
+        batches: asyncio.Queue[Any] = asyncio.Queue(maxsize=CLICKHOUSE_DRIVER_STREAM_QUEUE_SIZE)
+        reading = self.connections.run(self.read_on_thread, loop, batches)
+        try:
+            while True:
+                item = await batches.get()
+                if item is self.END:
+                    break
+                if isinstance(item, BaseException):
+                    raise item
+                yield item
+        finally:
+            self.stopped.set()
+            while not batches.empty():
+                batches.get_nowait()
+            await reading
+
+    def read_on_thread(
+        self, library_client: Client, loop: asyncio.AbstractEventLoop, batches: asyncio.Queue[Any]
+    ) -> None:
+        """Reads the rows on the worker thread holding a connection, putting them in batches.
+
+        Args:
+            library_client: The thread's connection.
+            loop: The reader's event loop.
+            batches: The batches the reader takes.
+        """
+        reads_to_end = False
+        try:
+            rows = library_client.execute_iter(
+                self.sql, settings={"max_block_size": self.batch_size}, with_column_types=True
+            )
+            row_class = ClickhouseStreamedRow.get_row_class(tuple(column[0] for column in next(rows)))
+            batch: list[ClickhouseStreamedRow] = []
+            for row in rows:
+                batch.append(row_class(row))
+                if len(batch) >= self.batch_size:
+                    if not self.put(loop, batches, batch):
+                        return
+                    batch = []
+            reads_to_end = True
+            if batch and not self.put(loop, batches, batch):
+                return
+            self.put(loop, batches, self.END)
+        except Exception as error:
+            reads_to_end = True
+            self.put(loop, batches, error)
+        finally:
+            if not reads_to_end:
+                # The server is still sending the rows - the connection is dropped, the next statement
+                # of the thread opens another.
+                library_client.disconnect()
+
+    def put(self, loop: asyncio.AbstractEventLoop, batches: asyncio.Queue[Any], item: Any) -> bool:
+        """Hands a batch to the reader, waiting while it holds as many as it may.
+
+        Args:
+            loop: The reader's event loop.
+            batches: The batches the reader takes.
+            item: The batch, the end, or an error.
+
+        Returns:
+            Whether the reader took it - False once it stopped reading.
+        """
+        if self.stopped.is_set():
+            return False
+        putting = asyncio.run_coroutine_threadsafe(batches.put(item), loop)
+        while True:
+            try:
+                putting.result(timeout=CLICKHOUSE_DRIVER_STREAM_WAIT_SECONDS)
+                return True
+            except concurrent.futures.TimeoutError:
+                if self.stopped.is_set():
+                    putting.cancel()
+                    return False

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_service_block_stream.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import Any
+
+from clickhouse_driver import defines
+from clickhouse_driver.block import BlockInfo, ColumnOrientedBlock
+from clickhouse_driver.columns.service import read_column
+from clickhouse_driver.reader import read_binary_str, read_binary_uint8
+from clickhouse_driver.streams.native import BlockInputStream
+from clickhouse_driver.varint import read_varint
+
+from hare.dialects.clickhouse.drivers.clickhouse_driver.constants import (
+    CLICKHOUSE_DRIVER_FIXED_VALUE_WIDTH_PREFIXES,
+    CLICKHOUSE_DRIVER_FIXED_VALUE_WIDTHS,
+    CLICKHOUSE_DRIVER_PROFILE_EVENTS_FIRST_COLUMN,
+    CLICKHOUSE_DRIVER_STRING_TYPE,
+)
+
+
+class ClickhouseDriverServiceBlockStream(BlockInputStream):  # type: ignore[misc]  # the library ships no types
+    """The stream of the uncompressed blocks the server sends besides a statement's rows - its log
+    lines and its ProfileEvents. The library reads a ProfileEvents block whole, a moment and a time
+    zone conversion per row, and drops it; its values are passed over unread here, the block given
+    without rows. A log block is read as the library reads it."""
+
+    def read(self, use_numpy: bool | None = None) -> Any:
+        info = BlockInfo()
+        revision = self.context.server_info.used_revision
+        if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
+            info.read(self.fin)
+        column_count = read_varint(self.fin)
+        row_count = read_varint(self.fin)
+        names: list[str] = []
+        types: list[str] = []
+        data: list[Any] = []
+        is_profile_events = False
+        for index in range(column_count):
+            column_name = read_binary_str(self.fin)
+            column_type = read_binary_str(self.fin)
+            names.append(column_name)
+            types.append(column_type)
+            if index == 0:
+                is_profile_events = column_name == CLICKHOUSE_DRIVER_PROFILE_EVENTS_FIRST_COLUMN
+            has_custom_serialization = False
+            if revision >= defines.DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION:
+                has_custom_serialization = bool(read_binary_uint8(self.fin))
+            if not row_count:
+                continue
+            if is_profile_events and not has_custom_serialization and self._skip_values(column_type, row_count):
+                continue
+            column = read_column(
+                self.context,
+                column_type,
+                row_count,
+                self.fin,
+                use_numpy=use_numpy,
+                has_custom_serialization=has_custom_serialization,
+            )
+            if not is_profile_events:
+                data.append(column)
+        if is_profile_events:
+            # Read past - the library drops the block.
+            return ColumnOrientedBlock(columns_with_types=list(zip(names, types, strict=True)), data=[], info=info)
+        if self.context.client_settings["use_numpy"]:
+            from clickhouse_driver.numpy.block import NumpyColumnOrientedBlock
+
+            return NumpyColumnOrientedBlock(
+                columns_with_types=list(zip(names, types, strict=True)), data=data, info=info
+            )
+        return ColumnOrientedBlock(columns_with_types=list(zip(names, types, strict=True)), data=data, info=info)
+
+    def _skip_values(self, column_type: str, row_count: int) -> bool:
+        """Reads past the values of a column without converting them.
+
+        Args:
+            column_type: The column's type.
+            row_count: The block's rows.
+
+        Returns:
+            Whether the values were read past - False for a type of no known layout, read by the
+            library then.
+        """
+        if column_type == CLICKHOUSE_DRIVER_STRING_TYPE:
+            self.fin.read_strings(row_count)
+            return True
+        width = CLICKHOUSE_DRIVER_FIXED_VALUE_WIDTHS.get(column_type)
+        if width is None:
+            for prefix, prefix_width in CLICKHOUSE_DRIVER_FIXED_VALUE_WIDTH_PREFIXES:
+                if column_type.startswith(prefix):
+                    width = prefix_width
+                    break
+            else:
+                return False
+        self.fin.read(width * row_count)
+        return True

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_settings.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import io
+from collections.abc import Callable
+from typing import Any, ClassVar
+
+from clickhouse_driver import connection
+
+from hare.core.caching.cache import Cache
+from hare.dialects.clickhouse.drivers.clickhouse_driver.constants import CLICKHOUSE_DRIVER_SETTINGS_CACHE_SIZE
+
+
+class ClickhouseDriverSettings:
+    """The settings clickhouse-driver sends with each statement, written as the bytes kept from the
+    first statement with the same settings - the library writes every setting, three values each,
+    for every statement."""
+
+    #: The library's own writing - kept to tell it was replaced, and to write settings not kept yet.
+    library_writers: ClassVar[list[Callable[[Any, Any, bool, int], None]]] = []
+    #: (flags, the settings, the type of each value) -> the settings as the library writes them.
+    WRITTEN_SETTINGS: ClassVar[Cache[bytes]] = Cache(
+        CLICKHOUSE_DRIVER_SETTINGS_CACHE_SIZE, holds_sql=False, keyed_by_model=False
+    )
+
+    @classmethod
+    def install(cls) -> None:
+        """Replaces the library's writing of a statement's settings - once."""
+        if cls.library_writers:
+            return
+        cls.library_writers.append(connection.write_settings)
+        connection.write_settings = cls.write
+
+    @staticmethod
+    def write(settings: dict[str, Any] | None, buffer: Any, settings_as_strings: bool, flags: int) -> None:
+        """Writes the settings as the library does.
+
+        Args:
+            settings: The settings, by name.
+            buffer: The connection's output.
+            settings_as_strings: Whether the server reads each setting as text.
+            flags: The flags written with each setting.
+        """
+        library_writer = ClickhouseDriverSettings.library_writers[0]
+        # A server reading typed settings has the library skip the unknown ones - with a warning
+        # each time.
+        if not settings or not settings_as_strings:
+            library_writer(settings, buffer, settings_as_strings, flags)
+            return
+        values = tuple(settings.values())
+        # The type tells apart values the library writes differently (True and 1).
+        key = (flags, tuple(settings), values, tuple(map(type, values)))
+        try:
+            written = ClickhouseDriverSettings.WRITTEN_SETTINGS.get(key)
+        except TypeError:
+            # A value that can't be a key.
+            library_writer(settings, buffer, settings_as_strings, flags)
+            return
+        if written is None:
+            output = io.BytesIO()
+            library_writer(settings, output, settings_as_strings, flags)
+            written = ClickhouseDriverSettings.WRITTEN_SETTINGS[key] = output.getvalue()
+        buffer.write(written)

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_transaction_client.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from hare.dialects.clickhouse.client.clickhouse_transaction_client import ClickhouseTransactionClient
+from hare.dialects.clickhouse.drivers.clickhouse_driver.client.clickhouse_driver_client import ClickhouseDriverClient
+from hare.dialects.clickhouse.drivers.clickhouse_driver.client.clickhouse_driver_connections import (
+    ClickhouseDriverConnections,
+)
+
+
+class ClickhouseDriverTransactionClient(ClickhouseTransactionClient, ClickhouseDriverClient):
+    """A transaction of a clickhouse-driver connection - a TCP connection of its own, on one worker
+    thread, which the server keeps the transaction on."""
+
+    _parent: ClickhouseDriverClient
+
+    async def open_transaction_connection(self) -> ClickhouseDriverConnections:
+        return ClickhouseDriverConnections(1, self.get_connection_settings(with_db=True), self.pool_statistics)
+
+    async def close_transaction_connection(self, connection: ClickhouseDriverConnections) -> None:
+        await connection.close()
+
+    async def send_transaction_statement(self, sql: str) -> None:
+        await self._connection.run(self._run_command, sql)

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_tuple_columns.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, ClassVar
+
+from clickhouse_driver.columns.tuplecolumn import TupleColumn
+
+
+class ClickhouseDriverTupleColumns:
+    """The writing of a ``Tuple(...)`` column by clickhouse-driver, made to write a column of no
+    tuples - the tuples of arrays or maps that are all empty: the library turns its tuples into a
+    column per element and then reads each by its position, of which there is none."""
+
+    #: The library's own writing of a tuple column - kept to tell it was replaced.
+    library_writers: ClassVar[list[Callable[..., Any]]] = []
+
+    @classmethod
+    def install(cls) -> None:
+        """Replaces the library's writing of a tuple column - once."""
+        if cls.library_writers:
+            return
+        cls.library_writers.append(TupleColumn.write_data)
+        TupleColumn.write_data = cls.write_data
+
+    @staticmethod
+    def write_data(column: Any, items: Any, buf: Any) -> None:
+        """Writes the tuples of a column - none as no value of each element.
+
+        Args:
+            column: The library's tuple column.
+            items: The tuples.
+            buf: The buffer written into.
+        """
+        if items:
+            ClickhouseDriverTupleColumns.library_writers[0](column, items, buf)
+            return
+        for nested_column in column.nested_columns:
+            nested_column.write_data([], buf)

hare/dialects/clickhouse/drivers/clickhouse_driver/client/clickhouse_driver_variant_column.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from clickhouse_driver.columns.dynamiccolumn import DynamicColumn
+from clickhouse_driver.reader import read_binary_uint64
+from clickhouse_driver.writer import write_binary_uint64
+
+from hare.dialects.clickhouse.drivers.clickhouse_driver.constants import CLICKHOUSE_DRIVER_VARIANT_BASIC_MODE
+from hare.dialects.clickhouse.drivers.constants import CLICKHOUSE_VARIANT_NULL_DISCRIMINATOR
+
+
+class ClickhouseDriverVariantColumn(DynamicColumn):  # type: ignore[misc]
+    """clickhouse-driver's ``Variant(T, ...)`` column - read as the library reads a ``Dynamic`` column's
+    values, a variant of the types it lists, with the types in the column's type instead; written from
+    values bound with their type, each through the library's column of that type.
+
+    Args:
+        variant_types: The types of the variant, as the server sorts them.
+        column_by_specification_getter: Builds the library's column of a type.
+        **column_options: The library's column options.
+    """
+
+    prefix_needs_items = True
+
+    def __init__(
+        self, variant_types: list[str], column_by_specification_getter: Callable[[str], Any], **column_options: Any
+    ) -> None:
+        super().__init__(column_by_specification_getter, **column_options)
+        self.variant_types = variant_types
+
+    def read_state_prefix(self, buf: Any) -> None:
+        self.variant_columns = [self.column_by_spec_getter(variant_type) for variant_type in self.variant_types]
+        self._shared_variant_index = None
+        self.discriminators_mode = read_binary_uint64(buf)
+        if self.discriminators_mode != CLICKHOUSE_DRIVER_VARIANT_BASIC_MODE:
+            raise NotImplementedError(
+                f"A Variant column whose discriminators are sent in mode {self.discriminators_mode} isn't read"
+            )
+        for column in self.variant_columns:
+            column.read_state_prefix(buf)
+
+    def get_variant_items(self, items: Any) -> tuple[bytes, list[list[Any]]]:
+        """Each row's discriminator, and the values of each type.
+
+        Args:
+            items: The values, each bound with its type, or None.
+
+        Returns:
+            The discriminators and the values per type.
+        """
+        discriminators = bytearray()
+        variant_items: list[list[Any]] = [[] for _ in self.variant_types]
+        for item in items:
+            if item is None:
+                discriminators.append(CLICKHOUSE_VARIANT_NULL_DISCRIMINATOR)
+                continue
+            index = self.variant_types.index(item.column_type)
+            discriminators.append(index)
+            variant_items[index].append(item.value)
+        return bytes(discriminators), variant_items
+
+    def write_state_prefix(self, buf: Any, items: Any = None) -> None:
+        self.variant_columns = [self.column_by_spec_getter(variant_type) for variant_type in self.variant_types]
+        write_binary_uint64(CLICKHOUSE_DRIVER_VARIANT_BASIC_MODE, buf)
+        variant_items = self.get_variant_items(items or [])[1]
+        for column, column_items in zip(self.variant_columns, variant_items, strict=True):
+            column.write_state_prefix(buf, column_items)
+
+    def _write_data(self, items: Any, buf: Any) -> None:
+        discriminators, variant_items = self.get_variant_items(items)
+        buf.write(discriminators)
+        for column, column_items in zip(self.variant_columns, variant_items, strict=True):
+            if column_items:
+                column.write_data(column_items, buf)

hare/dialects/clickhouse/drivers/clickhouse_driver/constants.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import datetime
+from decimal import Context
+
+from hare.dialects.base.connection.connection_option import ConnectionOption
+from hare.dialects.base.connection.connection_options import ConnectionOptions
+from hare.dialects.clickhouse.client.constants import CLICKHOUSE_CONNECTION_OPTION_DEFAULTS
+from hare.dialects.clickhouse.constants import CLICKHOUSE_CONNECTION_OPTIONS
+from hare.dialects.enums import ConnectionOptionType
+
+#: The most connections a client can be told to keep.
+CLICKHOUSE_DRIVER_MAX_POOL_SIZE = 1024
+
+#: The loggers of the clickhouse-driver library.
+CLICKHOUSE_DRIVER_LOGGER_NAMES = ("clickhouse_driver",)
+
+#: The settings of a clickhouse-driver connection: ClickHouse's own, and the most connections the
+#: client keeps - the statements it runs at once.
+CLICKHOUSE_DRIVER_CONNECTION_OPTIONS = CLICKHOUSE_CONNECTION_OPTIONS + ConnectionOptions(
+    ConnectionOption(
+        "max_size", ConnectionOptionType.WHOLE_NUMBER, minimum=1, maximum=CLICKHOUSE_DRIVER_MAX_POOL_SIZE
+    ),
+)
+
+#: The values of the connection settings left unset.
+CLICKHOUSE_DRIVER_CONNECTION_OPTION_DEFAULTS = {**CLICKHOUSE_CONNECTION_OPTION_DEFAULTS, "max_size": 16}
+
+#: The logger clickhouse-driver's connection writes to.
+CLICKHOUSE_DRIVER_LIBRARY_LOGGER_NAME = "clickhouse_driver.connection"
+
+#: The formats of the records the library writes of a statement it sends - the statement's whole text,
+#: the values written into it.
+CLICKHOUSE_DRIVER_STATEMENT_LOG_FORMATS = frozenset({"Query: %s"})
+
+#: How the blocks sent and received are compressed with ``compress`` on.
+CLICKHOUSE_DRIVER_COMPRESSION = "lz4"
+#: The setting naming how the server compresses the blocks it sends, and its value matching
+#: ``CLICKHOUSE_DRIVER_COMPRESSION`` - the server's default is ZSTD from ClickHouse 26.9 on.
+CLICKHOUSE_DRIVER_NETWORK_COMPRESSION_SETTING = "network_compression_method"
+CLICKHOUSE_DRIVER_NETWORK_COMPRESSION_METHOD = "LZ4"
+
+#: What the names of a client's worker threads begin with.
+CLICKHOUSE_DRIVER_THREAD_NAME_PREFIX = "hare-clickhouse"
+
+#: The seconds ``close()`` waits for the statements still running before it breaks their connections.
+CLICKHOUSE_DRIVER_CLOSE_TIMEOUT_SECONDS = 10
+
+#: The error of a statement that had not started when ``close()`` stopped waiting.
+CLICKHOUSE_DRIVER_CLOSED_MESSAGE = "The connection was closed before the statement started"
+
+#: The statement a binary insert begins with - the library sends the rows after it as blocks.
+CLICKHOUSE_DRIVER_INSERT_STATEMENT_TEMPLATE = "INSERT INTO {table} ({columns}) VALUES"
+
+#: The seconds after its last statement within which a connection starts the next one without the
+#: ping the library sends first - a connection idle for longer is checked, and opened again when
+#: the server closed it meanwhile.
+CLICKHOUSE_DRIVER_PING_AFTER_IDLE_SECONDS = 10.0
+
+#: The fractional digits of a second Python's ``datetime`` keeps.
+CLICKHOUSE_DRIVER_MICROSECOND_DIGITS = 6
+CLICKHOUSE_DRIVER_MICROSECONDS_PER_SECOND = 1_000_000
+CLICKHOUSE_DRIVER_MICROSECONDS_PER_DAY = 86_400 * CLICKHOUSE_DRIVER_MICROSECONDS_PER_SECOND
+#: How the server's type of a column of moments with a fraction of a second begins - the digits
+#: of the fraction follow.
+CLICKHOUSE_DRIVER_TICKS_MOMENT_TYPE_PREFIX = "DateTime64("
+#: The server's type of a column of moments of whole seconds, and how it begins when it names a
+#: time zone.
+CLICKHOUSE_DRIVER_SECONDS_MOMENT_TYPE = "DateTime"
+CLICKHOUSE_DRIVER_SECONDS_MOMENT_TYPE_PREFIX = "DateTime("
+
+#: What a column type holding moments at any depth names.
+CLICKHOUSE_DRIVER_MOMENT_TYPE_NAME = "DateTime"
+#: The container types a moment can be held in.
+CLICKHOUSE_DRIVER_ARRAY_TYPE = "Array"
+CLICKHOUSE_DRIVER_MAP_TYPE = "Map"
+CLICKHOUSE_DRIVER_TUPLE_TYPE = "Tuple"
+#: The moment the ticks of a column of moments count from, naive - its UTC wall clock.
+CLICKHOUSE_DRIVER_NAIVE_MOMENT_EPOCH = datetime.datetime(1970, 1, 1)
+#: The names of the zone whose wall clock is UTC's - a moment in it is the epoch plus its ticks.
+CLICKHOUSE_DRIVER_UTC_ZONE_NAMES = frozenset({"UTC", "Etc/UTC"})
+
+#: The geometry types the library doesn't know -> the type each is written as.
+CLICKHOUSE_DRIVER_GEOMETRY_ALIASES = (
+    ("LineString", "Array(Point)"),
+    ("MultiLineString", "Array(LineString)"),
+)
+#: How a ``Variant`` column's discriminators are sent - one byte per row; the compact mode isn't read.
+CLICKHOUSE_DRIVER_VARIANT_BASIC_MODE = 0
+#: The batches of a streamed query its reader may hold unread - the worker thread reading the rows waits
+#: beyond them; and how often the waiting thread looks whether the reader stopped, in seconds.
+CLICKHOUSE_DRIVER_STREAM_QUEUE_SIZE = 2
+CLICKHOUSE_DRIVER_STREAM_WAIT_SECONDS = 0.1
+
+#: The first column of the ProfileEvents block the server sends after each statement - read by the
+#: library only to be dropped, so hare passes its values over unread.
+CLICKHOUSE_DRIVER_PROFILE_EVENTS_FIRST_COLUMN = "host_name"
+#: The bytes a value of a column type takes - the types of the ProfileEvents block passed over.
+CLICKHOUSE_DRIVER_FIXED_VALUE_WIDTHS = {
+    "UInt8": 1,
+    "Int8": 1,
+    "UInt16": 2,
+    "Int16": 2,
+    "UInt32": 4,
+    "Int32": 4,
+    "Float32": 4,
+    "DateTime": 4,
+    "UInt64": 8,
+    "Int64": 8,
+    "Float64": 8,
+}
+#: How the types whose values take a fixed width whatever their arguments begin, with that width.
+CLICKHOUSE_DRIVER_FIXED_VALUE_WIDTH_PREFIXES = (("Enum8(", 1), ("Enum16(", 2))
+#: The type of a column of strings, each written as its length and its bytes.
+CLICKHOUSE_DRIVER_STRING_TYPE = "String"
+
+#: The most decompressor classes kept by the compression method byte of a block - one per method.
+CLICKHOUSE_DRIVER_DECOMPRESSOR_CACHE_SIZE = 8
+
+#: How a column type with arguments begins for the types the library is taught: ``Dynamic(...)`` and
+#: ``Variant(...)``.
+CLICKHOUSE_DRIVER_DYNAMIC_PREFIX = "Dynamic("
+CLICKHOUSE_DRIVER_VARIANT_PREFIX = "Variant("
+
+#: The most sets of statement settings kept written - the connection's own, and those of a
+#: statement streaming its rows in blocks of a size of its own.
+CLICKHOUSE_DRIVER_SETTINGS_CACHE_SIZE = 64
+
+#: The context a decimal column's values are built in - the precision of ClickHouse's widest decimal.
+CLICKHOUSE_DRIVER_DECIMAL_CONTEXT = Context(prec=76)
+
+#: What the library puts between the server's message of an error and the server's stack trace.
+CLICKHOUSE_DRIVER_STACK_TRACE_SEPARATOR = ". Stack trace:"