Add UUID2 data type with correct sorting - #110084

…IDToNum

Accept `UUID2` arguments in `hex`/`bin`, `reinterpretAs*`, `UUIDv7ToDateTime`
and `UUIDToNum`. For the layout-dependent functions (`hex`/`bin`,
`UUIDv7ToDateTime`, `UUIDToNum`) the big-endian `UUID2` value is converted to
the logical `UUID` layout with `UUIDHelpers::swapHalves` before reusing the
existing UUID code path, so results match `UUID` for the same textual value.

Hashing (`sipHash*`, `cityHash*`, `uniq*`), `GROUP BY`, `min`/`max`/`any` and
the `String`/`CSV`/`TSV`/`JSON`/`RowBinary`/`Native`/`Arrow` formats already
work for `UUID2`. Bitwise aggregates (`groupBitOr` etc.) are unsupported for
`UUID2` as they are for `UUID`.

Related: #110066

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Add UUID2 support to the data formats and storage features that special-case
UUID. The uniform rule: UUID2 shares ColumnUUID with UUID but stores the value
with the two 64-bit halves swapped, so at the column boundary the value is run
through UUIDHelpers::swapHalves and the existing UUID code path is reused;
format-to-ClickHouse type inference keeps returning UUID.

- Formats: Parquet (native writer), Arrow (arrow.uuid extension), Avro, BSON,
  MsgPack, Protobuf, CapnProto (input and output), and JSONExtract.
- Storage/functions: generateRandom, bloom_filter skip index, empty/notEmpty.

The native Parquet writer switch keys on the column's data type (which is UUID
for both UUID and UUID2), so UUID2 is detected via the concrete type in
ColumnChunkWriteState::type; the Parquet reader reconciles the inferred UUID to
a UUID2 target through the existing UUID->UUID2 cast.

Extends the 04402_uuid2_data_type test with function, format-adjacent and
storage cases.

Related: #110066

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

…ent the `UUID2` binary encoding

After merging master, the first release that will contain the new setting is
26.7, so its entry in `SettingsChangesHistory.cpp` belongs to the "26.7"
block instead of the already-released "26.6".

Also document the `UUID2` type in the Native format specification (fixed-width
table, the `UUID` wire-encoding section, and the type diagram): the wire
encoding is the 16 canonical big-endian bytes with no half-swapping, and the
binary type encoding tag is `0x38` (`0x37` was taken by `QBitWithStride`
in master).

…buted DDL

`ALTER TABLE ... ADD/MODIFY COLUMN x UUID` resolved the concrete type
(`UUID` vs `UUID2`, per `uuid_type_version`) on whichever node executed the command,
because `executeToTable` forwards the query to `ON CLUSTER` hosts and enqueues it into
a `Replicated` database DDL log *before* `parseAlterCommandSegments` runs. Unlike
`CREATE`, which bakes the concrete column types into the query AST on the initiator, a
bare `UUID` could therefore materialize as `UUID` on one node and `UUID2` on another when
nodes disagree on `uuid_type_version` (mixed-version rollouts, older
`distributed_ddl_entry_format_version`).

Mirror the `CREATE` flow: `materializeUUIDTypeVersion` resolves a bare `UUID` in
`ADD/MODIFY COLUMN` on the initiator before the query is forwarded, and
`parseAlterCommandSegments` keeps internal DDL (`isDDLOrOnClusterInternal`) verbatim
instead of re-resolving with the local node's setting, so every node agrees on the
initiator's decision.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

The Arrow library is not compiled into the fast-test build, so `FORMAT Arrow`
fails there and the query produces empty output. That made both the `UUID2` and
`UUID` branches emit nothing, so the byte-identity check passed trivially while
the round-trip lines were missing, and the test failed against its reference.

All other Arrow tests are already tagged `no-fasttest` for the same reason.

Verified locally with an Arrow-enabled build: the byte-identity check and the
round-trip both produce the exact reference output.

CI report: #110084

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

`uuid_type_version = 2` was ignored for `CREATE ... ON CLUSTER` when
`distributed_ddl_entry_format_version < NORMALIZE_CREATE_ON_INITIATOR_VERSION`.
That legacy path enqueues the query verbatim in `execute` before
`createTable` normalizes it on the initiator, and each worker then treats
the forwarded DDL as already-normalized internal DDL (forcing
`uuid_type_version = 1`), so a bare `UUID` column was created as the
historical `UUID` type instead of `UUID2`.

Materialize the setting into the column-declaration ASTs on the initiator
before the legacy enqueue, mirroring how `ALTER` and the modern `CREATE`
path bake in the concrete stored type.

Also extends `04402_uuid2_data_type` with the legacy `ON CLUSTER` case and
the Field-level `UUID`/`UUID2` coercion (`IN`-set) case.

Addresses review feedback on #110084

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

…SSL)

The Fast test build is compiled without SSL, so `halfMD5` (which is
`#if USE_SSL`-gated) does not exist there. The hashing-parity block of
`04402_uuid2_data_type` called `halfMD5`, so the whole test failed with
`Code: 46. Function with name 'halfMD5' does not exist. (UNKNOWN_FUNCTION)`.

`halfMD5` is a `FunctionAnyHash`, exactly like `sipHash64`, `sipHash128`,
`cityHash64`, `xxHash64`, and `farmHash64`, so it exercises the same
`executeUUID2` code path as those functions. Dropping it keeps the test
running in the Fast test build while still covering `UUID2` hashing parity
via five representative functions, instead of tagging the whole test
`no-fasttest`.

CI report: https://s3.amazonaws.com/clickhouse-test-reports/json.html?PR=110084&sha=883b4ea2562dc0114f97dffc9e809f22d33d47a3&name_0=PR&name_1=Fast%20test

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

`UUID2` can now be used as a TimeSeries `id` type, and `uuid_type_version = 2`
consistently materializes a bare `UUID` id to `UUID2`.

Previously `SET uuid_type_version = 2` broke `TimeSeries` DDL: the inner
samples/tags columns were materialized to `UUID2` (by
`InterpreterCreateQuery::getColumnsDescription`) while the resolved id type
stayed `UUID`, so the consistency check between the inner tables failed with
`Column id in the Samples table has type UUID2, but expected UUID`.

Changes:
- `normalizeTimeSeriesDefinition` now bakes the `uuid_type_version` setting
  into the declared inner-column types before resolving them, and applies the
  same materialization to the built-in default id type. This keeps the samples
  and tags inner tables consistent and makes any later normalization pass read
  the already-materialized types. It is gated to a primary user CREATE
  (mirroring the gate in `getColumnsDescription`), so ATTACH, restore, and
  already-normalized DDL-worker queries are unaffected.
- `normalizeTimeSeriesDefinition` id-type validation and
  `checkArgumentTypeForID` (used by `timeSeriesStoreTags`, `timeSeriesIdToTags`,
  `timeSeriesIdToGroup`) now accept `UUID2`.
- `TimeSeriesIDGenerator::getDefault` generates a default id expression for a
  `UUID2` id column.

Adds test `04517_uuid2_time_series_id` and documents `UUID2` as an allowed id
type in the TimeSeries docs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Follow-ups to the master merge, all mechanical:

- `SerializationUUID2::deserializeBinaryBulk` still had the `rows_offset`
  parameter that master dropped in "Remove rows_offset from the
  deserialization API", so it no longer overrode the virtual method.
- The `LowCardinality` branch of `getFieldFromColumnForASTLiteralImpl` did
  not pass the `datetime64_as_numbers` argument that master added.
- `tryBuildAdditionalFilterAST` now folds two independent fixes: master
  serializes decimal-backed constants exactly, and this branch serializes
  a `UUID2` constant as canonical text (its raw `Field` is formatted with
  `UUID` semantics and would be reparsed as a different value on the
  shard). The `UUID2` path is selected by a new file-local
  `typeMayContainUUID2`, so the raw-`Field` literal is kept for everything
  else, including `DateTime`.

The description promised that the setting covers "every expression a
`CREATE` or `ALTER` persists", but a type name carried inside a string is
only recognized when that string is a literal or is built from the string
functions `foldConstantStringExpression` mirrors without an execution
context (`concat`, `replace`, `replaceOne`, `replaceAll`, `upper`,
`ucase`, `lower`, `lcase`). `CAST(x, trim(' UUID '))` stays historical
`UUID`, as `05038_uuid2_constant_string_folding` already asserts.

Document that limitation instead of implying a broader guarantee, and
regenerate the reference documentation.

The entry was recorded under `26.8`, but the development version is now
`26.9`, so the `settings_changes_history` style check failed.

`uuid_type_version = 2` materializes the schema string of a table function in a
persisted definition. `substituteBareUUIDInPlace` used to call
`substituteBareUUIDInTableFunction` for every `ASTFunction`, recognizing the carrier
by name alone. But `format` is both the table function
`format(format_name, structure, data)` and the regular scalar string-formatting
function `format(pattern, ...)`, so a persisted
`SELECT format('{} {}', 'id UUID', 'x')` had its plain data argument rewritten to
`id UUID2`, silently changing the stored query.

The rewrite is now driven by the position of the call: the `table_function` of an
`ASTTableExpression`, the `as_table_function` of an `ASTCreateQuery`, and the whole
argument subtree of such a call (so that a table function nested in a wrapper, for
example `loop(url(...))`, is still reached).

Addresses the review finding on `src/Parsers/ASTDataType.cpp`.

A dictionary-encoded (`LowCardinality`) column written by the Apache Arrow library
writer cannot carry the `arrow.uuid` extension keys, because the registered extension
type rejects dictionary storage at read time. `CHColumnToArrowColumn` therefore marks
such a column with the ClickHouse-specific discriminator (`ClickHouse:type`) alone.
The native Arrow IPC reader still required `arrow.uuid` before honoring that key, so
`output_format_arrow_use_native_writer = 0` plus
`output_format_arrow_low_cardinality_as_dictionary = 1` plus
`input_format_arrow_use_native_reader = 1` read the column back as
`LowCardinality(FixedString(16))` instead of `LowCardinality(UUID2)` (and likewise
lost a plain `UUID`).

`isUUIDField` now treats the discriminator as authoritative on the fixed-size-binary
path, which also makes `isUUID2Field` work for that writer/reader combination.

Addresses the review finding on
`src/Processors/Formats/Impl/ArrowIPC/SchemaConverter.cpp`.

…olumn

`ReplacingConstantExpressionsMatcher` re-encodes a folded `UUID`/`UUID2` constant as
text, because an untyped `ASTLiteral` cannot tell the two apart. The text form is
itself ambiguous against a `Variant`, `Dynamic` or `JSON` column: the `DataTypeVariant`
branch of `convertFieldToType` accepts a string into the `String` alternative, so
`WHERE v = toUUID2('...')` on a `Variant(String, UUID2)` sharding key was analyzed as
a `String` and `sipHash64(v)` could select the wrong shard, pruning away the shard
that owns the matching row.

Neither representation is unambiguous there, so such tables are no longer pruned at
all: the constant is left unfolded and `evaluateExpressionOverConstantCondition`
returns no definite answer, which means every shard is queried. A plain `UUID2`
column is unambiguous and keeps being pruned.

Addresses the review finding on `src/Storages/StorageDistributed.cpp`.

The `Docs examples` check runs every documented snippet and compares its output. The
`toUUID2`, `dictGetUUID2` and `dictGetUUID2OrDefault` examples carried a hand-written
response with a truncated (`⋯`) header and, for `toUUID2`, right-aligned column
padding, neither of which the runner produces. The documented responses now match the
actual output, and the generated pages were regenerated accordingly.

… helper

The `clickhouse_spelling` style check rejects the `clickHouse` case variant,
so rename `clickHouseUUIDTypeMetadata` to `getClickHouseUUIDTypeMetadata`.

Master now wraps the default `TimeSeries` `id` component in `LowCardinality`
and lets `TimeSeriesIDGenerator` choose an expression for a `LowCardinality`
identifier type. The `uuid_type_version = 2` default therefore becomes
`Tuple(UInt64, LowCardinality(UUID2))`; update the two references that pin
the default identifier type, and mirror the merged documentation text in the
generated `time-series.mdx`.

`04652_enum_constant_vs_string_column` documented three cells as known
limitations and named this pull request as the change that adds the element
type hint propagation through the `Array`/`Tuple`/`Map` recursion of
`convertFieldToType` and through `createColumnFromConstantArray` in the bloom
filter condition. With the hint in place an `Enum` element inside a container
is converted to the name, so replace those cells with assertions of the fixed
behavior: `x[1]` yields `7`, and `hasAny`/`hasAll` no longer over prune.

# Conflicts:
#	src/Storages/TimeSeries/normalizeTimeSeriesDefinition.cpp