refactor(clickhouse): scope FixedString to ClickHouse dialect, drop from global ColumnType

Removes `ColumnType::FixedString` from the cross-dialect enum. FixedString
state now lives on `Column\ClickHouse` (via `asFixedString()` /
`isFixedString()` / `$fixedStringLength`), and `Schema\ClickHouse::compileColumnType()`
reads that state to emit `FixedString(N)` DDL.

`Table\ClickHouse::fixedString()` now registers a `ColumnType::String` column
and tags it with the FixedString state, so the global enum carries no
ClickHouse-only cases and the other dialects (`MySQL`, `PostgreSQL`,
`SQLite`, `MongoDB`) no longer need `UnsupportedException` match branches —
their `compileColumnType()` methods are byte-identical to `main`.

`Feature\OLAP` remains a marker interface matching the dialect-shape pattern
(OLAP modifiers live on the column/table builder, not on `Schema`, so they
cannot be expressed as a Schema-level method contract); docblock updated to
explain why and to confirm the non-OLAP dialects are unchanged by construction.

Compiled DDL bytes for ClickHouse are unchanged; all 5175 tests pass; lint
and PHPStan max are clean.

Author: lohanidamodar

src/Query/Schema/ClickHouse.php

@@ -33,9 +33,22 @@ protected function compileColumnType(Column $column): string
             throw new UnsupportedException('User-defined types are not supported in ClickHouse.');
         }
 
+        if ($column instanceof Column\ClickHouse && $column->isFixedString()) {
+            $type = 'FixedString(' . $column->fixedStringLength . ')';
+
+            if ($column->isLowCardinality) {
+                $type = 'LowCardinality(' . $type . ')';
+            }
+
+            if ($column->isNullable) {
+                $type = 'Nullable(' . $type . ')';
+            }
+
+            return $type;
+        }
+
         $type = match ($column->type) {
             ColumnType::String, ColumnType::Varchar, ColumnType::Relationship => 'String',
-            ColumnType::FixedString => 'FixedString(' . ($column->length ?? throw new ValidationException('FixedString requires a length.')) . ')',
             ColumnType::Text => 'String',
             ColumnType::MediumText, ColumnType::LongText => 'String',
             ColumnType::Integer => $column->isUnsigned ? 'UInt32' : 'Int32',

src/Query/Schema/Column/ClickHouse.php

@@ -16,9 +16,38 @@ class ClickHouse extends Column
 
     public protected(set) bool $isLowCardinality = false;
 
+    /** Length when the column should be emitted as `FixedString(N)`; null otherwise. */
+    public protected(set) ?int $fixedStringLength = null;
+
     /** @var list<string> Column-level CODEC clauses, e.g. ['Delta(4)', 'LZ4'] */
     public protected(set) array $codecs = [];
 
+    /**
+     * Mark the column as `FixedString(N)`.
+     *
+     * Used by {@see Table\ClickHouse::fixedString()} to attach the
+     * ClickHouse-specific FixedString width to a column whose generic
+     * {@see \Utopia\Query\Schema\ColumnType} is `String`. The compiler reads
+     * this state when emitting DDL.
+     *
+     * @throws ValidationException if $length is less than 1.
+     */
+    public function asFixedString(int $length): static
+    {
+        if ($length < 1) {
+            throw new ValidationException('FixedString length must be at least 1.');
+        }
+
+        $this->fixedStringLength = $length;
+
+        return $this;
+    }
+
+    public function isFixedString(): bool
+    {
+        return $this->fixedStringLength !== null;
+    }
+
     /**
      * @param  list<string>  $columns
      *

src/Query/Schema/ColumnType.php

@@ -5,7 +5,6 @@
 enum ColumnType: string
 {
     case String = 'string';
-    case FixedString = 'fixedstring';
     case Varchar = 'varchar';
     case Text = 'text';
     case MediumText = 'mediumtext';

src/Query/Schema/Feature/OLAP.php

@@ -6,12 +6,20 @@
  * Marker for dialects that expose OLAP-shaped column and table modifiers
  * (`LowCardinality`, `FixedString`, column-level `CODEC`, `SAMPLE BY`).
  *
- * The modifier methods live on the dialect's `Table` / `Column` subclasses
- * (e.g. {@see \Utopia\Query\Schema\Table\ClickHouse},
+ * Unlike sibling `Feature/*` interfaces — which declare schema-level method
+ * signatures because their operations are emitted as standalone statements —
+ * OLAP modifiers are intrinsic to a dialect's column/table builder shape and
+ * cannot be expressed as `Schema` methods. They live on the dialect's
+ * `Table` / `Column` subclasses (e.g. {@see \Utopia\Query\Schema\Table\ClickHouse},
  * {@see \Utopia\Query\Schema\Column\ClickHouse}) and the corresponding
  * `Forwarder` trait, so callers can only chain them when the underlying
  * dialect supports them — the methods aren't reachable from non-OLAP
  * dialects at the type level.
+ *
+ * Non-OLAP dialects therefore have nothing to handle or throw from: the
+ * cross-dialect `ColumnType` enum carries no OLAP-only cases, and the
+ * `compileColumnType()` implementations on `MySQL` / `PostgreSQL` / `SQLite` /
+ * `MongoDB` are byte-identical to their pre-OLAP form.
  */
 interface OLAP
 {

src/Query/Schema/MongoDB.php

@@ -45,7 +45,6 @@ protected function compileColumnType(Column $column): string
             ColumnType::Linestring, ColumnType::Polygon => 'object',
             ColumnType::Uuid7 => 'string',
             ColumnType::Vector => 'array',
-            ColumnType::FixedString => throw new UnsupportedException('FixedString type is not supported in MongoDB.'),
         };
     }
 

src/Query/Schema/MySQL.php

@@ -73,7 +73,6 @@ protected function compileColumnType(Column $column): string
             ColumnType::Polygon => 'POLYGON' . ($column->srid !== null ? ' SRID ' . $column->srid : ''),
             ColumnType::Uuid7 => 'VARCHAR(36)',
             ColumnType::Vector => throw new UnsupportedException('Vector type is not supported in MySQL.'),
-            ColumnType::FixedString => throw new UnsupportedException('FixedString type is not supported in MySQL.'),
         };
     }
 

src/Query/Schema/PostgreSQL.php

@@ -79,7 +79,6 @@ protected function compileColumnType(Column $column): string
             ColumnType::Serial => 'SERIAL',
             ColumnType::BigSerial => 'BIGSERIAL',
             ColumnType::SmallSerial => 'SMALLSERIAL',
-            ColumnType::FixedString => throw new UnsupportedException('FixedString type is not supported in PostgreSQL.'),
         };
     }
 

src/Query/Schema/SQLite.php

@@ -36,7 +36,6 @@ protected function compileColumnType(Column $column): string
             ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon => 'TEXT',
             ColumnType::Uuid7 => 'VARCHAR(36)',
             ColumnType::Vector => throw new UnsupportedException('Vector type is not supported in SQLite.'),
-            ColumnType::FixedString => throw new UnsupportedException('FixedString type is not supported in SQLite.'),
         };
     }
 

src/Query/Schema/Table/ClickHouse.php

@@ -42,15 +42,17 @@ public function vector(string $name, int $dimensions): Column\ClickHouse
      * digests, and similar values that benefit from ClickHouse's columnar
      * storage of fixed-width data.
      *
+     * The column is registered with the generic `ColumnType::String` type and
+     * tagged with FixedString state on {@see Column\ClickHouse}; the compiler
+     * reads that state when emitting DDL, so the global `ColumnType` enum
+     * stays free of ClickHouse-only cases.
+     *
      * @throws ValidationException if $length is less than 1.
      */
     public function fixedString(string $name, int $length): Column\ClickHouse
     {
-        if ($length < 1) {
-            throw new ValidationException('FixedString length must be at least 1.');
-        }
-
-        $col = $this->newColumn($name, ColumnType::FixedString, $length);
+        $col = $this->newColumn($name, ColumnType::String, $length);
+        $col->asFixedString($length);
         $this->columns[] = $col;
 
         return $col;