ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/cockroachdb/index.js

@@ -32,15 +32,27 @@
  *   folded into the default query-retry match lists so single-statement
  *   retries cover it too.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CockroachDBTransaction = exports.CockroachDBDialect = void 0;
 exports.createCockroachDBDialect = createCockroachDBDialect;
-const pg_1 = __importDefault(require("pg"));
+const operators_1 = require("../../operators");
 const prorm_1 = require("../../prorm");
-const { Pool: PgPool } = pg_1.default;
+// Lazily-loaded `pg` driver. Required only when a connection is opened, so
+// importing this ORM never loads the pg driver.
+let pgModule = null;
+function loadPg() {
+    if (!pgModule) {
+        try {
+            pgModule = require('pg');
+        }
+        catch (err) {
+            throw new Error("The 'pg' package is required to use the CockroachDB dialect but could not be loaded. " +
+                'Install it with `npm install pg`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return pgModule;
+}
 /**
  * Build a CockroachDB OPTIONS (...) clause from a plain object.
  * Single-quotes each value and escapes existing single-quotes.
@@ -153,7 +165,7 @@ class CockroachDBDialect {
      */
     async connect() {
         try {
-            this.pool = new PgPool({
+            this.pool = new (loadPg().Pool)({
                 host: this.config.host,
                 port: this.config.port,
                 user: this.config.username,
@@ -2140,6 +2152,62 @@ class CockroachDBDialect {
         const result = await this.query(sql);
         return result.rows;
     }
+    /**
+     * Inspect the range (shard) distribution of a table or index via
+     * CockroachDB's `SHOW RANGES FROM TABLE|INDEX ...`. Each row describes one
+     * range: its start/end keys, lease holder, and replica placement. Useful for
+     * diagnosing hotspots and verifying `splitAt()`/`configureZone()` results
+     * without dropping to raw SQL.
+     *
+     * @param target - `{ kind: 'table', name }` or `{ kind: 'index', table,
+     *   index }` naming what to inspect (same target shape as
+     *   {@link configureZone}/{@link splitAt}).
+     * @see https://www.cockroachlabs.com/docs/stable/show-ranges
+     */
+    async showRanges(target) {
+        const sql = `SHOW RANGES FROM ${this.resolveZoneTarget(target)}`;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Show the single range that would contain a given primary-key row
+     * (`SHOW RANGE FROM TABLE <t> FOR ROW (val, ...)`), reporting its lease
+     * holder and replica placement. Handy for pinpointing which node owns a
+     * specific hot key.
+     *
+     * @param tableName - Table to look up the row's range in.
+     * @param rowValues - The row's primary-key column value(s), in key order.
+     * @see https://www.cockroachlabs.com/docs/stable/show-range-for-row
+     */
+    async showRangeForRow(tableName, rowValues) {
+        const tuple = rowValues.map((v) => this.formatSplitValue(v)).join(', ');
+        const sql = `SHOW RANGE FROM TABLE ${this.escapeId(tableName)} FOR ROW (${tuple})`;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Return the cost-based optimizer's table statistics
+     * (`SHOW STATISTICS FOR TABLE <t>`): column sets, row counts, distinct
+     * counts, null counts and histogram ids the planner uses for cardinality
+     * estimation.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/show-statistics
+     */
+    async showStatistics(tableName) {
+        const sql = `SHOW STATISTICS FOR TABLE ${this.escapeId(tableName)}`;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Trigger a fresh collection of table statistics for the optimizer
+     * (`ANALYZE <t>`, an alias of `CREATE STATISTICS ... FROM <t>`). Run after a
+     * large bulk load/mutation so the planner has accurate cardinality estimates.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/create-statistics
+     */
+    async analyzeTable(tableName) {
+        await this.query(`ANALYZE ${this.escapeId(tableName)}`);
+    }
     /**
      * Describe a table (get column information)
      *
@@ -2338,6 +2406,35 @@ class CockroachDBDialect {
             : ''}`;
         await this.query(sql);
     }
+    /**
+     * Create an inverted (GIN) index over a JSONB column so containment/path
+     * queries (`@>`, `->`, `->>`) on it can be index-accelerated. Unlike
+     * {@link createGINIndex} (which wraps the column in `to_tsvector(...)` for
+     * full-text search), this indexes the raw JSONB value directly:
+     * `CREATE [UNIQUE] INVERTED INDEX <name> ON <table> (<column>)`.
+     *
+     * CockroachDB spells inverted indexes as `INVERTED INDEX ... (col)`
+     * (equivalent to Postgres's `USING GIN (col)`); this helper emits the
+     * CockroachDB-native form. Also usable for `ARRAY` columns.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/inverted-indexes
+     */
+    async createInvertedIndex(tableName, indexName, column, options) {
+        let sql = 'CREATE INVERTED INDEX';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${this.escapeId(column)})`;
+        if (options?.storageParameters && Object.keys(options.storageParameters).length > 0) {
+            sql +=
+                ' WITH (' +
+                    Object.entries(options.storageParameters)
+                        .map(([k, v]) => `${k} = ${v}`)
+                        .join(', ') +
+                    ')';
+        }
+        await this.query(sql);
+    }
     /**
      * Build a to_tsvector expression
      * SQL: to_tsvector([config,] document)
@@ -2706,9 +2803,32 @@ class CockroachDBDialect {
         else {
             await client.query('BEGIN');
         }
+        // Apply transaction priority (SET TRANSACTION PRIORITY LOW|NORMAL|HIGH)
+        // right after BEGIN, if requested. The priority keyword is from a fixed
+        // enum (not user input), so it is safe to interpolate directly.
+        if (options?.priority) {
+            await client.query(`SET TRANSACTION PRIORITY ${options.priority}`);
+        }
         const transaction = new CockroachDBTransaction(client, this.transactionDepth++, options);
         return transaction;
     }
+    /**
+     * Set the priority of the *current* transaction
+     * (`SET TRANSACTION PRIORITY {LOW|NORMAL|HIGH}`). Must be called on a
+     * transaction's own client, before any statement in the transaction reads or
+     * writes data. Prefer passing `priority` to {@link startTransaction} /
+     * {@link runTransaction}; this helper is for adjusting an already-open
+     * transaction created elsewhere.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/set-transaction
+     */
+    async setTransactionPriority(transaction, priority) {
+        const tx = transaction;
+        if (!tx.client) {
+            throw new Error('Transaction has no active client');
+        }
+        await tx.client.query(`SET TRANSACTION PRIORITY ${priority}`);
+    }
     /**
      * Run a function inside a CockroachDB transaction, automatically retrying
      * the *entire transaction body* when it fails with a serialization failure
@@ -3393,6 +3513,15 @@ class CockroachDBDialect {
     /**
      * Check if a value is a literal expression (literal('sql'))
      */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    literalSql(expr) {
+        return (0, operators_1.expandLiteralBindings)(expr, (v) => this.escape(v));
+    }
     isLiteralExpression(value) {
         return value !== null && typeof value === 'object' && value.__type === 'literal';
     }
@@ -3436,7 +3565,7 @@ class CockroachDBDialect {
                         sql = this.escapeId(expr.col);
                     }
                     else if (this.isLiteralExpression(expr)) {
-                        sql = expr.sql;
+                        sql = this.literalSql(expr);
                     }
                     else if (typeof expr === 'string') {
                         // Check if it's a column reference or literal SQL
@@ -3460,7 +3589,7 @@ class CockroachDBDialect {
                     return this.escapeId(attr.col);
                 }
                 else if (this.isLiteralExpression(attr)) {
-                    return attr.sql;
+                    return this.literalSql(attr);
                 }
                 else if (typeof attr === 'string') {
                     // Plain column name
@@ -3501,7 +3630,7 @@ class CockroachDBDialect {
                     sql = this.escapeId(expr.col);
                 }
                 else if (this.isLiteralExpression(expr)) {
-                    sql = expr.sql;
+                    sql = this.literalSql(expr);
                 }
                 else if (typeof expr === 'string') {
                     sql = this.escapeId(expr);
@@ -3522,7 +3651,7 @@ class CockroachDBDialect {
                 return this.escapeId(field.col);
             }
             else if (this.isLiteralExpression(field)) {
-                return field.sql;
+                return this.literalSql(field);
             }
             else if (typeof field === 'string') {
                 if (field.includes('.')) {

package/dist/dialects/cratedb/index.d.ts

@@ -0,0 +1,262 @@
+/**
+ * CrateDB dialect implementation for the TypeScript ORM
+ *
+ * CrateDB is a distributed SQL database that speaks the PostgreSQL wire protocol
+ * (default port 5432) and is largely PG-compatible on the client side, so this
+ * dialect extends `PostgresDialect` and reuses the `pg` driver for connectivity
+ * and most query building. It overrides the schema-generation surface (CREATE
+ * TABLE + type mapping) to emit CrateDB-native SQL. Notable differences from the
+ * Postgres dialect:
+ *
+ * - Default port stays 5432 (PG-wire-compatible), so the constructor forwards
+ *   `{ port: 5432, ...config }` to the Postgres base.
+ * - CREATE TABLE supports CrateDB's distribution/partitioning clauses, emitted in
+ *   CrateDB's required order: `PARTITIONED BY (col)`, then
+ *   `CLUSTERED [BY (col)] INTO n SHARDS`, then a `WITH ( ... )` settings block.
+ *   Example:
+ *     CREATE TABLE "t" (...) PARTITIONED BY ("day")
+ *       CLUSTERED BY ("id") INTO 6 SHARDS
+ *       WITH (number_of_replicas = '1', "refresh_interval" = 1000)
+ * - Type mapping is CrateDB-specific: TEXT, INTEGER, BIGINT, DOUBLE PRECISION,
+ *   BOOLEAN, TIMESTAMP, OBJECT and GEO_POINT (rather than Postgres VARCHAR/SERIAL/
+ *   JSONB/etc). Composite/semi-structured types use CrateDB syntax:
+ *     * OBJECT columns emit `OBJECT(DYNAMIC) AS (col type, ...)` (or bare `OBJECT`
+ *       when no sub-columns are declared). The column policy defaults to DYNAMIC.
+ *     * ARRAY columns emit `ARRAY(type)` (CrateDB's array syntax) rather than
+ *       Postgres's `type[]`.
+ * - PRIMARY KEY is preserved. NOTE: in CrateDB a PRIMARY KEY must include every
+ *   routing/clustered/partitioned column (CrateDB requires routing columns to be
+ *   part of the primary key). The dialect does not attempt to validate or rewrite
+ *   the PRIMARY KEY to enforce this — it is the caller's responsibility.
+ * - FOREIGN KEYs are OMITTED. CrateDB has no foreign-key support, so both
+ *   column-level `references` and any `FOREIGN KEY` table constraints are dropped
+ *   from generated DDL rather than emitted.
+ */
+import { PostgresDialect, PostgresDialectOptions } from '../postgres';
+import { ColumnDefinition, TableOptions, InsertOptions, IndexOptions, IndexDefinition, DropIndexOptions, ConstraintDefinition, CreateEnumTypeOptions, DropTypeOptions, CreateDomainOptions, DropDomainOptions } from '../dialect';
+import { DataType, SequenceOptions, DropSequenceOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, QueryResult, TriggerOptions, DropTriggerOptions, PolicyOptions, DropPolicyOptions, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions } from '../../types';
+/**
+ * CrateDB connection options. CrateDB is PG-wire-compatible, so this is just the
+ * Postgres option set (the default port is 5432, set in the constructor).
+ */
+export interface CrateDBDialectOptions extends PostgresDialectOptions {
+}
+/**
+ * CrateDB-specific CREATE TABLE options: sharding/routing (`CLUSTERED`),
+ * partitioning (`PARTITIONED BY`) and table settings (`WITH ( ... )`). Not part
+ * of the shared `TableOptions` type (used by every dialect), so callers targeting
+ * CrateDB pass these alongside the common options via an intersection type.
+ *
+ * @see https://cratedb.com/docs/crate/reference/en/latest/sql/statements/create-table.html
+ */
+export interface CrateDBTableOptions {
+    /** `CLUSTERED INTO n SHARDS` — number of shards to distribute the table into. */
+    clusteredInto?: number;
+    /** Alias for {@link CrateDBTableOptions.clusteredInto}. */
+    shards?: number;
+    /** `CLUSTERED BY (col)` — the routing column used to co-locate rows. */
+    clusteredBy?: string;
+    /** `PARTITIONED BY (col, ...)` — one or more partition (routing) columns. */
+    partitionedBy?: string | string[];
+    /**
+     * `WITH ( key = value, ... )` — CrateDB table settings, e.g.
+     * `{ number_of_replicas: '1', '"refresh_interval"': 1000 }`. String values are
+     * single-quoted; numeric/boolean values are emitted bare. Keys are emitted
+     * verbatim, so a quoted key (`'"refresh_interval"'`) is preserved as-is.
+     */
+    with?: Record<string, string | number | boolean>;
+    /**
+     * Fulltext (`INDEX name USING FULLTEXT (col, ...) [WITH (analyzer = '...')]`)
+     * indexes declared inside the column list. CrateDB has no standalone
+     * `CREATE INDEX` statement — the only user-defined indexes are fulltext
+     * indexes, and they must be declared at `CREATE TABLE` time as named index
+     * columns. Each entry emits one such index column.
+     *
+     * @see https://cratedb.com/docs/crate/reference/en/latest/general/ddl/fulltext-indices.html
+     */
+    fulltextIndexes?: Array<{
+        /** The index column name. */
+        name: string;
+        /** Source column(s) the fulltext index covers. */
+        fields: string[];
+        /** Optional analyzer, e.g. `'english'`, emitted as `WITH (analyzer = '...')`. */
+        analyzer?: string;
+    }>;
+}
+/**
+ * CrateDB INSERT options: the shared {@link InsertOptions} plus CrateDB's
+ * `ON CONFLICT ... DO NOTHING` variant (CrateDB supports both `DO UPDATE SET`
+ * and `DO NOTHING`, and — unlike `DO UPDATE` — `DO NOTHING` may omit the
+ * conflict target).
+ */
+export interface CrateDBInsertOptions extends InsertOptions {
+    /** Emit `ON CONFLICT [(fields)] DO NOTHING` instead of an upsert/plain insert. */
+    onConflictDoNothing?: boolean;
+}
+/**
+ * CrateDB dialect class. Extends the PostgreSQL dialect (PG-wire compatible) and
+ * overrides CREATE TABLE generation and type mapping for CrateDB.
+ */
+export declare class CrateDBDialect extends PostgresDialect {
+    readonly name = "cratedb";
+    constructor(config: CrateDBDialectOptions);
+    /**
+     * Map an ORM data type to its CrateDB SQL type. Overrides the Postgres mapping
+     * to emit CrateDB-native types (TEXT, INTEGER, BIGINT, DOUBLE PRECISION,
+     * BOOLEAN, TIMESTAMP, OBJECT, GEO_POINT) and CrateDB's `OBJECT(...)`/`ARRAY(...)`
+     * syntax for semi-structured/collection types.
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build the CrateDB `OBJECT` type SQL. Emits `OBJECT(POLICY) AS (col type, ...)`
+     * when sub-columns are declared, otherwise a bare `OBJECT`. The column policy
+     * defaults to DYNAMIC (CrateDB's default).
+     */
+    private buildObjectTypeSql;
+    /**
+     * Format a value for a `WITH ( key = value )` table setting: strings are
+     * single-quoted (with embedded quotes escaped), numbers/booleans are bare.
+     */
+    private formatSettingValue;
+    /**
+     * Format a CrateDB column DEFAULT value.
+     */
+    private formatDefaultValue;
+    /**
+     * Build a single CrateDB column definition. FOREIGN KEY references are omitted
+     * (CrateDB has no FK support).
+     */
+    private getCrateColumnDefinitionSql;
+    /**
+     * Build a CrateDB table constraint. FOREIGN KEY constraints are omitted
+     * (CrateDB has no FK support); PRIMARY KEY / UNIQUE / CHECK are passed through.
+     */
+    private buildCrateConstraintSql;
+    /**
+     * Build the CrateDB `CREATE TABLE` statement (synchronous, no execution).
+     *
+     * Emits clauses in CrateDB's required order after the column list:
+     *   1. `PARTITIONED BY (col, ...)`
+     *   2. `CLUSTERED [BY (col)] INTO n SHARDS`
+     *   3. `WITH ( key = value, ... )`
+     *
+     * FOREIGN KEY references/constraints are omitted (unsupported by CrateDB).
+     */
+    buildCreateTableSQL(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & CrateDBTableOptions): string;
+    /**
+     * Create a new table in CrateDB.
+     *
+     * Overrides the Postgres implementation to emit CrateDB's CREATE TABLE syntax
+     * (CLUSTERED / PARTITIONED BY / WITH, CrateDB type mapping, no foreign keys).
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & CrateDBTableOptions): Promise<void>;
+    private static readonly NO_CREATE_INDEX;
+    addIndex(_tableName: string, _indexName: string, _fields?: string[], _options?: IndexOptions): Promise<void>;
+    createIndex(_tableName: string, _indexDef: IndexDefinition): Promise<void>;
+    createFulltextIndex(_tableName: string, _indexName: string, _fields: string[], _options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    createSpatialIndex(_tableName: string, _indexName: string, _fields: string[], _options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    removeIndex(_tableName: string, _indexName: string): Promise<void>;
+    dropIndex(_tableName: string, _indexName: string, _options?: DropIndexOptions): Promise<void>;
+    addForeignKey(_tableName: string, _columnName: string, _referencedTableName: string, _referencedColumnName: string, _options?: unknown): Promise<void>;
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    /**
+     * Add a column via `ALTER TABLE t ADD COLUMN ...`. Overrides the Postgres
+     * implementation so the column uses CrateDB's type mapping and drops any FK
+     * reference (CrateDB supports ADD COLUMN but not SERIAL/REFERENCES).
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * CrateDB cannot rename columns via ALTER TABLE (no `RENAME COLUMN`).
+     */
+    renameColumn(_tableName: string, _oldColumnName: string, _newColumnName: string): Promise<void>;
+    /**
+     * CrateDB cannot rename tables via ALTER TABLE (no `RENAME TO`).
+     */
+    renameTable(_oldName: string, _newName: string): Promise<void>;
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: CrateDBInsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    private static unsupported;
+    createSequence(_options: SequenceOptions): Promise<void>;
+    dropSequence(_sequenceName: string, _options?: DropSequenceOptions): Promise<void>;
+    nextSequenceValue(_sequenceName: string): Promise<number>;
+    hasSequence(_sequenceName: string): Promise<boolean>;
+    createMaterializedView(_options: MaterializedViewOptions): Promise<void>;
+    refreshMaterializedView(_viewName: string, _options?: RefreshOptions): Promise<void>;
+    dropMaterializedView(_viewName: string, _options?: DropMaterializedViewOptions): Promise<void>;
+    hasMaterializedView(_viewName: string): Promise<boolean>;
+    showMaterializedViews(): Promise<string[]>;
+    createStoredProcedure(_options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(_procedureName: string, _options?: DropStoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(_options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(_procedureName: string, _schema?: string): Promise<boolean>;
+    createTrigger(_options: TriggerOptions): Promise<void>;
+    dropTrigger(_triggerName: string, _tableName: string, _options?: DropTriggerOptions): Promise<void>;
+    hasTrigger(_triggerName: string, _tableName: string): Promise<boolean>;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(_tableName: string, _schema?: string): Promise<void>;
+    disableRLS(_tableName: string, _schema?: string): Promise<void>;
+    hasPolicy(_policyName: string, _tableName: string): Promise<boolean>;
+    createEnumType(_name: string, _values: string[], _options?: CreateEnumTypeOptions): Promise<void>;
+    dropType(_name: string, _options?: DropTypeOptions): Promise<void>;
+    createDomain(_name: string, _baseType: string, _options?: CreateDomainOptions): Promise<void>;
+    dropDomain(_name: string, _options?: DropDomainOptions): Promise<void>;
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options: TableOptions & CrateDBTableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+    }): Promise<void>;
+    createPartition(_options: CreatePartitionOptions): Promise<void>;
+    attachPartition(_options: AttachPartitionOptions): Promise<void>;
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    dropPartition(_partitionName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    createForeignDataWrapper(_fdwName: string, _options?: {
+        handler?: string;
+    }): Promise<void>;
+    dropForeignDataWrapper(_fdwName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    createForeignServer(_serverName: string, _fdwName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    dropForeignServer(_serverName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    createForeignTable(_tableName: string, _columns: Record<string, {
+        type: string;
+    }>, _options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    createUserMapping(_userName: string, _serverName: string, _options?: unknown): Promise<void>;
+    dropUserMapping(_userName: string, _serverName: string, _options?: unknown): Promise<void>;
+}
+/**
+ * Create a new CrateDB dialect instance
+ */
+export declare function createCrateDBDialect(options?: CrateDBDialectOptions): CrateDBDialect;
+export default CrateDBDialect;

package/dist/dialects/cratedb/index.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CrateDBDialect = void 0;
 exports.createCrateDBDialect = createCrateDBDialect;
 const postgres_1 = require("../postgres");
+const index_1 = require("../../errors/index");
 /**
  * CrateDB dialect class. Extends the PostgreSQL dialect (PG-wire compatible) and
  * overrides CREATE TABLE generation and type mapping for CrateDB.
@@ -421,6 +422,153 @@ class CrateDBDialect extends postgres_1.PostgresDialect {
         }
         return super.buildInsertQuery(tableName, values, options);
     }
+    // ---------------------------------------------------------------------------
+    // Capability guards for PostgreSQL features CrateDB does NOT implement.
+    //
+    // These methods are inherited from PostgresDialect, which would happily emit
+    // valid *PostgreSQL* DDL (CREATE SEQUENCE, CREATE MATERIALIZED VIEW, CREATE
+    // FUNCTION/PROCEDURE, CREATE TRIGGER, CREATE POLICY / ENABLE ROW LEVEL
+    // SECURITY, CREATE TYPE ... AS ENUM, CREATE DOMAIN, PostgreSQL-style
+    // partitioning, and the Foreign Data Wrapper stack). CrateDB rejects all of
+    // it at execution time with an opaque parser/"not supported" error. Rather
+    // than let callers discover that at runtime through a confusing wire error,
+    // these overrides throw an immediate, typed capability error (DatabaseError)
+    // that names the missing feature and points at CrateDB's supported
+    // alternative where one exists. This keeps the "no silent wrong SQL" contract:
+    // a feature either works through the builder API or fails loudly and clearly.
+    //
+    // @see https://cratedb.com/docs/crate/reference/en/latest/sql/index.html
+    // ---------------------------------------------------------------------------
+    static unsupported(feature, hint) {
+        throw new index_1.DatabaseError(`CrateDB does not support ${feature}.${hint ? ` ${hint}` : ''}`);
+    }
+    // --- Sequences (CrateDB has no sequences / SERIAL; use client-generated keys)
+    async createSequence(_options) {
+        CrateDBDialect.unsupported('sequences', 'CrateDB has no CREATE SEQUENCE / SERIAL; generate keys client-side (e.g. a UUID/TEXT primary key) or use gen_random_text_uuid().');
+    }
+    async dropSequence(_sequenceName, _options) {
+        CrateDBDialect.unsupported('sequences');
+    }
+    async nextSequenceValue(_sequenceName) {
+        CrateDBDialect.unsupported('sequences');
+    }
+    async hasSequence(_sequenceName) {
+        // Non-throwing existence check: CrateDB never has sequences.
+        return false;
+    }
+    // --- Materialized views (unsupported; plain CREATE VIEW works and is inherited)
+    async createMaterializedView(_options) {
+        CrateDBDialect.unsupported('materialized views', 'Use a regular view (createView) — CrateDB has no CREATE MATERIALIZED VIEW.');
+    }
+    async refreshMaterializedView(_viewName, _options) {
+        CrateDBDialect.unsupported('materialized views');
+    }
+    async dropMaterializedView(_viewName, _options) {
+        CrateDBDialect.unsupported('materialized views');
+    }
+    async hasMaterializedView(_viewName) {
+        return false;
+    }
+    async showMaterializedViews() {
+        return [];
+    }
+    // --- Stored procedures / functions (no PL/pgSQL or CREATE FUNCTION/PROCEDURE)
+    async createStoredProcedure(_options) {
+        CrateDBDialect.unsupported('stored procedures or user-defined functions');
+    }
+    async dropStoredProcedure(_procedureName, _options) {
+        CrateDBDialect.unsupported('stored procedures or user-defined functions');
+    }
+    async executeStoredProcedure(_options) {
+        CrateDBDialect.unsupported('stored procedures or user-defined functions');
+    }
+    async hasStoredProcedure(_procedureName, _schema) {
+        return false;
+    }
+    // --- Triggers (unsupported)
+    async createTrigger(_options) {
+        CrateDBDialect.unsupported('triggers');
+    }
+    async dropTrigger(_triggerName, _tableName, _options) {
+        CrateDBDialect.unsupported('triggers');
+    }
+    async hasTrigger(_triggerName, _tableName) {
+        return false;
+    }
+    // --- Row-Level Security (unsupported)
+    async createPolicy(_options) {
+        CrateDBDialect.unsupported('row-level security policies');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        CrateDBDialect.unsupported('row-level security policies');
+    }
+    async enableRLS(_tableName, _schema) {
+        CrateDBDialect.unsupported('row-level security');
+    }
+    async disableRLS(_tableName, _schema) {
+        CrateDBDialect.unsupported('row-level security');
+    }
+    async hasPolicy(_policyName, _tableName) {
+        return false;
+    }
+    // --- Enum types & domains (no CREATE TYPE AS ENUM / CREATE DOMAIN)
+    async createEnumType(_name, _values, _options) {
+        CrateDBDialect.unsupported('enum types', 'Model enumerated values as a TEXT column with a CHECK constraint instead.');
+    }
+    async dropType(_name, _options) {
+        CrateDBDialect.unsupported('user-defined types');
+    }
+    async createDomain(_name, _baseType, _options) {
+        CrateDBDialect.unsupported('domains');
+    }
+    async dropDomain(_name, _options) {
+        CrateDBDialect.unsupported('domains');
+    }
+    // --- PostgreSQL-style declarative partitioning.
+    // CrateDB partitions a table via the `partitionedBy` option on createTable
+    // (`PARTITIONED BY (col)`), NOT via CREATE TABLE ... PARTITION OF / ATTACH /
+    // DETACH PARTITION. The inherited Postgres methods would emit rejected SQL.
+    async createPartitionedTable(tableName, columns, options) {
+        // Emulate through CrateDB's native partitioning: forward the partition
+        // column(s) to `PARTITIONED BY` so callers get a working partitioned table
+        // instead of an error.
+        const partitionedBy = options.partitionBy.column;
+        return this.createTable(tableName, columns, { ...options, partitionedBy });
+    }
+    async createPartition(_options) {
+        CrateDBDialect.unsupported('explicit partition management', 'CrateDB creates partitions automatically from the PARTITIONED BY column value on INSERT.');
+    }
+    async attachPartition(_options) {
+        CrateDBDialect.unsupported('ATTACH PARTITION');
+    }
+    async detachPartition(_options) {
+        CrateDBDialect.unsupported('DETACH PARTITION');
+    }
+    async dropPartition(_partitionName, _options) {
+        CrateDBDialect.unsupported('DROP PARTITION', "Delete the partition's rows instead (DELETE ... WHERE partition_col = value).");
+    }
+    // --- Foreign Data Wrappers (the whole FDW stack is PostgreSQL-only).
+    async createForeignDataWrapper(_fdwName, _options) {
+        CrateDBDialect.unsupported('foreign data wrappers');
+    }
+    async dropForeignDataWrapper(_fdwName, _options) {
+        CrateDBDialect.unsupported('foreign data wrappers');
+    }
+    async createForeignServer(_serverName, _fdwName, _options) {
+        CrateDBDialect.unsupported('foreign servers');
+    }
+    async dropForeignServer(_serverName, _options) {
+        CrateDBDialect.unsupported('foreign servers');
+    }
+    async createForeignTable(_tableName, _columns, _options) {
+        CrateDBDialect.unsupported('foreign tables');
+    }
+    async createUserMapping(_userName, _serverName, _options) {
+        CrateDBDialect.unsupported('foreign data wrapper user mappings');
+    }
+    async dropUserMapping(_userName, _serverName, _options) {
+        CrateDBDialect.unsupported('foreign data wrapper user mappings');
+    }
 }
 exports.CrateDBDialect = CrateDBDialect;
 // ---------------------------------------------------------------------------