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

# Сопоставление типов

> Сопоставление типов в ClickHouse и Elasticsearch

Elasticsearch и ClickHouse поддерживают широкий спектр типов данных, но их нижележащее хранилище и модели запросов фундаментально различаются. В этом разделе приведено сопоставление часто используемых типов полей Elasticsearch с их эквивалентами в ClickHouse, где они существуют, а также дан контекст, который поможет при миграции. Если эквивалента нет, в комментариях приведены альтернативы или примечания.

| **Тип Elasticsearch**              | **Эквивалент в ClickHouse**                                                                                                                                                                                                                                                             | **Примечания**                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `boolean`                          | [`UInt8`](/ru/reference/data-types/int-uint)  или [`Bool`](/ru/reference/data-types/boolean)                                                                                                                                                                                            | В новых версиях ClickHouse `Boolean` поддерживается как псевдоним для `UInt8`.                                                                                                                                                                                                                                                                                                                                                                                       |
| `keyword`                          | [`String`](/ru/reference/data-types/string)                                                                                                                                                                                                                                             | Используется для фильтрации по точному совпадению, группировки и сортировки.                                                                                                                                                                                                                                                                                                                                                                                         |
| `text`                             | [`String`](/ru/reference/data-types/string)                                                                                                                                                                                                                                             | Возможности полнотекстового поиска в ClickHouse ограничены; токенизация требует пользовательской логики с использованием таких функций, как `tokens`, в сочетании с функциями для работы с массивами.                                                                                                                                                                                                                                                                |
| `long`                             | [`Int64`](/ru/reference/data-types/int-uint)                                                                                                                                                                                                                                            | 64-битное целое число со знаком.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `integer`                          | [`Int32`](/ru/reference/data-types/int-uint)                                                                                                                                                                                                                                            | 32-битное целое число со знаком.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `short`                            | [`Int16`](/ru/reference/data-types/int-uint)                                                                                                                                                                                                                                            | 16-битное целое число со знаком.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `byte`                             | [`Int8`](/ru/reference/data-types/int-uint)                                                                                                                                                                                                                                             | 8-битное целое число со знаком.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `unsigned_long`                    | [`UInt64`](/ru/reference/data-types/int-uint)                                                                                                                                                                                                                                           | 64-битное целое число без знака.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `double`                           | [`Float64`](/ru/reference/data-types/float)                                                                                                                                                                                                                                             | 64-битное число с плавающей точкой.                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `float`                            | [`Float32`](/ru/reference/data-types/float)                                                                                                                                                                                                                                             | 32-битное число с плавающей точкой.                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `half_float`                       | [`Float32`](/ru/reference/data-types/float) или [`BFloat16`](/ru/reference/data-types/float)                                                                                                                                                                                            | Наиболее близкий эквивалент. В ClickHouse нет 16-битного числа с плавающей точкой. В ClickHouse есть `BFloat16` — он отличается от half-float IEEE-754: half-float обеспечивает более высокую точность при меньшем диапазоне, тогда как bfloat16 жертвует точностью ради более широкого диапазона, что делает его лучше подходящим для задач машинного обучения.                                                                                                     |
| `scaled_float`                     | [`Decimal(x, y)`](/ru/reference/data-types/decimal)                                                                                                                                                                                                                                     | Используется для хранения числовых значений с фиксированной точкой.                                                                                                                                                                                                                                                                                                                                                                                                  |
| `date`                             | [`DateTime`](/ru/reference/data-types/datetime)                                                                                                                                                                                                                                         | Эквивалентные типы даты и времени с точностью до секунды.                                                                                                                                                                                                                                                                                                                                                                                                            |
| `date_nanos`                       | [`DateTime64`](/ru/reference/data-types/datetime64)                                                                                                                                                                                                                                     | ClickHouse поддерживает точность до наносекунд с `DateTime64(9)`.                                                                                                                                                                                                                                                                                                                                                                                                    |
| `binary`                           | [`String`](/ru/reference/data-types/string), [`FixedString(N)`](/ru/reference/data-types/fixedstring)                                                                                                                                                                                   | Для бинарных полей требуется декодирование из base64.                                                                                                                                                                                                                                                                                                                                                                                                                |
| `ip`                               | [`IPv4`](/ru/reference/data-types/ipv4), [`IPv6`](/ru/reference/data-types/ipv6)                                                                                                                                                                                                        | Доступны встроенные типы `IPv4` и `IPv6`.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `object`                           | [`Nested`](/ru/reference/data-types/nested-data-structures), [`Map`](/ru/reference/data-types/map), [`Tuple`](/ru/reference/data-types/tuple), [`JSON`](/ru/reference/data-types/newjson)                                                                                               | В ClickHouse JSON-подобные объекты можно моделировать с помощью [`Nested`](/ru/reference/data-types/nested-data-structures) или [`JSON`](/ru/reference/data-types/newjson).                                                                                                                                                                                                                                                                                          |
| `flattened`                        | [`String`](/ru/reference/data-types/string)                                                                                                                                                                                                                                             | Тип `flattened` в Elasticsearch хранит целые объекты JSON как отдельные поля, обеспечивая гибкий, бессхемный доступ к вложенным ключам без полного mapping. В ClickHouse похожую функциональность можно реализовать с помощью типа String, но для этого потребуется обработка в materialized view.                                                                                                                                                                   |
| `nested`                           | [`Nested`](/ru/reference/data-types/nested-data-structures)                                                                                                                                                                                                                             | Столбцы ClickHouse `Nested` предоставляют схожую семантику для сгруппированных вложенных полей, если используется `flatten_nested=0`.                                                                                                                                                                                                                                                                                                                                |
| `join`                             | NA                                                                                                                                                                                                                                                                                      | Прямого аналога отношений parent-child нет. В ClickHouse это и не требуется, так как поддерживаются JOIN между таблицами.                                                                                                                                                                                                                                                                                                                                            |
| `alias`                            | [`Alias`](/ru/reference/statements/create/table#alias) модификатор столбца                                                                                                                                                                                                              | Псевдонимы [поддерживаются](/ru/reference/statements/create/table#alias) через модификатор поля. К таким псевдонимам можно применять функции, например `size String ALIAS formatReadableSize(size_bytes)`                                                                                                                                                                                                                                                            |
| `range` types (`*_range`)          | [`Tuple(start, end)`](/ru/reference/data-types/tuple) или [`Array(T)`](/ru/reference/data-types/array)                                                                                                                                                                                  | В ClickHouse нет встроенного типа range, но числовые диапазоны и диапазоны дат можно представить с помощью структур [`Tuple(start, end)`](/ru/reference/data-types/tuple) или [`Array`](/ru/reference/data-types/array). Для диапазонов IP (`ip_range`) храните значения CIDR как `String` и проверяйте их с помощью функций вроде `isIPAddressInRange()`. В качестве альтернативы можно использовать lookup-словари на основе `ip_trie` для эффективной фильтрации. |
| `aggregate_metric_double`          | [`AggregateFunction(...)`](/ru/reference/data-types/aggregatefunction) и [`SimpleAggregateFunction(...)`](/ru/reference/data-types/simpleaggregatefunction)                                                                                                                             | Используйте состояние агрегатной функции и materialized view для моделирования предварительно агрегированных метрик. Все функции агрегации поддерживают состояние агрегатной функции.                                                                                                                                                                                                                                                                                |
| `histogram`                        | [`Tuple(Array(Float64), Array(UInt64))`](/ru/reference/data-types/tuple)                                                                                                                                                                                                                | Вручную представляйте бакеты и счётчики с помощью массивов или пользовательских схем.                                                                                                                                                                                                                                                                                                                                                                                |
| `annotated-text`                   | [`String`](/ru/reference/data-types/string)                                                                                                                                                                                                                                             | Нет встроенной поддержки поиска с учётом сущностей или аннотаций.                                                                                                                                                                                                                                                                                                                                                                                                    |
| `completion`, `search_as_you_type` | NA                                                                                                                                                                                                                                                                                      | Нет встроенного движка для автодополнения или подсказок. Это можно воспроизвести с помощью `String` и [функций поиска](/ru/reference/functions/regular-functions/string-search-functions).                                                                                                                                                                                                                                                                           |
| `semantic_text`                    | NA                                                                                                                                                                                                                                                                                      | Нет встроенного семантического поиска — сгенерируйте эмбеддинги и используйте векторный поиск.                                                                                                                                                                                                                                                                                                                                                                       |
| `token_count`                      | [`Int32`](/ru/reference/data-types/int-uint)                                                                                                                                                                                                                                            | Используйте на этапе ингестии, чтобы вручную вычислять количество токенов, например с помощью функции `length(tokens())`, в том числе через материализованный столбец                                                                                                                                                                                                                                                                                                |
| `dense_vector`                     | [`Array(Float32)`](/ru/reference/data-types/array)                                                                                                                                                                                                                                      | Используйте массивы для хранения эмбеддингов                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `sparse_vector`                    | [`Map(UInt32, Float32)`](/ru/reference/data-types/map)                                                                                                                                                                                                                                  | Имитируйте разреженные векторы с помощью map. Встроенной поддержки разреженных векторов нет.                                                                                                                                                                                                                                                                                                                                                                         |
| `rank_feature` / `rank_features`   | [`Float32`](/ru/reference/data-types/float), [`Array(Float32)`](/ru/reference/data-types/array)                                                                                                                                                                                         | Встроенного повышения релевантности во время выполнения запроса нет, но его можно реализовать вручную в логике скоринга.                                                                                                                                                                                                                                                                                                                                             |
| `geo_point`                        | [`Tuple(Float64, Float64)`](/ru/reference/data-types/tuple) или [`Point`](/ru/reference/data-types/geo#point)                                                                                                                                                                           | Используйте кортеж вида (широта, долгота). [`Point`](/ru/reference/data-types/geo#point) также доступен как тип ClickHouse.                                                                                                                                                                                                                                                                                                                                          |
| `geo_shape`, `shape`               | [`Ring`](/ru/reference/data-types/geo#ring), [`LineString`](/ru/reference/data-types/geo#linestring), [`MultiLineString`](/ru/reference/data-types/geo#multilinestring), [`Polygon`](/ru/reference/data-types/geo#polygon), [`MultiPolygon`](/ru/reference/data-types/geo#multipolygon) | Встроенная поддержка геометрических объектов и пространственной индексации.                                                                                                                                                                                                                                                                                                                                                                                          |
| `percolator`                       | NA                                                                                                                                                                                                                                                                                      | Концепция индексации запросов отсутствует. Вместо этого используйте стандартный SQL и incremental materialized views.                                                                                                                                                                                                                                                                                                                                                |
| `version`                          | [`String`](/ru/reference/data-types/string)                                                                                                                                                                                                                                             | В ClickHouse нет встроенного типа для версий. Храните версии как строки и при необходимости используйте пользовательские функции (UDF) для семантического сравнения. Если нужны запросы по диапазону, рассмотрите нормализацию к числовым форматам.                                                                                                                                                                                                                  |

<div id="notes">
  ### Примечания
</div>

* **Массивы**: в Elasticsearch все поля изначально поддерживают массивы. В ClickHouse массивы должны быть явно определены (например, `Array(String)`); их преимущество в том, что к конкретным позициям можно обращаться и выполнять по ним запросы, например `an_array[1]`.
* **Мультиполя**: Elasticsearch позволяет индексировать [одно и то же поле несколькими способами](https://www.elastic.co/docs/reference/elasticsearch/mapping-reference/multi-fields#_multi_fields_with_multiple_analyzers) (например, и как `text`, и как `keyword`). В ClickHouse такой подход нужно моделировать с помощью отдельных столбцов или представлений.
* **Типы Map и JSON** - в ClickHouse тип [`Map`](/ru/reference/data-types/map) обычно используется для моделирования динамических структур ключ-значение, таких как `resourceAttributes` и `logAttributes`. Этот тип обеспечивает гибкую ингестию без схемы, позволяя добавлять произвольные ключи во время выполнения, — по смыслу это похоже на объекты JSON в Elasticsearch. Однако важно учитывать следующие ограничения:

  * **Единый тип значений**: столбцы [`Map`](/ru/reference/data-types/map) в ClickHouse должны иметь согласованный тип значений (например, `Map(String, String)`). Значения смешанных типов не поддерживаются без приведения.
  * **Издержки производительности**: доступ к любому ключу в [`Map`](/ru/reference/data-types/map) требует загрузки всей структуры `Map` в память, что может негативно сказываться на производительности.
  * **Нет подстолбцов**: в отличие от JSON, ключи в [`Map`](/ru/reference/data-types/map) не представлены как настоящие подстолбцы, что ограничивает возможности ClickHouse по эффективному индексированию, сжатию и выполнению запросов.

  Из-за этих ограничений ClickStack отказывается от [`Map`](/ru/reference/data-types/map) в пользу улучшенного типа [`JSON`](/ru/reference/data-types/newjson) в ClickHouse. Тип [`JSON`](/ru/reference/data-types/newjson) устраняет многие недостатки `Map`:

  * **Настоящее столбцовое хранение**: каждый путь в JSON хранится как подстолбец, что обеспечивает эффективное сжатие, фильтрацию и векторизованное выполнение запросов.
  * **Поддержка смешанных типов**: разные типы данных (например, целые числа, строки, массивы) могут сосуществовать по одному и тому же пути без приведения или унификации типов.
  * **Масштабируемость файловой системы**: внутренние ограничения на динамические ключи (`max_dynamic_paths`) и типы (`max_dynamic_types`) предотвращают взрывной рост числа файлов столбцов на диске даже для наборов ключей большой мощности.
  * **Плотное хранение**: `null` и отсутствующие значения хранятся разреженно, чтобы избежать лишних накладных расходов.

    Тип [`JSON`](/ru/reference/data-types/newjson) особенно хорошо подходит для рабочих нагрузок обсервабилити, сочетая гибкость ингестии без схемы с производительностью и масштабируемостью встроенных типов ClickHouse, — это делает его идеальной заменой [`Map`](/ru/reference/data-types/map) в динамических полях атрибутов.

    Для получения дополнительных сведений о типе JSON рекомендуем [руководство по JSON](/ru/guides/clickhouse/data-formats/json/intro) и статью [«How we built a new powerful JSON data type for ClickHouse»](https://clickhouse.com/blog/a-new-powerful-json-data-type-for-clickhouse).
