@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.0

package/dist/clickhouse/overlays/projections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projections.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/projections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC7B,oDAAoD;IACpD,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAGrD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAGhD,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAAuD,CAAC"}

package/dist/clickhouse/overlays/skip-indexes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Skip index parameters: the overlay half.
+ *
+ * `system.data_skipping_index_types` names each type and gives a syntax line,
+ * from which the generator reads parameter names and optionality. This adds
+ * their kinds and ranges. `GRANULARITY` is fixed grammar the parser owns.
+ */
+import type { ArgumentOverlay } from "./kinds.js";
+export declare const SKIP_INDEX_PARAMETERS: Record<string, Record<string, ArgumentOverlay>>;
+//# sourceMappingURL=skip-indexes.d.ts.map

package/dist/clickhouse/overlays/skip-indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-indexes.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/skip-indexes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAM/C,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CA6BjF,CAAC"}

package/dist/clickhouse/overlays/ttl.d.ts

@@ -0,0 +1,35 @@
+/**
+ * TTL clauses: the whole grammar is overlay.
+ *
+ * No system table describes TTL. A table TTL is a list of rules, each an
+ * expression evaluating to a `Date` or `DateTime` and an action; a column TTL
+ * is a single expression with no action, after which the column resets to its
+ * default. Which engines accept TTL at all is generated
+ * (`capabilities.ttl` from `system.table_engines.supports_ttl`).
+ *
+ *     TTL expr [DELETE | RECOMPRESS codec | TO DISK 'd' | TO VOLUME 'v'] [WHERE cond]
+ *         [, expr GROUP BY key_columns SET col = agg(col), ...]
+ */
+import type { ArgumentOverlay } from "./kinds.js";
+export interface TtlAction {
+    /** The keywords that open the action, as written. */
+    keywords: string;
+    /** What follows the keywords. */
+    argument?: ArgumentOverlay;
+    /** Whether a trailing `WHERE cond` may filter the rows it applies to. */
+    where: boolean;
+    /**
+     * What the server's `SHOW CREATE` prints when the action is written as the
+     * default. A declared `TTL ts + INTERVAL 1 DAY DELETE` reads back with
+     * `DELETE` dropped, so a comparison must treat the two as one.
+     */
+    impliedWhenOmitted?: boolean;
+}
+export declare const TTL_ACTIONS: readonly TtlAction[];
+/** A column TTL takes an expression and nothing else. */
+export declare const COLUMN_TTL_ACTIONS: readonly TtlAction[];
+/** The types a TTL expression must evaluate to. */
+export declare const TTL_RESULT_TYPES: readonly string[];
+/** MergeTree settings that change how TTL runs, for lint and hover to point at. */
+export declare const TTL_SETTINGS: readonly string[];
+//# sourceMappingURL=ttl.d.ts.map

package/dist/clickhouse/overlays/ttl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttl.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/ttl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,WAAW,SAAS;IACxB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,yEAAyE;IACzE,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAU3C,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,EAAE,SAAS,SAAS,EAAO,CAAC;AAE3D,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAAiD,CAAC;AAEhG,mFAAmF;AACnF,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAKzC,CAAC"}

package/dist/clickhouse/overlays/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Column type parameters: the overlay half.
+ *
+ * `system.data_type_families` lists the families and their aliases. The
+ * parameter grammar (`Decimal(P, S)`, `DateTime64(precision[, tz])`,
+ * `Enum8('a' = 1)`) is in no system table. A family missing here takes no
+ * parameters; generation fails when a key here is not a family at the pin.
+ */
+import type { ArgumentKind } from "./kinds.js";
+export interface TypeParameter {
+    name: string;
+    kind: ArgumentKind | "enum-member" | "named-type";
+    optional?: boolean;
+    /** The parameter repeats (`Tuple(T, ...)`). */
+    repeated?: boolean;
+    range?: readonly [number, number];
+}
+export declare const TYPE_PARAMETERS: Record<string, readonly TypeParameter[]>;
+/** Families that wrap another type and pass its nullability and sort-key rules through. */
+export declare const WRAPPER_TYPES: readonly string[];
+//# sourceMappingURL=types.d.ts.map

package/dist/clickhouse/overlays/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,GAAG,aAAa,GAAG,YAAY,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAUD,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CA0BpE,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAAuB,CAAC"}

package/dist/clickhouse/ownership.d.ts

@@ -0,0 +1,71 @@
+/**
+ * chant's ownership marker on ClickHouse objects (#3208): a trailer on the
+ * object's own `COMMENT`.
+ *
+ * ClickHouse objects carry no tags or labels. The channels considered:
+ *
+ * - The object `COMMENT`. Every object kind has one (a table of any engine, a
+ *   view, a materialized view, a database), it is set in the `CREATE` itself
+ *   so an object is never created unmarked, `MODIFY COMMENT` restamps it, and
+ *   `system.tables` / `system.databases` return it with the catalog read
+ *   observation already makes. The #3046 candidate.
+ * - Table `SETTINGS`: a MergeTree table refuses a setting it does not know.
+ * - A registry table on the server naming the objects chant created: a record
+ *   apart from the object, which is the state file chant does not keep, and
+ *   one that goes on claiming a table someone dropped and created again.
+ *
+ * So the comment, and the question is the user's own comment, which is a
+ * declared property (`COMMENT 'Raw events'`, classified by SQLCH203). The
+ * marker never replaces it: it is appended as a bracketed trailer,
+ *
+ *     COMMENT 'Raw events [chant managed-by=chant stack=shop env=prod]'
+ *
+ * and taken off again wherever chant reads a definition (`readLiveSchema`
+ * strips it from `SHOW CREATE`), so planning, the deep diff and import compare
+ * and write the declared comment alone. Someone who edits the comment by hand
+ * and drops the trailer makes the object read as foreign, which is the safe
+ * direction: it is never pruned, and the next apply of its declaration
+ * stamps it again.
+ *
+ * Values are percent-encoded outside `[A-Za-z0-9._-]`, so the trailer never
+ * holds a quote, a backslash, a space or a bracket of its own.
+ *
+ * The trailer itself is the shared core's (`../core/ownership.ts`), the same in
+ * every dialect. What is ClickHouse's here: the channel the plugin declares,
+ * taking the trailer off a printed `COMMENT '...'` clause, and the trailer keys
+ * of the rebuild migration's working objects.
+ */
+import type { ChannelKeys, OwnershipChannel } from "@intentius/chant/ownership";
+export { carriesMarker, isChantManaged, markerTrailer, readMarker, readTrailerPairs, RECEIPTS_TRAILER_KEY, stampedComment, stripMarker, type CommentMarker, } from "../core/ownership.js";
+/** The keys inside the trailer. */
+export declare const CLICKHOUSE_COMMENT_OWNERSHIP_KEYS: ChannelKeys;
+/**
+ * Where the marker is read back (#1348): `describeResources` and
+ * `exportResources` read the comment from `system.tables` and
+ * `system.databases`. The deep read takes it off with the rest of `SHOW CREATE`
+ * and reports no verdict.
+ */
+export declare const SQL_OWNERSHIP_CHANNEL: OwnershipChannel;
+/**
+ * The trailer key naming the table a rebuild migration object belongs to
+ * (`./rebuild/`). An object carrying it is the rebuild's own working object,
+ * not a declaration: a new table being filled, the dual-write view, an old
+ * table being retained. Reading a schema leaves those out
+ * (`./live/catalog.ts`), so a plan, an import or a prune never sees them.
+ */
+export declare const REBUILD_TRAILER_KEY = "rebuild";
+/** Whether a comment marks a rebuild migration's working object. */
+export declare function isRebuildObject(comment: string | undefined): boolean;
+/**
+ * Whether a comment marks one of chant's own working objects: a rebuild's
+ * new, dual-write or retained table, or the receipts database and table.
+ * Schema reads leave them out.
+ */
+export declare function isChantWorkingObject(comment: string | undefined): boolean;
+/**
+ * A `SHOW CREATE` statement with the trailer taken off its object comment, so
+ * the statement reads as the declaration it came from. A comment that was the
+ * trailer alone loses its whole `COMMENT` clause.
+ */
+export declare function stripMarkerFromStatement(statement: string): string;
+//# sourceMappingURL=ownership.d.ts.map

package/dist/clickhouse/ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.d.ts","sourceRoot":"","sources":["../../src/clickhouse/ownership.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGhF,OAAO,EACL,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,WAAW,EACX,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAE3B,mCAAmC;AACnC,eAAO,MAAM,iCAAiC,EAAE,WAAoC,CAAC;AAErF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,gBAGnC,CAAC;AAOF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAE7C,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEpE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEzE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/clickhouse/parser.d.ts

@@ -0,0 +1,130 @@
+/**
+ * A hand-written recursive-descent parser for the ClickHouse statements the
+ * dialect declares: `CREATE DATABASE`, `CREATE TABLE`, `CREATE VIEW` and
+ * `CREATE MATERIALIZED VIEW` (chant #3196).
+ *
+ * Statement structure is parsed; expressions are not. An expression (a
+ * default, a codec, a sort key, a TTL, a view's SELECT) is kept as a span of
+ * tokens: its source text, verbatim, and the interpolations inside it. That is
+ * what entities, references, dependency order and lineage need. Comparing
+ * `INTERVAL 1 DAY` with the server's `toIntervalDay(1)` is normalization's job,
+ * which asks the server.
+ *
+ * An interpolation (`ref` token) is accepted wherever a name, a type or an
+ * expression goes. At build time the tag has already spliced plain strings into
+ * the token list as SQL text, so a `ref` left here is an entity or a column
+ * reference. Lint parses the source with every interpolation still a `ref`,
+ * because it cannot know the values; accepting them keeps it from reporting an
+ * error the build would not have.
+ */
+import type { Token } from "./tokens.js";
+import { type Span } from "../core/cursor.js";
+export type { Span } from "../core/cursor.js";
+export interface ColumnNode {
+    /** The name as written, unquoted. Empty when the name is an interpolation. */
+    name: string;
+    nameSpan: Span;
+    type?: Span;
+    /** `NULL` / `NOT NULL` after the type. */
+    nullable?: boolean;
+    default?: {
+        kind: "DEFAULT" | "MATERIALIZED" | "ALIAS" | "EPHEMERAL";
+        expr?: Span;
+    };
+    comment?: Span;
+    codec?: Span;
+    ttl?: Span;
+    statistics?: Span;
+    settings?: Span;
+    /** `PRIMARY KEY` written on the column. */
+    primaryKey?: boolean;
+}
+export interface IndexNode {
+    name: string;
+    expr: Span;
+    type: Span;
+    granularity?: Span;
+}
+export interface ProjectionNode {
+    name: string;
+    body: Span;
+}
+export interface ConstraintNode {
+    name: string;
+    kind: "CHECK" | "ASSUME";
+    expr: Span;
+}
+export interface StorageNode {
+    engine?: {
+        name: string;
+        nameSpan: Span;
+        args?: Span[];
+        span: Span;
+    };
+    orderBy?: Span;
+    primaryKey?: Span;
+    partitionBy?: Span;
+    sampleBy?: Span;
+    ttl?: Span;
+    settings?: Array<{
+        key: string;
+        value: Span;
+    }>;
+    /** The whole `SETTINGS ...` clause, keyword included. */
+    settingsClause?: Span;
+}
+export interface DatabaseNode {
+    statement: "database";
+    ifNotExists: boolean;
+    name: Span;
+    onCluster?: Span;
+    engine?: {
+        name: string;
+        nameSpan: Span;
+        args?: Span[];
+        span: Span;
+    };
+    settings?: Array<{
+        key: string;
+        value: Span;
+    }>;
+    comment?: Span;
+}
+export interface TableNode extends StorageNode {
+    statement: "table";
+    orReplace: boolean;
+    ifNotExists: boolean;
+    name: Span;
+    onCluster?: Span;
+    columns: ColumnNode[];
+    indexes: IndexNode[];
+    projections: ProjectionNode[];
+    constraints: ConstraintNode[];
+    comment?: Span;
+}
+export interface ViewNode extends StorageNode {
+    statement: "view";
+    materialized: boolean;
+    orReplace: boolean;
+    ifNotExists: boolean;
+    name: Span;
+    onCluster?: Span;
+    refresh?: Span;
+    append: boolean;
+    to?: Span;
+    columns: ColumnNode[];
+    /** The parenthesised column list, parentheses included, when there is one. */
+    columnsSpan?: Span;
+    populate: boolean;
+    empty: boolean;
+    /** `DEFINER = ...` and `SQL SECURITY ...`, as written. */
+    security?: Span;
+    select: Span;
+    comment?: Span;
+}
+export type CreateNode = DatabaseNode | TableNode | ViewNode;
+/** A name with its `` ` `` or `"` quotes taken off. */
+export declare const unquote: (text: string) => string;
+/** Parse one CREATE statement. Throws {@link SqlSyntaxError} located in the template. */
+export declare function parseCreate(tokens: Token[]): CreateNode;
+//# sourceMappingURL=parser.d.ts.map

package/dist/clickhouse/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/clickhouse/parser.ts"],"names":[],"mappings":"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"}

package/dist/clickhouse/plan/commands.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `chant sql diff` and `chant sql plan`: the classified change between two
+ * builds, or between a build and a live server. A Postgres build (its output
+ * says `"dialect": "postgres"`) or a Postgres binding goes to
+ * `../../postgres/plan/commands.ts`.
+ *
+ *     chant sql diff <before.json> <after.json> [--json]
+ *     chant sql plan <env> <build.json> [--json]
+ *
+ * `diff` is offline: it compares two `chant build` outputs, say a pull
+ * request's base and head, and needs no server. `plan` compares a build with
+ * the server `sql.profiles.<env>` binds and asks that server's formatter about
+ * expressions the rules leave different. Both exit 2 when a change needs a
+ * rebuild, which a plan refuses to make in place, and 0 otherwise; for each
+ * refused table they name the `ClickHouseRebuildOp` to run instead
+ * (`rebuildOps` in `--json`, `./rebuild-handoff.ts`).
+ */
+import type { CommandGroup, CommandGroupContext } from "@intentius/chant/cli/command-group";
+import { type SchemaDiff } from "./diff.js";
+import { bindClickHouse } from "../live/bind.js";
+export declare function runDiff(ctx: CommandGroupContext): Promise<number>;
+/** The declared objects against the server, keys and labels by `database.name`. */
+export declare function planAgainstServer(environment: string, buildFile: string, options?: Parameters<typeof bindClickHouse>[0]): Promise<SchemaDiff>;
+export declare function runPlan(ctx: CommandGroupContext): Promise<number>;
+export declare const sqlCommands: CommandGroup;
+//# sourceMappingURL=commands.d.ts.map

package/dist/clickhouse/plan/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC5F,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAC;AAItD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAsB9C,wBAAsB,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAcvE;AAED,mFAAmF;AACnF,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAevJ;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAYvE;AAED,eAAO,MAAM,WAAW,EAAE,YAOzB,CAAC"}

package/dist/clickhouse/plan/deep.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `observeResourcesDeep()` for the ClickHouse dialect: each declared object's
+ * live definition as a property tree in the declaration's own shape, so
+ * `chant lifecycle diff --live` and `plan` report property drift with no false
+ * drift.
+ *
+ * The reader parses the server's `SHOW CREATE` with the same tag the
+ * declaration used, which gives the same props shape. A field whose canonical
+ * form (`./normalize.ts`) equals the declaration's is written with the
+ * declaration's own value, so `INTERVAL 180 DAY` and `toIntervalDay(180)` do
+ * not read as drift; a field that differs keeps the server's value.
+ * `deepNormalizationHooks` prunes what is not a property of the object (the
+ * DDL text, the template source, lineage, a view's reads and `TO` target).
+ * `chant sql plan` covers the target, and classifies every change.
+ */
+import { type DeepObservationResult, type DeepNormalizationHooks } from "@intentius/chant/deep-observation";
+import { type BindOptions } from "../live/bind.js";
+import { type CanonicalObject } from "./normalize.js";
+type Props = Record<string, unknown>;
+export declare const sqlDeepNormalizationHooks: DeepNormalizationHooks;
+/** The live props, with each field the declaration means the same as written the declaration's way. */
+export declare function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalObject, l: CanonicalObject): Props;
+export declare function observeResourcesDeep(options: {
+    environment: string;
+    entityNames: string[];
+    entities: Map<string, {
+        entityType: string;
+        props: Record<string, unknown>;
+    }>;
+} & Omit<BindOptions, "environment">): Promise<DeepObservationResult>;
+export {};
+//# sourceMappingURL=deep.d.ts.map

package/dist/clickhouse/plan/deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/deep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAmB,KAAK,qBAAqB,EAAgC,KAAK,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAE3J,OAAO,EAA6C,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3F,OAAO,EAAyC,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAE1F,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAKrC,eAAO,MAAM,yBAAyB,EAAE,sBAEvC,CAAC;AAaF,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,KAAK,CA+BhH;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/E,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAwChC"}

package/dist/clickhouse/plan/diff.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The diff between two ClickHouse schemas, each change classified.
+ *
+ * Identity (#3047 question 3):
+ *
+ * - An object is identified by its export name between two revisions of the
+ *   declarations, so a changed name in the SQL under the same export is a
+ *   rename, not a drop and a create. Against a live server, which has no
+ *   export names, it is identified by `database.name`, and a declaration
+ *   carrying `-- previously: <old name>` before its CREATE is matched to the
+ *   object of that name.
+ * - A column is identified by its name: the SQL form has no column key apart
+ *   from the name. A column renamed in place says so with
+ *   `-- previously: <old name>` on its line; without the hint a renamed
+ *   column reads as a drop and an add, and the diff points that out when the
+ *   two look alike.
+ */
+import { type ChangeClass, type ClassifierRuleId } from "./rules.js";
+import type { CanonicalObject } from "./normalize.js";
+import type { RebuildOpSuggestion } from "./rebuild-handoff.js";
+import { type ChangeSet, type ClassifiedChange } from "../../core/classifier.js";
+import { type Keyed } from "../../core/diff.js";
+export type SchemaObject = Keyed<CanonicalObject>;
+export type Change = ClassifiedChange<ClassifierRuleId, ChangeClass>;
+export interface SchemaDiff extends ChangeSet<Change> {
+    /** The rebuilds a plan must refuse to make in place. */
+    rebuilds: Change[];
+    /** For each table refused as a rebuild, the rebuild migration Op to run instead (`./rebuild-handoff.ts`). */
+    rebuildOps?: RebuildOpSuggestion[];
+}
+/**
+ * Diff two schemas. `before` and `after` are matched by key; an `after`
+ * object whose key is new but whose `previously` names a `before` object
+ * with no `after` counterpart is that object, renamed.
+ */
+export declare function diffSchemas(before: readonly SchemaObject[], after: readonly SchemaObject[]): SchemaDiff;
+//# sourceMappingURL=diff.d.ts.map

package/dist/clickhouse/plan/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAoB,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,EAAmC,KAAK,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE9E,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,eAAe,CAAC,CAAC;AAElD,MAAM,MAAM,MAAM,GAAG,gBAAgB,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;AAErE,MAAM,WAAW,UAAW,SAAQ,SAAS,CAAC,MAAM,CAAC;IACnD,wDAAwD;IACxD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,6GAA6G;IAC7G,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACpC;AAkJD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,EAAE,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,UAAU,CAiBvG"}

package/dist/clickhouse/plan/disruption.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `classifyDisruption()`: what applying a pending update costs, from the
+ * paths `chant lifecycle plan` reports changed, mapped onto the classifier's
+ * rules (`./rules.ts`). A metadata-only change is `in-place`, a background
+ * rewrite `rolling`, a rebuild `replace`.
+ *
+ * A path alone cannot always say which rule applies: a column type change is a
+ * rewrite, or a rebuild when the column is in a key. Those answer `unknown`,
+ * naming both rules; `chant sql plan` resolves them with the whole definition
+ * in hand.
+ */
+import type { DisruptionQuery, DisruptionVerdict } from "@intentius/chant/lifecycle/disruption";
+export declare function classifyDisruption(options: {
+    environment: string;
+    changes: DisruptionQuery[];
+}): Record<string, DisruptionVerdict>;
+//# sourceMappingURL=disruption.d.ts.map

package/dist/clickhouse/plan/disruption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disruption.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/disruption.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAqChG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,eAAe,EAAE,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAWlI"}

package/dist/clickhouse/plan/normalize.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Normalization: a ClickHouse object's definition in a form two definitions
+ * can be compared in, so a declaration and what the server reports for it are
+ * equal when they mean the same thing (#3047 question 4).
+ *
+ * The server rewrites what it is given. `SHOW CREATE` quotes every column,
+ * qualifies names with their database, writes `INTERVAL 180 DAY` as
+ * `toIntervalDay(180)`, fills in codec levels (`ZSTD(1)`, `Delta(4)`), drops a
+ * TTL's trailing `DELETE`, prints `index_granularity = 8192`, writes `int` as
+ * `Int32` and infers a view's column list. Each of those is undone here, on
+ * both sides, by rule:
+ *
+ * - expressions compare as their token sequences, whitespace, comments and
+ *   identifier quoting left out, keywords in upper case, `INTERVAL n UNIT`
+ *   rewritten to `toIntervalUnit(n)`, the object's own database dropped from a
+ *   qualified name;
+ * - a type's family is its canonical name (`int` is `Int32`), from the pinned
+ *   catalog's alias table;
+ * - a codec's default level goes (`ZSTD(1)` is `ZSTD`, `Delta(4)` is `Delta`);
+ * - a TTL rule's trailing `DELETE` goes;
+ * - a setting at the pinned server's default goes;
+ * - a view's column list is not compared: the server infers it.
+ *
+ * What the rules cannot see is the server's own expression formatting
+ * (`a+b*2` prints as `a + (b * 2)`). When a plan reads a live server it asks
+ * that server's formatter (`formatQuerySingleLine`, a read with no side
+ * effects) about any expression the rules leave different
+ * (`./server-format.ts`). Nothing is created anywhere to normalize: a scratch
+ * database on the target would start Kafka consumers and register replicas in
+ * Keeper, and a scratch container would need Docker at plan time and could
+ * differ from the server in version.
+ */
+export { previouslyIn } from "../../core/normalize.js";
+export type ObjectKind = "database" | "table" | "view" | "materializedView";
+export interface CanonicalColumn {
+    name: string;
+    position: number;
+    type: string;
+    nullable?: boolean;
+    defaultKind?: string;
+    defaultExpr?: string;
+    codec?: string;
+    ttl?: string;
+    comment?: string;
+    /** `-- previously: <name>` on the column's line: the name it had before. */
+    previously?: string;
+    /** The column's name and type as written, for a message. Not compared. */
+    text: string;
+}
+export interface CanonicalObject {
+    kind: ObjectKind;
+    database?: string;
+    name: string;
+    engine?: string;
+    /** The engine's name alone. */
+    engineName?: string;
+    columns: CanonicalColumn[];
+    orderBy?: string;
+    primaryKey?: string;
+    partitionBy?: string;
+    sampleBy?: string;
+    ttl?: string;
+    settings: Record<string, string>;
+    indexes: Record<string, string>;
+    projections: Record<string, string>;
+    constraints: Record<string, string>;
+    comment?: string;
+    select?: string;
+    to?: string;
+    refresh?: string;
+    /** `-- previously: <name>` before the statement: the object's previous name. */
+    previously?: string;
+}
+/**
+ * The Keeper path and replica name a `Replicated*MergeTree` gets when its
+ * declaration leaves them out: the stock `default_replica_path` and
+ * `default_replica_name`, which `SHOW CREATE` then prints.
+ */
+export declare const DEFAULT_REPLICA_PATH = "'/clickhouse/tables/{uuid}/{shard}'";
+export declare const DEFAULT_REPLICA_NAME = "'{replica}'";
+/**
+ * An expression's canonical text: its significant tokens joined by single
+ * spaces, with the rewrites the server makes undone.
+ */
+export declare function canonicalExpression(text: string, ownDatabase?: string): string;
+/** A type with its family names canonical: `int` is `Int32`, `BIGINT` is `Int64`. */
+export declare function canonicalType(text: string): string;
+/** A codec chain with each codec's default level left out. */
+export declare function canonicalCodec(text: string): string;
+/** A TTL with each rule's trailing `DELETE` (the default action) left out. */
+export declare function canonicalTtl(text: string, ownDatabase?: string): string;
+/**
+ * Parse a CREATE statement into its canonical form. `defaultDatabase` is the
+ * database an unqualified name is created in.
+ */
+export declare function canonicalObject(ddl: string, defaultDatabase?: string): CanonicalObject;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/clickhouse/plan/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAOH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,kBAAkB,CAAC;AAE5E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA2BD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,wCAAwC,CAAC;AAC1E,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AASlD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CA8B9E;AAgBD,qFAAqF;AACrF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQlD;AAWD,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASnD;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvE;AA4BD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,SAAY,GAAG,eAAe,CA8EzF"}

package/dist/clickhouse/plan/rebuild-handoff.d.ts

@@ -0,0 +1,38 @@
+/**
+ * How a plan hands a rebuild to the rebuild migration Op (#3198).
+ *
+ * `chant sql plan`, `chant sql diff` and the applier refuse a rebuild in
+ * place. What they hand on is the Op to run instead, one per table: a
+ * `ClickHouseRebuildOp` declaration ready to put in an `*.op.ts` file, with
+ * the table's `database.name` filled in and a dual-write mode suggested from
+ * the declared columns (materialized-view mode on the first time column,
+ * otherwise app mode). The Op's own Plan phase then classifies the same
+ * change again against the server, so what it runs is what the plan refused,
+ * read fresh.
+ *
+ * Nothing is written for the user: the Op is a declaration, reviewed in the
+ * pull request like the schema change it carries out. The hand-off's shape is
+ * the shared core's (`../../core/handoff.ts`); the Op and the dual-write
+ * suggestion are ClickHouse's.
+ */
+import type { CanonicalObject } from "./normalize.js";
+import type { SchemaDiff } from "./diff.js";
+import { type MigrationOpSuggestion } from "../../core/handoff.js";
+export interface RebuildOpSuggestion extends MigrationOpSuggestion {
+    /** `database.name`, the Op's `table`. */
+    table: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+    } | {
+        mode: "app";
+    };
+}
+/**
+ * One suggestion per object the diff refuses as a rebuild. `declared` maps
+ * the diff's object keys to the declared definitions.
+ */
+export declare function rebuildOpSuggestions(diff: SchemaDiff, declared: ReadonlyMap<string, CanonicalObject>, env: string): RebuildOpSuggestion[];
+/** The suggestions as text, for the report. */
+export declare function renderRebuildOps(ops: readonly RebuildOpSuggestion[]): string[];
+//# sourceMappingURL=rebuild-handoff.d.ts.map

package/dist/clickhouse/plan/rebuild-handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-handoff.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/rebuild-handoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAuC,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAErG,MAAM,WAAW,mBAAoB,SAAQ,qBAAqB;IAChE,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE;QAAE,IAAI,EAAE,mBAAmB,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC;CACnF;AAID;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAmBzI;AAED,+CAA+C;AAC/C,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAE9E"}

package/dist/clickhouse/plan/report.d.ts

@@ -0,0 +1,6 @@
+/** A schema diff as text, for a terminal or a pull request (the shared core's report, with ClickHouse's refusal). */
+import type { SchemaDiff } from "./diff.js";
+export declare function renderDiff(diff: SchemaDiff, opts?: {
+    title?: string;
+}): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/clickhouse/plan/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/plan/report.ts"],"names":[],"mappings":"AAAA,qHAAqH;AAIrH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAGzC,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,CAWlF"}