hare-orm 0.9.0__py3-none-any.whl

hare/dialects/clickhouse/schema/constants.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import re
+
+#: The fields a ClickHouse container type maps to.
+CLICKHOUSE_ARRAY_FIELD_PATH = "hare.fields.data.containers.ArrayField"
+CLICKHOUSE_MAP_FIELD_PATH = "hare.fields.data.containers.MapField"
+CLICKHOUSE_TUPLE_FIELD_PATH = "hare.fields.data.containers.TupleField"
+CLICKHOUSE_NESTED_FIELD_PATH = "hare.fields.data.containers.NestedField"
+#: The field a type no field maps to is read as - its values as text.
+CLICKHOUSE_FALLBACK_FIELD_PATH = "hare.fields.data.text.TextField"
+#: The field of a dictionary-encoded type.
+CLICKHOUSE_LOW_CARDINALITY_FIELD_PATH = "hare.dialects.clickhouse.fields.LowCardinalityField"
+#: The fields of an enum: of one numbered as a ``CharEnumField`` numbers its values, of one whose labels
+#: are member names, and of the labels of any other.
+CLICKHOUSE_CHAR_ENUM_FIELD_PATH = "hare.fields.data.choices.CharEnumField"
+CLICKHOUSE_INT_ENUM_FIELD_PATH = "hare.fields.data.choices.IntEnumField"
+CLICKHOUSE_ENUM_LABEL_FIELD_PATH = "hare.fields.data.text.CharField"
+#: The name an enum class read off a column type is given after - its column's name follows it.
+CLICKHOUSE_INSPECTED_ENUM_NAME = "labels"
+#: The fields of a value of any type and of a value of one of several types.
+CLICKHOUSE_DYNAMIC_FIELD_PATH = "hare.dialects.clickhouse.fields.DynamicField"
+CLICKHOUSE_VARIANT_FIELD_PATH = "hare.dialects.clickhouse.fields.VariantField"
+#: How the most types a ``Dynamic`` column keeps apart is named in its type.
+CLICKHOUSE_DYNAMIC_MAX_TYPES_ARGUMENT = "max_types="
+#: The codecs of a column as ``CODEC(...)`` takes them - names with their arguments, comma-separated.
+CLICKHOUSE_CODEC_PATTERN = re.compile(
+    r"[A-Za-z][A-Za-z0-9_]*(?:\([A-Za-z0-9_, ]*\))?(?:\s*,\s*[A-Za-z][A-Za-z0-9_]*(?:\([A-Za-z0-9_, ]*\))?)*"
+)
+#: The table settings a table with projections takes a lightweight DELETE and the merges of an engine
+#: dropping rows (``ReplacingMergeTree``, ...) by, and their value - the projections of the parts the
+#: rows leave are built again.
+CLICKHOUSE_PROJECTION_REBUILD_SETTINGS = ("lightweight_mutation_projection_mode", "deduplicate_merge_projection_mode")
+CLICKHOUSE_PROJECTION_REBUILD_MODE = "rebuild"
+#: A view - a table of the ``View`` engine.
+CLICKHOUSE_VIEW_CREATE_TEMPLATE = "CREATE {or_replace}VIEW {view} AS\n{query};"
+#: A view of either type is dropped and renamed as a table.
+CLICKHOUSE_VIEW_DROP_TEMPLATE = "DROP VIEW {if_exists}{view};"
+CLICKHOUSE_VIEW_RENAME_TEMPLATE = "RENAME TABLE {view} TO {new_view};"
+#: A materialized view - refreshed on a schedule or following the inserts of the table it reads,
+#: writing to a table or keeping a storage of its own.
+CLICKHOUSE_MATERIALIZED_VIEW_CREATE_TEMPLATE = (
+    "CREATE MATERIALIZED VIEW {if_not_exists}{view}{schedule}{storage}{empty} AS\n{query};"
+)
+#: The settings of a materialized view's own sorted storage - its columns are its query's, and a
+#: nullable one may be a key: ``unique_columns`` of a column holding NULL.
+CLICKHOUSE_MATERIALIZED_VIEW_STORAGE_SETTINGS_SQL = " SETTINGS allow_nullable_key = 1"
+#: The rows of a materialized view's query written into it.
+CLICKHOUSE_MATERIALIZED_VIEW_FILL_TEMPLATE = "INSERT INTO {view}\n{query};"
+#: The query and the schedule of a materialized view changed in place.
+CLICKHOUSE_MATERIALIZED_VIEW_QUERY_TEMPLATE = "ALTER TABLE {view} MODIFY QUERY\n{query};"
+CLICKHOUSE_MATERIALIZED_VIEW_SCHEDULE_TEMPLATE = "ALTER TABLE {view} MODIFY REFRESH {schedule};"
+#: A refresh of a view refreshed on a schedule started now, and waited for.
+CLICKHOUSE_VIEW_REFRESH_TEMPLATE = "SYSTEM REFRESH VIEW {view};"
+CLICKHOUSE_VIEW_WAIT_TEMPLATE = "SYSTEM WAIT VIEW {view};"
+CLICKHOUSE_TABLE_TRUNCATE_TEMPLATE = "TRUNCATE TABLE {table};"
+#: The schedule of a refreshed view as ``REFRESH`` takes it - ``EVERY 1 DAY OFFSET 2 HOUR``.
+CLICKHOUSE_REFRESH_SCHEDULE_PATTERN = re.compile(
+    r"(?:EVERY|AFTER)(?: \d+ (?:SECOND|MINUTE|HOUR|DAY|WEEK|MONTH|YEAR)S?)+"
+    r"(?: OFFSET(?: \d+ (?:SECOND|MINUTE|HOUR|DAY|WEEK|MONTH|YEAR)S?)+)?"
+    r"(?: RANDOMIZE FOR(?: \d+ (?:SECOND|MINUTE|HOUR|DAY|WEEK|MONTH|YEAR)S?)+)?",
+    re.IGNORECASE,
+)
+#: A dictionary - its columns, its key, where it is loaded from, how it is kept and for how long.
+CLICKHOUSE_DICTIONARY_CREATE_TEMPLATE = (
+    "CREATE {or_replace}DICTIONARY {exists}{dictionary} ({columns}) PRIMARY KEY {key} SOURCE({source}) "
+    "LAYOUT({layout}){lifetime};"
+)
+#: How long a dictionary keeps its rows before loading them again.
+CLICKHOUSE_DICTIONARY_LIFETIME_TEMPLATE = " LIFETIME(MIN {lifetime_minimum} MAX {lifetime_maximum})"
+#: The layouts that keep no rows - each lookup reads the source - and so take no ``LIFETIME``.
+CLICKHOUSE_DICTIONARY_DIRECT_LAYOUT_NAMES = frozenset({"DIRECT", "COMPLEX_KEY_DIRECT"})
+CLICKHOUSE_DICTIONARY_DROP_TEMPLATE = "DROP DICTIONARY {if_exists}{dictionary};"
+CLICKHOUSE_DICTIONARY_RENAME_TEMPLATE = "RENAME DICTIONARY {dictionary} TO {new_dictionary};"
+CLICKHOUSE_DICTIONARY_RELOAD_TEMPLATE = "SYSTEM RELOAD DICTIONARY {dictionary};"
+#: The source of a dictionary of a model's own table - read by the server from itself, as the user of
+#: the connection: without one it reads as the default user with no password.
+CLICKHOUSE_DICTIONARY_TABLE_SOURCE_TEMPLATE = "CLICKHOUSE(DB {database} TABLE {table} USER {user} PASSWORD {password})"
+#: What stands for the password in a dictionary's SQL that is shown, not run.
+CLICKHOUSE_DICTIONARY_HIDDEN_PASSWORD = "[HIDDEN]"  # nosec B105
+#: An environment variable a dictionary's source reads when the dictionary is created.
+CLICKHOUSE_DICTIONARY_ENVIRONMENT_PATTERN = re.compile(r"\{env:([A-Za-z_][A-Za-z0-9_]*)\}")
+#: The layout of a dictionary keyed by fields of any types.
+CLICKHOUSE_DICTIONARY_DEFAULT_LAYOUT = "COMPLEX_KEY_HASHED()"
+#: A dictionary's layout with its arguments - ``CACHE(SIZE_IN_CELLS 1000)``.
+CLICKHOUSE_DICTIONARY_LAYOUT_PATTERN = re.compile(r"[A-Za-z_]+\([A-Za-z0-9_ '/.\-]*\)")
+#: The longest a dictionary waits to be loaded again, in seconds - ten years.
+CLICKHOUSE_DICTIONARY_LIFETIME_LIMIT = 315_360_000
+#: How the engines of the MergeTree family end, and the table options of theirs alone.
+CLICKHOUSE_MERGE_TREE_ENGINE_SUFFIX = "MergeTree"
+CLICKHOUSE_MERGE_TREE_OPTIONS = (
+    "order_by",
+    "sample_by",
+    "partition_by",
+    "ttl",
+    "settings",
+    "column_ttls",
+    "projections",
+    "lightweight_updates",
+)
+#: The table settings a table changed by lightweight UPDATEs takes - the number of each row's block and
+#: its place in it, which the new values written beside a row are matched to it by.
+CLICKHOUSE_LIGHTWEIGHT_UPDATE_SETTINGS = ("enable_block_number_column", "enable_block_offset_column")
+CLICKHOUSE_LIGHTWEIGHT_UPDATE_SETTING_VALUE = 1
+#: The table options ClickHouse changes with an ``ALTER TABLE`` - a change of any other one remakes the
+#: table.
+CLICKHOUSE_ALTERABLE_TABLE_OPTIONS = frozenset(
+    {"ttl", "settings", "column_codecs", "column_ttls", "projections", "lightweight_updates"}
+)
+#: The table settings set when the table is created and never after.
+CLICKHOUSE_CREATION_ONLY_TABLE_SETTINGS = frozenset({"index_granularity", "index_granularity_bytes"})
+
+#: Writes the default of a column just added into the rows stored before it - they would read the
+#: column's default as declared at the time of reading.
+CLICKHOUSE_MATERIALIZE_COLUMN_TEMPLATE = "ALTER TABLE {table} MATERIALIZE COLUMN {column}"
+#: A column made NOT NULL with the DEFAULT its NULL rows would take - ClickHouse 25.12+ refuses the change
+#: of a column that has none.
+CLICKHOUSE_NOT_NULL_WITH_DEFAULT_TEMPLATE = "MODIFY COLUMN {column} {sql_type} DEFAULT {default}"
+#: The empty value of a type - the default of a column made NOT NULL that declares none, dropped again.
+CLICKHOUSE_TYPE_EMPTY_VALUE_SQL = "defaultValueOfTypeName({type_name})"
+#: Removes the rows a lightweight DELETE only marked - a MODIFY COLUMN converts them too, and fails on a
+#: value of a deleted row the new type can't hold.
+CLICKHOUSE_APPLY_DELETED_MASK_TEMPLATE = "ALTER TABLE {table} APPLY DELETED MASK"
+
+#: The start of a refresh schedule a view's dependencies need - ClickHouse refreshes a view of
+#: ``REFRESH AFTER`` on its own.
+CLICKHOUSE_REFRESH_EVERY_KEYWORD = "EVERY"
+#: A whole number as a Decimal256 - a bound a Decimal or a float column is compared with; a Decimal
+#: compared with an Int64 bound past its own digits raises DECIMAL_OVERFLOW.
+CLICKHOUSE_WIDE_DECIMAL_BOUND_TEMPLATE = "toDecimal256('{}', 0)"
+#: A column made NOT NULL while it holds NULL - ClickHouse would write its type's default in place of
+#: each.
+CLICKHOUSE_NOT_NULL_CHANGE_REFUSED_MESSAGE = "column {column} of table {table} holds NULL"
+#: A text column's type - a type change from it parses each value, and a value that doesn't parse fails
+#: the change's mutation after the column took its new type, or becomes NULL in a Nullable one.
+CLICKHOUSE_TEXT_COLUMN_TYPE_PATTERN = r"(?:Nullable\(|LowCardinality\()*(?:String|FixedString\(\d+\))\)*"
+#: The type a column has and the server's name of the type it changes to - a field's type is declared
+#: by its SQL name (``INT``, ``VARCHAR(40)``); no row is read of an empty table.
+CLICKHOUSE_COLUMN_TYPES_QUERY = (
+    "SELECT toTypeName({column}) AS old_type, toTypeName(defaultValueOfTypeName({new_type})) AS new_type "
+    "FROM {table} LIMIT 1"
+)
+#: The precision and scale of a Decimal column's type.
+CLICKHOUSE_DECIMAL_COLUMN_TYPE_PATTERN = r"Decimal\((\d+),\s*(\d+)\)"
+#: A label of an Enum column's type, as the SQL literal it is declared with.
+CLICKHOUSE_ENUM_LABEL_PATTERN = r"('(?:[^'\\]|\\.)*')\s*=\s*-?\d+"
+#: The column types a text column changes to unchecked - every text is one of a text type, and a
+#: container's values have no cast a check could read.
+CLICKHOUSE_UNCHECKED_CONVERSION_TYPE_PREFIXES = (
+    "String",
+    "FixedString",
+    "LowCardinality(String",
+    "Array(",
+    "Map(",
+    "Tuple(",
+    "Nested(",
+)
+#: A text read as a value of a type - NULL for a text that isn't one.
+CLICKHOUSE_CONVERTED_VALUE_TEMPLATE = "accurateCastOrNull({column}, {type})"
+#: A text read as a decimal with every fractional digit it has.
+CLICKHOUSE_DECIMAL_TEXT_TEMPLATE = "toDecimal256OrNull({column}, 38)"
+#: A text a date column doesn't hold as written - ClickHouse reads an impossible date as 1970-01-01
+#: and a day past a month's end as one of the next month.
+CLICKHOUSE_UNCONVERTED_DATE_TEMPLATE = "{value} IS NULL OR toString({value}) != substring(trimBoth({column}), 1, 10)"
+#: A text a moment column doesn't hold as written - an impossible moment is read as 1900-01-01.
+CLICKHOUSE_UNCONVERTED_MOMENT_TEMPLATE = (
+    "{value} IS NULL OR NOT startsWith(formatDateTime({value}, '%F %T'), "
+    "substring(replaceOne(trimBoth({column}), 'T', ' '), 1, 19))"
+)
+#: A text a JSON column doesn't hold - one that isn't JSON, or isn't a JSON object.
+CLICKHOUSE_UNCONVERTED_JSON_TEMPLATE = "NOT isValidJSON({column}) OR NOT startsWith(trimLeft({column}), '{{')"
+#: One stored value of a column a type change doesn't convert.
+CLICKHOUSE_UNCONVERTED_VALUE_QUERY = (
+    "SELECT {column} AS value FROM {table} WHERE {column} IS NOT NULL AND ({predicate}) LIMIT 1"
+)
+#: A stored value a column's type change doesn't convert to its new type.
+CLICKHOUSE_VALUE_NOT_CONVERTED_MESSAGE = 'column {column} of table {table} holds "{value}", which is no {new_type}'
+#: A column's values the server converts to no value of the new type at all.
+CLICKHOUSE_TYPE_NOT_CONVERTED_MESSAGE = (
+    "column {column} of table {table} is a {old_type}, which ClickHouse converts to no {new_type}: {error}"
+)
+#: The wrappers of a column type around the type of its values.
+CLICKHOUSE_TYPE_WRAPPER_PATTERN = r"(?:Nullable|LowCardinality)\((.*)\)"
+#: A number column's type - a change between two of them is checked by the narrowing check.
+CLICKHOUSE_NUMBER_COLUMN_TYPE_PATTERN = r"(?:U?Int\d+|Float\d+|Decimal(?:\d+)?\(.*\)|Bool)"
+#: A column's comment changed - an empty one for none.
+CLICKHOUSE_COLUMN_COMMENT_CHANGE_TEMPLATE = "ALTER TABLE {table} COMMENT COLUMN {column} {comment}"
+#: A table's comment changed - an empty one for none.
+CLICKHOUSE_TABLE_COMMENT_CHANGE_TEMPLATE = "ALTER TABLE {table} MODIFY COMMENT {comment}"
+#: What the shadow database of drift is named after - a random part follows.
+CLICKHOUSE_SHADOW_DATABASE_PREFIX = "hare_shadow_"
+#: The connection's database with its engine - a shadow of a Replicated one is Replicated too.
+CLICKHOUSE_SHADOW_DATABASE_ENGINE_SQL = (
+    "SELECT name, engine, engine_full FROM system.databases WHERE name = currentDatabase()"
+)
+#: Another database of the server a model is in, with its engine - its shadow takes the same engine.
+CLICKHOUSE_SHADOW_OTHER_DATABASE_ENGINE_SQL = "SELECT name, engine, engine_full FROM system.databases WHERE name = $1"
+#: The shadow database created - with an engine of its own, or the server's default one.
+CLICKHOUSE_SHADOW_DATABASE_CREATE_TEMPLATE = "CREATE DATABASE {database}{engine}"
+#: The shadow database dropped - its replicated tables' Keeper paths removed before it returns.
+CLICKHOUSE_SHADOW_DATABASE_DROP_TEMPLATE = "DROP DATABASE IF EXISTS {database} SYNC"

hare/dialects/clickhouse/schema/declarations.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from hare.dialects.base.schema.base_schema_editor import BaseSchemaEditor
+from hare.dialects.base.schema.columns.column_backfill import ColumnBackfill
+from hare.dialects.base.schema.columns.column_conversion_check import ColumnConversionCheck
+from hare.dialects.base.schema.columns.column_definitions import ColumnDefinitions
+from hare.dialects.base.schema.columns.column_narrowing_check import ColumnNarrowingCheck
+from hare.dialects.base.schema.columns.column_renames import ColumnRenames
+from hare.dialects.base.schema.indexes.index_statements import IndexStatements
+from hare.dialects.base.schema.runtime_statements.table_clearing import TableClearing
+from hare.dialects.base.schema.schema_objects.dictionaries import Dictionaries
+from hare.dialects.base.schema.schema_objects.materialized_views import MaterializedViews
+from hare.dialects.base.schema.schema_objects.schemas import Schemas
+from hare.dialects.base.schema.schema_objects.views import Views
+from hare.dialects.base.schema.tables.table_comments import TableComments
+from hare.dialects.base.schema.tables.table_creation import TableCreation
+from hare.dialects.base.schema.tables.table_partitions import TablePartitions
+from hare.dialects.base.schema.tables.table_rebuild import TableRebuild
+from hare.dialects.clickhouse.schema.columns.clickhouse_column_backfill import ClickhouseColumnBackfill
+from hare.dialects.clickhouse.schema.columns.clickhouse_column_conversion_check import (
+    ClickhouseColumnConversionCheck,
+)
+from hare.dialects.clickhouse.schema.columns.clickhouse_column_definitions import ClickhouseColumnDefinitions
+from hare.dialects.clickhouse.schema.columns.clickhouse_column_narrowing_check import ClickhouseColumnNarrowingCheck
+from hare.dialects.clickhouse.schema.columns.clickhouse_column_renames import ClickhouseColumnRenames
+from hare.dialects.clickhouse.schema.indexes.clickhouse_index_statements import ClickhouseIndexStatements
+from hare.dialects.clickhouse.schema.runtime_statements.clickhouse_table_clearing import ClickhouseTableClearing
+from hare.dialects.clickhouse.schema.schema_objects.clickhouse_dictionaries import ClickhouseDictionaries
+from hare.dialects.clickhouse.schema.schema_objects.clickhouse_materialized_views import ClickhouseMaterializedViews
+from hare.dialects.clickhouse.schema.schema_objects.clickhouse_schemas import ClickhouseSchemas
+from hare.dialects.clickhouse.schema.schema_objects.clickhouse_views import ClickhouseViews
+from hare.dialects.clickhouse.schema.tables.clickhouse_table_comments import ClickhouseTableComments
+from hare.dialects.clickhouse.schema.tables.clickhouse_table_creation import ClickhouseTableCreation
+from hare.dialects.clickhouse.schema.tables.clickhouse_table_partitions import ClickhouseTablePartitions
+from hare.dialects.clickhouse.schema.tables.clickhouse_table_rebuild import ClickhouseTableRebuild
+
+if TYPE_CHECKING:
+    from hare.dialects.clickhouse.client.clickhouse_client import ClickhouseClient
+    from hare.models import Model
+
+
+class ClickhouseSchemaEditor(BaseSchemaEditor):
+    """ClickHouse's DDL - a table needs an engine, a column changes with ``MODIFY COLUMN``, and an
+    index is a data skipping index of its table."""
+
+    column_backfill_class: ClassVar[type[ColumnBackfill]] = ClickhouseColumnBackfill
+    column_conversion_check_class: ClassVar[type[ColumnConversionCheck]] = ClickhouseColumnConversionCheck
+    column_definitions_class: ClassVar[type[ColumnDefinitions]] = ClickhouseColumnDefinitions
+    column_narrowing_check_class: ClassVar[type[ColumnNarrowingCheck]] = ClickhouseColumnNarrowingCheck
+    column_renames_class: ClassVar[type[ColumnRenames]] = ClickhouseColumnRenames
+    index_statements_class: ClassVar[type[IndexStatements]] = ClickhouseIndexStatements
+    table_comments_class: ClassVar[type[TableComments]] = ClickhouseTableComments
+    table_creation_class: ClassVar[type[TableCreation]] = ClickhouseTableCreation
+    table_clearing_class: ClassVar[type[TableClearing]] = ClickhouseTableClearing
+    table_partitions_class: ClassVar[type[TablePartitions]] = ClickhouseTablePartitions
+    table_rebuild_class: ClassVar[type[TableRebuild]] = ClickhouseTableRebuild
+    views_class: ClassVar[type[Views]] = ClickhouseViews
+    materialized_views_class: ClassVar[type[MaterializedViews]] = ClickhouseMaterializedViews
+    dictionaries_class: ClassVar[type[Dictionaries]] = ClickhouseDictionaries
+    schemas_class: ClassVar[type[Schemas]] = ClickhouseSchemas
+
+    client: ClickhouseClient
+    materialized_views: ClickhouseMaterializedViews
+    schemas: ClickhouseSchemas
+    table_creation: ClickhouseTableCreation
+    table_rebuild: ClickhouseTableRebuild
+
+    async def create_model(self, model: type[Model]) -> None:
+        await self.table_creation.raise_if_replicas_keep_rows_apart(model)
+        await super().create_model(model)
+
+    # An automatic through table has no primary key: its rows are kept unsorted.
+    MANY_TO_MANY_TABLE_TEMPLATE = (
+        "CREATE TABLE {exists}{table_name} ({fields}) ENGINE = MergeTree ORDER BY tuple(){extra}{comment};"
+    )
+    RENAME_TABLE_TEMPLATE = "RENAME TABLE {old_table} TO {new_table}"
+    DELETE_TABLE_TEMPLATE = "DROP TABLE {table}"
+    DELETE_FIELD_TEMPLATE = "ALTER TABLE {table} DROP COLUMN {column}"
+    ALTER_FIELD_TYPE_TEMPLATE = "MODIFY COLUMN {column} {sql_type}"
+    # A column holds NULL by its type - its nullability changes with its type declared again.
+    ALTER_FIELD_NULL_TEMPLATE = "MODIFY COLUMN {column} {sql_type}"
+    ALTER_FIELD_NOT_NULL_TEMPLATE = "MODIFY COLUMN {column} {sql_type}"
+    UPDATE_ROWS_TEMPLATE = "ALTER TABLE {table} UPDATE {assignments} WHERE {condition}"
+    ALTER_FIELD_SET_DEFAULT_TEMPLATE = "MODIFY COLUMN {column} DEFAULT {default}"
+    ALTER_FIELD_DROP_DEFAULT_TEMPLATE = "MODIFY COLUMN {column} REMOVE DEFAULT"
+    # A column computed on write is stored with the row, one computed on read is an alias of its
+    # expression - neither comes with SELECT *.
+    STORED_GENERATED_COLUMN_TEMPLATE = "MATERIALIZED {expression}"
+    VIRTUAL_GENERATED_COLUMN_TEMPLATE = "ALIAS {expression}"
+    # An index is added as a change of its table: the server runs no CREATE INDEX over a cluster.
+    INDEX_CREATE_TEMPLATE = "ALTER TABLE {table_name} ADD INDEX {exists}{index_name} ({fields}){index_type}{extra};"
+    RENAME_CONSTRAINT_TEMPLATE = None
+    DROP_INDEX_TEMPLATE = "ALTER TABLE {table} DROP INDEX {name}"

hare/dialects/clickhouse/schema/indexes/clickhouse_index_statements.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from hare.ddl.enums import GeneratedNamePrefix
+from hare.ddl.generated_names import GeneratedNames
+from hare.dialects.base.schema.indexes.index_statements import IndexStatements
+from hare.dialects.clickhouse.constants import CLICKHOUSE_DEFAULT_INDEX_GRANULARITY_SQL, CLICKHOUSE_DEFAULT_INDEX_TYPE
+
+if TYPE_CHECKING:
+    from hare.models import Model
+
+
+class ClickhouseIndexStatements(IndexStatements):
+    """ClickHouse's ``CREATE INDEX`` - a data skipping index, its type and granularity written after
+    its keys; an index of no type is a ``minmax`` one of granularity 1."""
+
+    def get_index_sql(
+        self,
+        model: type[Model],
+        field_names: Sequence[str],
+        safe: bool = False,
+        index_name: str | None = None,
+        index_type: str | None = None,
+        extra: str | None = None,
+        opclasses: Sequence[str] | None = None,
+        unique: bool = False,
+        orders: Sequence[str] | None = None,
+        indexed_table_sql: str | None = None,
+    ) -> str:
+        return super().get_index_sql(
+            model,
+            field_names,
+            safe,
+            index_name=index_name,
+            index_type=index_type or CLICKHOUSE_DEFAULT_INDEX_TYPE,
+            extra=extra or CLICKHOUSE_DEFAULT_INDEX_GRANULARITY_SQL,
+            opclasses=opclasses,
+            unique=unique,
+            orders=orders,
+            indexed_table_sql=indexed_table_sql,
+        )
+
+    def format_index_type(self, index_type: str) -> str:
+        return f" TYPE {index_type}"
+
+    def get_table_index_sql(
+        self, table_name: str, column_names: Sequence[str], schema: str | None = None, safe: bool = False
+    ) -> str:
+        return self.editor.INDEX_CREATE_TEMPLATE.format(
+            exists=self.editor.table_creation.get_exists_sql(safe),
+            index_name=self.editor.quote(
+                GeneratedNames.get_index_name(GeneratedNamePrefix.INDEX, table_name, column_names)
+            ),
+            index_type=self.format_index_type(CLICKHOUSE_DEFAULT_INDEX_TYPE),
+            table_name=self.editor.qualify_table_name(table_name, schema),
+            fields=", ".join([self.editor.quote(column_name) for column_name in column_names]),
+            extra=CLICKHOUSE_DEFAULT_INDEX_GRANULARITY_SQL,
+        )

hare/dialects/clickhouse/schema/runtime_statements/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

hare/dialects/clickhouse/schema/runtime_statements/clickhouse_table_clearing.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from hare.dialects.base.client.database_client import DatabaseClient
+from hare.dialects.base.schema.runtime_statements.table_clearing import TableClearing
+
+
+class ClickhouseTableClearing(TableClearing):
+    """Tables emptied with ``TRUNCATE TABLE`` - a ClickHouse DELETE needs a condition and marks
+    every row deleted one by one."""
+
+    __slots__ = ()
+
+    @classmethod
+    async def clear_tables(cls, connection: DatabaseClient, quoted_tables: Sequence[str]) -> None:
+        if quoted_tables:
+            script = "".join(f"TRUNCATE TABLE {quoted_table};\n" for quoted_table in quoted_tables)  # nosec
+            await connection.execute_built_script(script)

hare/dialects/clickhouse/schema/schema_objects/clickhouse_dictionaries.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import os
+import re
+from typing import TYPE_CHECKING
+
+from hare.ddl.schema_objects.dictionary import Dictionary
+from hare.dialects.base.schema.schema_objects.dictionaries import Dictionaries
+from hare.dialects.clickhouse.schema.constants import (
+    CLICKHOUSE_DICTIONARY_CREATE_TEMPLATE,
+    CLICKHOUSE_DICTIONARY_DROP_TEMPLATE,
+    CLICKHOUSE_DICTIONARY_ENVIRONMENT_PATTERN,
+    CLICKHOUSE_DICTIONARY_HIDDEN_PASSWORD,
+    CLICKHOUSE_DICTIONARY_LIFETIME_TEMPLATE,
+    CLICKHOUSE_DICTIONARY_RELOAD_TEMPLATE,
+    CLICKHOUSE_DICTIONARY_RENAME_TEMPLATE,
+    CLICKHOUSE_DICTIONARY_TABLE_SOURCE_TEMPLATE,
+)
+from hare.dialects.clickhouse.schema_objects.clickhouse_dictionary import ClickhouseDictionary
+from hare.exceptions import ConfigurationError
+from hare.models import Model
+
+if TYPE_CHECKING:
+    from hare.dialects.clickhouse.schema.declarations import ClickhouseSchemaEditor
+
+
+class ClickhouseDictionaries(Dictionaries):
+    """Dictionaries as ClickHouse writes it - a dictionary's columns are those of the fields it names,
+    its source the model's table read by the connection's own user. It isn't dropped with the table it
+    reads."""
+
+    editor: ClickhouseSchemaEditor
+
+    __slots__ = ()
+
+    def get_dictionary_create_sqls(self, model: type[Model], dictionary: Dictionary, safe: bool = False) -> list[str]:
+        return [self.get_dictionary_sql(model, dictionary, exists="IF NOT EXISTS " if safe else "")]
+
+    def get_dictionary_sql(
+        self, model: type[Model], dictionary: Dictionary, *, exists: str = "", or_replace: str = ""
+    ) -> str:
+        """The statement creating a dictionary.
+
+        Args:
+            model: The model declaring it.
+            dictionary: The dictionary.
+            exists: ``IF NOT EXISTS`` with its trailing space, or nothing.
+            or_replace: ``OR REPLACE`` with its trailing space, or nothing.
+
+        Returns:
+            The statement.
+
+        Raises:
+            ConfigurationError: The dictionary isn't one of ClickHouse's, names no field of the
+                model, or its source names an environment variable that isn't set.
+        """
+        if not isinstance(dictionary, ClickhouseDictionary):
+            raise ConfigurationError(
+                f"{model.__name__}: Meta.dictionaries takes ClickhouseDictionary(...) on ClickHouse, got "
+                f"{dictionary!r}"
+            )
+        meta = model._meta
+        unknown = [name for name in dictionary.get_field_names() if name not in meta.fields_db_projection]
+        if unknown:
+            raise ConfigurationError(
+                f"{model.__name__}: ClickhouseDictionary {dictionary.name!r} names no field {unknown}"
+            )
+        quote = self.editor.quote
+        column_definitions = self.editor.column_definitions
+        column_sqls = []
+        for field_name in dictionary.get_field_names():
+            field = meta.fields_map[field_name]
+            column_type = column_definitions.get_altered_column_type(
+                column_definitions.get_table_column_type(model, field), field.null
+            )
+            column_sqls.append(f"{quote(meta.fields_db_projection[field_name])} {column_type}")
+        lifetime_minimum, lifetime_maximum = dictionary.get_lifetime_range()
+        return CLICKHOUSE_DICTIONARY_CREATE_TEMPLATE.format(
+            or_replace=or_replace,
+            exists=exists,
+            dictionary=self.editor.qualify_object_name(model, dictionary.name),
+            columns=", ".join(column_sqls),
+            key=", ".join(quote(meta.fields_db_projection[field_name]) for field_name in dictionary.key),
+            source=self.get_source_sql(model, dictionary),
+            layout=dictionary.layout,
+            lifetime=""
+            if dictionary.keeps_no_rows()
+            else CLICKHOUSE_DICTIONARY_LIFETIME_TEMPLATE.format(
+                lifetime_minimum=lifetime_minimum, lifetime_maximum=lifetime_maximum
+            ),
+        )
+
+    def get_source_sql(self, model: type[Model], dictionary: ClickhouseDictionary) -> str:
+        """What a dictionary is loaded from, as ``SOURCE(...)`` takes it.
+
+        Args:
+            model: The model declaring the dictionary.
+            dictionary: The dictionary.
+
+        Returns:
+            The declared source, each ``{env:NAME}`` of it replaced by the environment variable; the
+            model's table read by the connection's user without one - its password hidden in SQL
+            that is collected, not run.
+
+        Raises:
+            ConfigurationError: The source names an environment variable that isn't set.
+        """
+        literals = self.editor.client.dialect.literals
+        if dictionary.source is not None:
+
+            def get_variable_sql(match: re.Match[str]) -> str:
+                value = os.environ.get(match.group(1))
+                if value is None:
+                    raise ConfigurationError(
+                        f"ClickhouseDictionary {dictionary.name!r}: its source reads the environment variable "
+                        f"{match.group(1)}, which isn't set"
+                    )
+                # Without the quotes of a literal: the source writes its own around the variable.
+                return literals.get_string_literal_sql(value)[1:-1]
+
+            return CLICKHOUSE_DICTIONARY_ENVIRONMENT_PATTERN.sub(get_variable_sql, dictionary.source.sql.strip())
+        client = self.editor.client
+        password = CLICKHOUSE_DICTIONARY_HIDDEN_PASSWORD if self.editor.collect_sql else client.password
+        return CLICKHOUSE_DICTIONARY_TABLE_SOURCE_TEMPLATE.format(
+            database=literals.get_string_literal_sql(model._meta.schema or client.database or ""),
+            table=literals.get_string_literal_sql(model._meta.db_table),
+            user=literals.get_string_literal_sql(client.user),
+            password=literals.get_string_literal_sql(password),
+        )
+
+    async def drop_dictionary(self, model: type[Model], dictionary: Dictionary) -> None:
+        await self.editor.run_sql(
+            CLICKHOUSE_DICTIONARY_DROP_TEMPLATE.format(
+                if_exists="", dictionary=self.editor.qualify_object_name(model, dictionary.name)
+            )
+        )
+
+    async def drop_model_dictionaries(self, model: type[Model]) -> None:
+        for dictionary in reversed(model._meta.dictionaries):
+            await self.editor.run_sql(
+                CLICKHOUSE_DICTIONARY_DROP_TEMPLATE.format(
+                    if_exists="IF EXISTS ", dictionary=self.editor.qualify_object_name(model, dictionary.name)
+                )
+            )
+
+    async def alter_dictionary(
+        self, model: type[Model], old_dictionary: Dictionary, new_dictionary: Dictionary
+    ) -> None:
+        """Replaces the dictionary at once - a query reads the old one until the new one stands."""
+        await self.editor.run_sql(self.get_dictionary_sql(model, new_dictionary, or_replace="OR REPLACE "))
+
+    async def rename_dictionary(
+        self, model: type[Model], old_dictionary: Dictionary, new_dictionary: Dictionary
+    ) -> None:
+        if old_dictionary.name == new_dictionary.name:
+            return
+        await self.editor.run_sql(
+            CLICKHOUSE_DICTIONARY_RENAME_TEMPLATE.format(
+                dictionary=self.editor.qualify_object_name(model, old_dictionary.name),
+                new_dictionary=self.editor.qualify_object_name(model, new_dictionary.name),
+            )
+        )
+
+    async def reload_dictionary(self, model: type[Model], dictionary: Dictionary) -> None:
+        await self.editor.run_sql(
+            CLICKHOUSE_DICTIONARY_RELOAD_TEMPLATE.format(
+                dictionary=self.editor.qualify_object_name(model, dictionary.name)
+            )
+        )