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

package/dist/clickhouse/entities.d.ts

@@ -0,0 +1,183 @@
+/**
+ * The ClickHouse entities: `database`, `table` and `view` tagged templates that
+ * parse their DDL at fold time into one Declarable each (chant #3196, #3197).
+ *
+ * ```ts
+ * import { table, view } from "@intentius/chant-lexicon-sql/clickhouse";
+ *
+ * export const events = table`
+ *   CREATE TABLE events (user_id UUID, kind LowCardinality(String), ts DateTime)
+ *   ENGINE = MergeTree ORDER BY (user_id, ts)`;
+ *
+ * export const activeUsers = view`
+ *   CREATE MATERIALIZED VIEW active_users
+ *   ENGINE = AggregatingMergeTree ORDER BY ${events.columns.user_id} AS
+ *   SELECT ${events.columns.user_id}, count() AS n FROM ${events} GROUP BY ${events.columns.user_id}`;
+ * ```
+ *
+ * The export name is the object's identity in chant; the name in the SQL is the
+ * object's name in the database.
+ *
+ * What an interpolation means is decided by its value:
+ *
+ * - a `table`, `view` or `database` entity is a reference to that object, and
+ *   renders as its (database-qualified) name;
+ * - `entity.columns.<name>` is a reference to one column, and renders as the
+ *   column's name;
+ * - a string is SQL text, spliced into the statement before it is parsed, so a
+ *   composite can supply a name, a type, an engine or an expression;
+ * - a number or bigint is a numeric literal, a boolean `true`/`false`, `null`
+ *   is `NULL`;
+ * - `literal(value)` is a quoted, escaped string literal, for the case where a
+ *   string is meant as a value (`DEFAULT ${literal(plan)}`).
+ *
+ * Anything else, `undefined` included, is refused with the position it was
+ * interpolated at. `${events.user_id}` is `undefined` (columns are reached
+ * through `.columns`), and the refusal says so.
+ */
+import type { AttrRef } from "@intentius/chant/attrref";
+import { type TemplateDialect } from "../core/interpolation.js";
+import { SqlObject } from "../core/entity.js";
+import type { LineageEdge } from "../core/references.js";
+import { SqlLiteral } from "../core/template.js";
+export { SQL_LEXICON } from "../core/entity.js";
+export type { LineageEdge } from "../core/references.js";
+export { SqlLiteral, SqlTemplateError, templateParts, unescapeTemplateDelimiters } from "../core/template.js";
+export declare const CLICKHOUSE_ENTITY_TYPES: {
+    readonly database: "ClickHouse::Database";
+    readonly table: "ClickHouse::Table";
+    readonly view: "ClickHouse::View";
+    readonly materializedView: "ClickHouse::MaterializedView";
+};
+export type ClickHouseEntityType = (typeof CLICKHOUSE_ENTITY_TYPES)[keyof typeof CLICKHOUSE_ENTITY_TYPES];
+/** A column of a table or view, as declared. Expressions are the source text with interpolations rendered. */
+export interface ColumnDef {
+    name: string;
+    type?: string;
+    nullable?: boolean;
+    default?: {
+        kind: "DEFAULT" | "MATERIALIZED" | "ALIAS" | "EPHEMERAL";
+        expr?: string;
+    };
+    codec?: string;
+    ttl?: string;
+    comment?: string;
+    statistics?: string;
+    settings?: string;
+}
+export interface EngineDef {
+    name: string;
+    /** Each argument's text, as written. Absent when the engine is written without parentheses. */
+    args?: string[];
+}
+interface StorageProps {
+    engine?: EngineDef;
+    orderBy?: string;
+    primaryKey?: string;
+    partitionBy?: string;
+    sampleBy?: string;
+    ttl?: string;
+    settings?: Record<string, string>;
+}
+interface CommonProps {
+    /** The object's name in the database, unquoted. */
+    name: string;
+    /** The database it is created in, when the DDL qualifies it. */
+    database?: string;
+    onCluster?: string;
+    comment?: string;
+    /** The statement as it will be sent: the author's text, interpolations rendered. */
+    ddl: string;
+    /** The template's raw parts, as written, for a source round trip. */
+    source: {
+        strings: string[];
+    };
+}
+export interface DatabaseProps extends CommonProps {
+    engine?: EngineDef;
+    settings?: Record<string, string>;
+}
+export interface TableProps extends CommonProps, StorageProps {
+    columns: ColumnDef[];
+    indexes: Array<{
+        name: string;
+        expr: string;
+        type: string;
+        granularity?: string;
+    }>;
+    projections: Array<{
+        name: string;
+        definition: string;
+    }>;
+    constraints: Array<{
+        name: string;
+        kind: "CHECK" | "ASSUME";
+        expr: string;
+    }>;
+    orReplace?: boolean;
+    ifNotExists?: boolean;
+}
+export interface ViewProps extends CommonProps, StorageProps {
+    /** Declared output columns; empty when the view infers them from its SELECT. */
+    columns: ColumnDef[];
+    /** For a refreshable materialized view, the `REFRESH` clause. */
+    refresh?: string;
+    append?: boolean;
+    /** The target a materialized view writes into: the entity when it is declared, else its name. */
+    to?: ClickHouseObject | string;
+    populate?: boolean;
+    empty?: boolean;
+    security?: string;
+    select: string;
+    /** The tables and views the SELECT reads, as references. */
+    reads: ClickHouseObject[];
+    /** Per output column of the top-level select list, the columns it reads. */
+    lineage: LineageEdge[];
+    orReplace?: boolean;
+    ifNotExists?: boolean;
+}
+/**
+ * A string as a quoted, escaped ClickHouse string literal. An interpolated
+ * plain string is SQL text; wrap it in `literal()` when it is a value.
+ */
+export declare function literal(value: string | number | boolean | null): SqlLiteral;
+/** The members a ClickHouse entity has besides its props (the shared core's {@link SqlObject}). */
+export declare abstract class ClickHouseObject extends SqlObject {
+    readonly entityType: ClickHouseEntityType;
+    /** The name the object is referred to by in SQL: `name`, or `database.name`. */
+    readonly sqlName: string;
+}
+export interface ClickHouseDatabase extends ClickHouseObject {
+    readonly entityType: "ClickHouse::Database";
+    readonly props: DatabaseProps;
+}
+/** A table or a view: something with columns that SQL can reference. */
+export interface ClickHouseRelation extends ClickHouseObject {
+    /** One reference per column, by name: `${events.columns.user_id}`. */
+    readonly columns: Readonly<Record<string, AttrRef>>;
+}
+export interface ClickHouseTable extends ClickHouseRelation {
+    readonly entityType: "ClickHouse::Table";
+    readonly props: TableProps;
+}
+export interface ClickHouseView extends ClickHouseRelation {
+    readonly entityType: "ClickHouse::View" | "ClickHouse::MaterializedView";
+    readonly props: ViewProps;
+}
+export declare function isClickHouseObject(value: unknown): value is ClickHouseObject;
+/** A column reference: an AttrRef whose parent is a ClickHouse table or view. */
+export declare function isColumnRef(value: unknown): value is AttrRef;
+/** A name as ClickHouse reads it: bare when it is a plain identifier, backquoted otherwise. */
+export declare function quoteIdentifier(name: string): string;
+/** ClickHouse as the shared template machinery reads it (`../core/interpolation.ts`). */
+export declare const CLICKHOUSE_TEMPLATES: TemplateDialect;
+/** `` database`CREATE DATABASE ...` ``: one ClickHouse database, parsed at build time. */
+export declare function database(strings: TemplateStringsArray, ...values: unknown[]): ClickHouseDatabase;
+/** `` table`CREATE TABLE ...` ``: one ClickHouse table, parsed at build time. */
+export declare function table(strings: TemplateStringsArray, ...values: unknown[]): ClickHouseTable;
+/**
+ * `` view`CREATE [MATERIALIZED] VIEW ...` ``: one view or materialized view,
+ * with the tables it reads and its column lineage.
+ */
+export declare function view(strings: TemplateStringsArray, ...values: unknown[]): ClickHouseView;
+//# sourceMappingURL=entities.d.ts.map

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

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

package/dist/clickhouse/http.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The smallest ClickHouse client chant needs: one SQL statement over the HTTP
+ * interface, rows back as JSON objects.
+ *
+ * No driver dependency. ClickHouse's HTTP interface takes the statement as the
+ * request body and `default_format=JSONEachRow` returns one JSON object per
+ * line, which is all generation (and, later, observation and import) reads.
+ */
+/** Where a server answers, and as whom. */
+export interface ClickHouseEndpoint {
+    /** Base URL of the HTTP interface, e.g. `http://127.0.0.1:8123`. */
+    url: string;
+    user?: string;
+    password?: string;
+}
+/** A query the server refused, with the server's own message. */
+export declare class ClickHouseQueryError extends Error {
+    readonly status: number;
+    readonly serverMessage: string;
+    readonly sql: string;
+    constructor(status: number, serverMessage: string, sql: string);
+}
+/** Per-query options. */
+export interface QueryOptions {
+    /**
+     * The query's id on the server (`system.processes`, `KILL QUERY`). The
+     * server refuses a second query with an id that is still running, which is
+     * what a caller that must never run one statement twice at once relies on.
+     */
+    queryId?: string;
+    /** Server settings for this query alone, e.g. `{ mutations_sync: "2" }`. */
+    settings?: Record<string, string>;
+    /** Abandons the request. The server may go on running a statement it already started. */
+    signal?: AbortSignal;
+}
+/** Run one statement and return its rows. A statement that returns nothing yields `[]`. */
+export declare function clickhouseQuery<Row = Record<string, unknown>>(endpoint: ClickHouseEndpoint, sql: string, opts?: QueryOptions): Promise<Row[]>;
+/** True when the server answers `/ping`. */
+export declare function clickhousePing(endpoint: ClickHouseEndpoint): Promise<boolean>;
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/clickhouse/http.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,iEAAiE;AACjE,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM;gBAFX,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM;CAKvB;AAED,yBAAyB;AACzB,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,yFAAyF;IACzF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,2FAA2F;AAC3F,wBAAsB,eAAe,CAAC,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,GAAG,EAAE,CAAC,CAiBhB;AAED,4CAA4C;AAC5C,wBAAsB,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnF"}

package/dist/clickhouse/import/generator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The import IR as TypeScript: one `schema.ts` holding every imported
+ * object as a `database`, `table` or `view` declaration, in dependency order,
+ * with references between them interpolated. One file because the references
+ * cross databases freely, and declarations in one file reference each other
+ * without import cycles.
+ */
+import type { GeneratedFile, TypeScriptGenerator } from "@intentius/chant/import/generator";
+import type { TemplateIR } from "@intentius/chant/import/parser";
+export declare class ClickHouseGenerator implements TypeScriptGenerator {
+    private readonly header?;
+    readonly ownsLayout = true;
+    constructor(header?: string | undefined);
+    generate(ir: TemplateIR): GeneratedFile[];
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/clickhouse/import/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/generator.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AA2FjE,qBAAa,mBAAoB,YAAW,mBAAmB;IAGjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAFpC,QAAQ,CAAC,UAAU,QAAQ;gBAEE,MAAM,CAAC,EAAE,MAAM,YAAA;IAE5C,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,aAAa,EAAE;CA+C1C"}

package/dist/clickhouse/import/ir.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ClickHouse DDL into the import IR, and back out as `database`, `table` and
+ * `view` declarations.
+ *
+ * `chant import --from <env>` reads each object's `SHOW CREATE` and `chant
+ * import schema.sql` reads a file of CREATE statements; both arrive here as
+ * statements. The generated declaration is the statement itself, the
+ * server's canonical form when it came from a server (#3046 question 5), with
+ * two changes:
+ *
+ * - a qualified name of another imported object becomes a reference to its
+ *   export (`FROM analytics.events` is `FROM ${events}`), and the database
+ *   part of an object's own name becomes a reference to the database's export,
+ *   so dependency order survives the import;
+ * - a backquoted identifier that needs no quoting is written bare, and one that
+ *   does is double-quoted, so the template has no backquotes to escape.
+ *
+ * Columns written by name inside a view's SELECT stay text: which table a
+ * bare name belongs to is the server's to resolve, and a guess would be
+ * wrong lineage. An imported view therefore records its reads, not its column
+ * lineage, until its column references are written as `${t.columns.c}`.
+ */
+import type { TemplateIR } from "@intentius/chant/import/parser";
+import { type ClickHouseEntityType } from "../entities.js";
+export interface ImportedObject {
+    type: ClickHouseEntityType;
+    database?: string;
+    name: string;
+    /** The CREATE statement. */
+    ddl: string;
+}
+/**
+ * Export names for a set of objects. A table or view is its name in camel
+ * case, prefixed with its database when two databases share a name; a
+ * database is its name with `Db` after it, so `analytics` the database and
+ * `analytics` a table do not collide.
+ */
+export declare function exportNames(objects: readonly ImportedObject[]): string[];
+/** Split a file of statements on top-level `;`. */
+export declare function splitStatements(text: string): string[];
+/** Read a statement's kind and name. Throws the parser's error when it does not parse. */
+export declare function describeStatement(ddl: string): ImportedObject;
+/**
+ * Leave out what the server adds and the declaration would not say: settings
+ * at the pinned server's default (`index_granularity = 8192`), and a view's
+ * column list, which the server infers from the SELECT. A server re-adds both
+ * on create, so the stripped statement creates the same object.
+ */
+export declare function stripServerDefaults(ddl: string): string;
+/** The IR for a set of objects. */
+export declare function objectsToIR(objects: readonly ImportedObject[], warnings?: string[]): TemplateIR;
+//# sourceMappingURL=ir.d.ts.map

package/dist/clickhouse/import/ir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAG7E,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGjF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAC;CACb;AAeD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,EAAE,CAkBxE;AAED,mDAAmD;AACnD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CActD;AAmBD,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAI7D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAoCvD;AAED,mCAAmC;AACnC,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,EAAE,QAAQ,GAAE,MAAM,EAAO,GAAG,UAAU,CAQnG"}

package/dist/clickhouse/import/live-export.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Live export: `chant import --from <env>` writes the server's schema as
+ * `database`, `table` and `view` declarations.
+ *
+ * Every object in the environment's databases is read with `SHOW CREATE`, the
+ * server's canonical form, which is the baseline #3046 question 5 asks for.
+ * By default what the server adds on its own is left out (settings at their
+ * default, a view's inferred column list), so the declaration says what an
+ * author would; `verbatim` keeps the statement as the server printed it.
+ *
+ * - `selector.type` is an entity type (`ClickHouse::Table`); `selector.name` is
+ *   an object name, `db.name` or `name`.
+ * - `owned` keeps the objects whose comment carries chant's ownership marker
+ *   (`../ownership.ts`), the trailer the applier stamps. The trailer itself is
+ *   never written into a declaration: `readLiveSchema` takes it off.
+ */
+import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
+import { type BindOptions } from "../live/bind.js";
+export interface ExportOptions extends Omit<BindOptions, "environment"> {
+    environment: string;
+    stack?: string;
+    region?: string;
+    selector?: ResourceSelector;
+    owned?: boolean;
+    verbatim?: boolean;
+}
+export declare function exportResources(options: ExportOptions): Promise<ExportedTemplate>;
+//# sourceMappingURL=live-export.d.ts.map

package/dist/clickhouse/import/live-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-export.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/live-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAKhE,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAoBvF"}

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

@@ -0,0 +1,10 @@
+/**
+ * `chant import schema.sql`: a file of ClickHouse CREATE statements into the
+ * import IR. Each statement must parse; one that does not is reported in the
+ * IR's warnings and left out, with the parser's message.
+ */
+import type { TemplateIR, TemplateParser } from "@intentius/chant/import/parser";
+export declare class ClickHouseSqlParser implements TemplateParser {
+    parse(content: string): TemplateIR;
+}
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGjF,qBAAa,mBAAoB,YAAW,cAAc;IACxD,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;CAgBnC"}

package/dist/clickhouse/live/bind.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Which ClickHouse server a chant environment reads: the config lookup and
+ * the binding, shared by observation and live export so both read the same
+ * server.
+ */
+import type { ChantConfig } from "@intentius/chant/config";
+import type { UnobservedReason } from "@intentius/chant/observation";
+import { type ClickHouseEndpoint } from "../http.js";
+export interface ClickHouseTarget {
+    endpoint: ClickHouseEndpoint;
+    /** Where the binding came from: `sql.profiles.prod` or `env CLICKHOUSE_URL`. */
+    source: string;
+    /** The databases in scope; undefined is every database but the server's own. */
+    databases?: string[];
+    defaultDatabase: string;
+}
+export interface UnresolvedTarget {
+    reason: "no-binding" | "no-credentials";
+    detail: string;
+}
+export declare const isUnresolvedTarget: (v: ClickHouseTarget | UnresolvedTarget) => v is UnresolvedTarget;
+/**
+ * The server an environment reads. Pure: `config` and `env` are passed in.
+ *
+ * 1. `sql.profiles.<environment>`. A profile naming a credential variable that
+ *    is not set is `no-credentials`: the profile said how to authenticate.
+ * 2. `CLICKHOUSE_URL`, with `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD` when set.
+ * 3. Otherwise `no-binding`.
+ */
+export declare function resolveClickHouseTarget(input: {
+    environment?: string;
+    config?: Pick<ChantConfig, "sql">;
+    env?: Record<string, string | undefined>;
+}): ClickHouseTarget | UnresolvedTarget;
+/** A target that could not be resolved. */
+export declare class ClickHouseBindingError extends Error {
+    readonly unresolved: UnresolvedTarget;
+    constructor(unresolved: UnresolvedTarget);
+}
+export interface BindOptions {
+    environment?: string;
+    /** The project's config; loaded from `cwd` when omitted. */
+    config?: Pick<ChantConfig, "sql">;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}
+/** Resolve the environment's server. Throws {@link ClickHouseBindingError} when there is none. */
+export declare function bindClickHouse(options?: BindOptions): Promise<ClickHouseTarget>;
+/** What a failed bind or read means, in the observation vocabulary. */
+export declare function classifyClickHouseFailure(err: unknown): {
+    reason: UnobservedReason;
+    detail: string;
+};
+/** `SELECT version()` on the target. */
+export declare function serverVersion(target: ClickHouseTarget): Promise<string>;
+//# sourceMappingURL=bind.d.ts.map

package/dist/clickhouse/live/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/live/bind.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAyC,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEzF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB,GAAI,GAAG,gBAAgB,GAAG,gBAAgB,KAAG,CAAC,IAAI,gBAAiC,CAAC;AAEnH;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C,GAAG,gBAAgB,GAAG,gBAAgB,CAkCtC;AAED,2CAA2C;AAC3C,qBAAa,sBAAuB,SAAQ,KAAK;IACnC,QAAQ,CAAC,UAAU,EAAE,gBAAgB;gBAA5B,UAAU,EAAE,gBAAgB;CAIlD;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C;AAYD,kGAAkG;AAClG,wBAAsB,cAAc,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAKzF;AAED,uEAAuE;AACvE,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAUpG;AAED,wCAAwC;AACxC,wBAAsB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7E"}

package/dist/clickhouse/live/catalog.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Reading a live server's schema: the databases and the tables, views and
+ * materialized views in them, from `system.databases`, `system.tables` and
+ * `SHOW CREATE`.
+ */
+import type { ClickHouseTarget } from "./bind.js";
+import { type ClickHouseEntityType } from "../entities.js";
+/** The server's own databases, never part of a declared schema. */
+export declare const SYSTEM_DATABASES: Set<string>;
+export interface LiveObject {
+    type: ClickHouseEntityType;
+    database?: string;
+    name: string;
+    /** The engine `system.tables` / `system.databases` report: `MergeTree`, `View`, `MaterializedView`, `Atomic`. */
+    engine: string;
+    uuid?: string;
+    /** The object's comment as the server holds it, chant's ownership trailer included (`../ownership.ts`). */
+    comment?: string;
+    /** `SHOW CREATE` as the server prints it, less chant's ownership trailer, so it reads as the declaration. */
+    statement: string;
+}
+/** The entity type a `system.tables` engine stands for. */
+export declare function entityTypeOfEngine(engine: string): ClickHouseEntityType;
+/**
+ * Every object in the target's databases, sorted by database then name.
+ * A materialized view's inner table (`.inner_id.<uuid>`, `.inner.<name>`)
+ * belongs to its view and is left out, as are temporary tables and
+ * dictionaries (not declared in slice 1).
+ *
+ * So are chant's own working objects (`../ownership.ts`
+ * `isChantWorkingObject`): a rebuild migration's new, dual-write and retained
+ * tables, and the effect receipts database. None of them is a declaration, so
+ * a plan, an import or a prune that saw them would propose dropping, importing
+ * or pruning the very objects a rebuild in progress depends on.
+ */
+export declare function readLiveSchema(target: ClickHouseTarget, opts?: {
+    withStatements?: boolean;
+}): Promise<LiveObject[]>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/clickhouse/live/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/live/catalog.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAC/C,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGjF,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,aAAkE,CAAC;AAEhG,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,iHAAiH;IACjH,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2GAA2G;IAC3G,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6GAA6G;IAC7G,SAAS,EAAE,MAAM,CAAC;CACnB;AAKD,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAIvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA8C7H"}

package/dist/clickhouse/live/describe-resources.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `describeResources()` for the ClickHouse dialect: which declared databases,
+ * tables and views exist on the environment's server.
+ *
+ * One read of `system.databases` and `system.tables` per run, then a lookup
+ * per declared entity, so N entities are two queries, not N. An object the
+ * catalog does not list is absent, and the `queried` address says which
+ * server and name were asked. A server that cannot be reached, or refuses the
+ * credentials, leaves every entity unobserved with that reason: never absent.
+ *
+ * Ownership is read from chant's marker, the trailer the applier appends to
+ * the object's comment (`../ownership.ts`): `owned` when the comment carries
+ * it, `foreign` when it does not. With `owned: true` a foreign object is
+ * withheld as `filtered`, which says it exists and is not chant's, never that
+ * it is absent.
+ */
+import { type DeclaredEntity, type DescribeResourcesResult } from "@intentius/chant/observation";
+import { type BindOptions } from "./bind.js";
+/** The database and name a declared entity is created as. */
+export declare function declaredAddress(entity: DeclaredEntity, defaultDatabase: string): {
+    database?: string;
+    name: string;
+};
+export declare function describeResources(options: {
+    environment: string;
+    entityNames: string[];
+    entities: Map<string, {
+        entityType: string;
+        props: Record<string, unknown>;
+    }>;
+    /** Withhold objects that do not carry chant's ownership marker. */
+    owned?: boolean;
+} & Omit<BindOptions, "environment">): Promise<DescribeResourcesResult>;
+//# sourceMappingURL=describe-resources.d.ts.map

package/dist/clickhouse/live/describe-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/live/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAG7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAA6C,KAAK,WAAW,EAAyB,MAAM,QAAQ,CAAC;AAY5G,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAIpH;AA0CD,wBAAsB,iBAAiB,CACrC,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;IAC9E,mEAAmE;IACnE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAMlC"}

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

@@ -0,0 +1,28 @@
+/**
+ * Codec parameters and chaining: the overlay half.
+ *
+ * `system.codecs` gives the 17 names and their flags (compression, generic,
+ * encryption, time series, experimental). The parameters (`ZSTD(level)`,
+ * `Delta(bytes)`) and the order a chain like `CODEC(Delta, ZSTD(3))` must
+ * follow are in no table.
+ *
+ * Every codec at the pin has an entry, and generation fails when one does not,
+ * so a codec a pin move adds is a decision rather than a silent `string`.
+ * `"unknown"` is that decision for the experimental codecs whose parameters
+ * are not documented: they are accepted as written and not checked.
+ */
+import type { ArgumentOverlay } from "./kinds.js";
+export interface CodecOverlay {
+    /** Positional parameters, all optional unless marked otherwise; `"unknown"` when undocumented. */
+    parameters: readonly (ArgumentOverlay & {
+        name: string;
+    })[] | "unknown";
+    /**
+     * Where the codec sits in a chain. A `preprocessing` codec transforms values
+     * for the compression codec that must follow it; `encryption` comes last;
+     * `internal` is never written by hand.
+     */
+    role: "preprocessing" | "compression" | "encryption" | "none" | "internal";
+}
+export declare const CODEC_OVERLAY: Record<string, CodecOverlay>;
+//# sourceMappingURL=codecs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/codecs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,kGAAkG;IAClG,UAAU,EAAE,SAAS,CAAC,eAAe,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,GAAG,SAAS,CAAC;IACxE;;;;OAIG;IACH,IAAI,EAAE,eAAe,GAAG,aAAa,GAAG,YAAY,GAAG,MAAM,GAAG,UAAU,CAAC;CAC5E;AASD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAiCtD,CAAC"}

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

@@ -0,0 +1,20 @@
+/**
+ * Engine arguments: the overlay half (chant #3195).
+ *
+ * The generator reads each engine's argument names, positions and optionality
+ * from the server's `syntax` line (`engine-syntax.ts`). This table adds what
+ * that line cannot say: whether `ver` is a column, `cluster` a name, `min_time`
+ * a number. Keys are the argument names exactly as the syntax line spells
+ * them, and generation fails when one no longer appears there, so a pin move
+ * that renames or drops an argument is caught rather than mistyped.
+ *
+ * Covered: the MergeTree family and its Replicated twins, and the engines a
+ * schema commonly declares beside them (Distributed, Buffer, Join, Merge,
+ * Dictionary, File, URL, Alias, KeeperMap, EmbeddedRocksDB, GenerateRandom).
+ * Integration engines (S3, Kafka, the lake engines, the database bridges) keep
+ * their arguments untyped: they are connection strings and credentials, which
+ * lint has no business guessing at.
+ */
+import type { ArgumentOverlay } from "./kinds.js";
+export declare const ENGINE_ARGUMENTS: Record<string, Record<string, ArgumentOverlay>>;
+//# sourceMappingURL=engines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engines.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/engines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAmB/C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAsE5E,CAAC"}

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

@@ -0,0 +1,38 @@
+/**
+ * What kind of value an argument or parameter takes. The catalog names an
+ * argument (`ver`, `cluster`); it never says whether `ver` is a column and
+ * `cluster` a name, which is what these say.
+ */
+export type ArgumentKind = 
+/** One column of the table, by name. */
+"column"
+/** A column, or a tuple of columns. */
+ | "columns"
+/** Any expression over the table's columns. */
+ | "expression"
+/** A database, table, cluster or dictionary name. */
+ | "identifier"
+/** A string literal. */
+ | "string"
+/** A numeric literal. */
+ | "number"
+/** A bare keyword from a fixed set (`values`). */
+ | "keyword"
+/** A column type (`Nullable(T)`'s `T`). */
+ | "type"
+/** An aggregate function name with its parameters (`AggregateFunction(uniq, UUID)`'s `uniq`). */
+ | "function"
+/** A codec, as written inside `CODEC(...)`. */
+ | "codec";
+export interface ArgumentOverlay {
+    kind: ArgumentKind;
+    /** Overrides the syntax line's optionality, with `note` saying why. */
+    optional?: boolean;
+    /** The legal values of a `keyword`. */
+    values?: readonly string[];
+    /** The inclusive range of a `number`. */
+    range?: readonly [number, number];
+    /** Where the overlay knows something the syntax line does not. */
+    note?: string;
+}
+//# sourceMappingURL=kinds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/overlays/kinds.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,YAAY;AACtB,wCAAwC;AACtC,QAAQ;AACV,uCAAuC;GACrC,SAAS;AACX,+CAA+C;GAC7C,YAAY;AACd,qDAAqD;GACnD,YAAY;AACd,wBAAwB;GACtB,QAAQ;AACV,yBAAyB;GACvB,QAAQ;AACV,kDAAkD;GAChD,SAAS;AACX,2CAA2C;GACzC,MAAM;AACR,iGAAiG;GAC/F,UAAU;AACZ,+CAA+C;GAC7C,OAAO,CAAC;AAEZ,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,yCAAyC;IACzC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

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

@@ -0,0 +1,27 @@
+/**
+ * Projections: the overlay half.
+ *
+ * `system.table_engines.supports_projections` says which engines accept a
+ * projection, and is generated. The projection's own grammar is fixed and in
+ * no table: a name and a parenthesised query over the table, either a
+ * reordering (`SELECT * ORDER BY x`) or an aggregation (`SELECT k, sum(v)
+ * GROUP BY k`). `system.projections` is runtime state, not grammar.
+ *
+ *     PROJECTION name (SELECT <columns or *> [GROUP BY ...] [ORDER BY ...])
+ */
+export interface ProjectionForm {
+    form: "normal" | "aggregate";
+    /** The clause that makes a projection this form. */
+    marker: "ORDER BY" | "GROUP BY";
+    summary: string;
+}
+export declare const PROJECTION_FORMS: readonly ProjectionForm[];
+/**
+ * MergeTree settings that decide what a mutation or deduplicating merge does to
+ * a table with projections. Changing either is metadata only; leaving them at
+ * their defaults makes `ALTER ... UPDATE` on such a table an error.
+ */
+export declare const PROJECTION_SETTINGS: readonly string[];
+/** Clauses a projection's query may not carry. */
+export declare const PROJECTION_FORBIDDEN_CLAUSES: readonly string[];
+//# sourceMappingURL=projections.d.ts.map