ts-prorm-orm 1.1.0

package/dist/dialects/redshift/index.js

@@ -0,0 +1,2277 @@
+"use strict";
+/**
+ * Amazon Redshift dialect implementation for the TypeScript ORM
+ *
+ * Redshift speaks the PostgreSQL wire protocol (it is a fork of Postgres 8.0.2),
+ * so this dialect reuses the `pg` driver exactly like the Postgres dialect and
+ * mirrors much of its query-building behavior. However, Redshift diverges from
+ * Postgres in ways that matter a lot in practice — two gotchas in particular:
+ *
+ * 1. FOREIGN KEY / UNIQUE / PRIMARY KEY constraints are accepted syntactically
+ *    (and stored in the catalog for the query planner / documentation
+ *    purposes) but are **NEVER enforced** at write time. `INSERT`/`UPDATE`
+ *    statements that violate a declared FK or UNIQUE constraint will succeed
+ *    silently. Do not rely on Redshift to guarantee referential integrity or
+ *    uniqueness — enforce that in application code. See the inline comments
+ *    on `getColumnDefinitionSql`, `buildConstraintSql`, `addForeignKey`,
+ *    `createConstraint` below for where this shows up.
+ *
+ * 2. There are no traditional B-tree secondary indexes. Instead, performance
+ *    is governed by table-level `DISTSTYLE`/`DISTKEY` (how rows are
+ *    distributed across compute node slices) and `SORTKEY` (how rows are
+ *    physically ordered on disk, either `COMPOUND` or `INTERLEAVED`). These
+ *    are specified via `RedshiftTableOptions` on `createTable` and emitted
+ *    directly in the `CREATE TABLE` DDL. Methods that would create a
+ *    traditional index (`addIndex`, `createIndex`, `createPartialIndex`, ...)
+ *    throw a clear error pointing callers at DISTKEY/SORTKEY instead.
+ *
+ * Other notable differences from the Postgres dialect:
+ * - Default port is 5439 (not 5432).
+ * - No native JSON/JSONB type before Redshift's semi-structured `SUPER` type;
+ *   `getDataTypeSql` maps both `JSON` and `JSONB` DataTypes to `SUPER`.
+ * - Auto-increment columns use `IDENTITY(seed, step)` rather than
+ *   `SERIAL`/`BIGSERIAL`.
+ * - `MERGE` is only available in Redshift starting ~2023 and `ON CONFLICT`
+ *   has never been supported, so `buildUpsertQuery` does NOT generate
+ *   `INSERT ... ON CONFLICT DO UPDATE` (that would simply fail against a real
+ *   cluster prior to MERGE support, and is not portable). Instead it
+ *   generates AWS's own documented staging-table + `DELETE` + `INSERT`
+ *   pattern. See the comment on `buildUpsertQuery` for the full rationale.
+ * - Bulk loads are normally done via `COPY FROM S3` rather than row-by-row
+ *   `INSERT`. `copyFromS3()` is added as an extra (non-`Dialect`-interface)
+ *   method for that; ordinary `bulkInsert`/`buildInsertQuery` still work via
+ *   plain multi-row `INSERT` for compatibility with the rest of the ORM.
+ * - No triggers, no sequences (`CREATE SEQUENCE`/`nextval`), no row-level
+ *   security policies, and no foreign-data-wrapper support (Redshift uses
+ *   Redshift Spectrum's `CREATE EXTERNAL SCHEMA` for federated/external data
+ *   instead). All of these throw a clear, explanatory `Error`.
+ * - Redshift *does* support views, materialized views (with optional
+ *   `AUTO REFRESH`), and a limited form of stored procedures
+ *   (`CREATE OR REPLACE PROCEDURE ... LANGUAGE plpgsql`), so those are
+ *   implemented much like Postgres.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedshiftTransaction = exports.RedshiftDialect = void 0;
+exports.createRedshiftDialect = createRedshiftDialect;
+const pg_1 = __importDefault(require("pg"));
+const query_stream_helper_1 = require("../query-stream-helper");
+const prorm_1 = require("../../prorm");
+const index_1 = require("../../errors/index");
+const index_2 = require("../../utils/index");
+const operators_1 = require("../../operators");
+const DEFAULT_RETRY_OPTIONS = {
+    max: 3,
+    timeout: 1000,
+    match: [
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ETIMEDOUT',
+        'connection timeout',
+        'connect timeout',
+        'too many connections',
+    ],
+    backoff: false,
+    backoffMultiplier: 2,
+    backoffMax: 10000,
+};
+const DEFAULT_POOL_OPTIONS = {
+    max: 10,
+    min: 0,
+    acquire: 60000,
+    idle: 30000,
+    evict: 1000,
+    handleDisconnects: false,
+    onConnect: undefined,
+    onDisconnect: undefined,
+    enableEvents: false,
+    logPoolOperations: false,
+};
+/**
+ * Amazon Redshift dialect class implementing the Dialect interface.
+ *
+ * See the module-level doc comment above for the two biggest Postgres ->
+ * Redshift surprises: unenforced FK/UNIQUE constraints, and DISTKEY/SORTKEY
+ * replacing B-tree indexes.
+ */
+class RedshiftDialect {
+    constructor(config) {
+        this.name = 'redshift';
+        this.library = 'pg';
+        this.pool = null;
+        this._isConnected = false;
+        this.transactionDepth = 0;
+        this.config = {
+            host: 'localhost',
+            port: 5439,
+            max: 10,
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 2000,
+            ...config,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Connection management
+    // ---------------------------------------------------------------------------
+    async connect() {
+        try {
+            const { Pool: PgPool } = pg_1.default;
+            this.pool = new PgPool({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.username,
+                password: this.config.password,
+                database: this.config.database,
+                max: this.config.max,
+                idleTimeoutMillis: this.config.idleTimeoutMillis,
+                connectionTimeoutMillis: this.config.connectionTimeoutMillis,
+                ssl: this.config.ssl,
+                statement_timeout: this.config.statementTimeout,
+                query_timeout: this.config.queryTimeout,
+            });
+            const client = await this.pool.connect();
+            client.release();
+            this._isConnected = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Redshift database: ${error}`);
+        }
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this._isConnected = false;
+        }
+    }
+    getConnection() {
+        return this.pool;
+    }
+    isConnected() {
+        return this._isConnected && this.pool !== null;
+    }
+    /**
+     * Stream query results by paging through `sql` via repeated
+     * dialect-appropriate LIMIT/OFFSET queries (see
+     * `createPaginatedQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * instead of loading the whole result set into memory at once.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     */
+    queryStream(sql, options) {
+        return (0, query_stream_helper_1.createPaginatedQueryStream)(this, sql, options);
+    }
+    async query(sql, options) {
+        const executeQuery = async () => {
+            if (!this.pool) {
+                throw new Error('Not connected to database');
+            }
+            const isSelect = sql.trim().toUpperCase().startsWith('SELECT') ||
+                sql.trim().toUpperCase().startsWith('WITH') ||
+                sql.trim().toUpperCase().startsWith('SHOW');
+            try {
+                const replacements = options?.replacements ?? options?.bindings;
+                const finalSql = replacements !== undefined ? this.replaceReplacements(sql, replacements) : sql;
+                const result = (await this.pool.query(finalSql));
+                const fieldInfo = result.fields
+                    ? result.fields.map((field) => ({
+                        name: field.name,
+                        type: field.dataTypeID.toString(),
+                        length: field.dataTypeModifier || 0,
+                        tableID: 0,
+                        columnID: 0,
+                        nullable: true,
+                        isEnum: false,
+                        isPrimaryKey: false,
+                    }))
+                    : [];
+                if (isSelect) {
+                    return { rows: result.rows, rowCount: result.rowCount || result.rows.length, fields: fieldInfo };
+                }
+                const rowCount = result.rowCount || 0;
+                if (result.rows && result.rows.length > 0) {
+                    return { rows: result.rows, rowCount: result.rows.length, fields: fieldInfo };
+                }
+                return { rows: [], rowCount, fields: fieldInfo };
+            }
+            catch (error) {
+                throw new Error(`Redshift Query error: ${error}`);
+            }
+        };
+        const retryOptions = options?.retry;
+        if (retryOptions) {
+            const effectiveRetry = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions, match: retryOptions.match || DEFAULT_RETRY_OPTIONS.match };
+            return this.executeWithRetry(executeQuery, effectiveRetry);
+        }
+        return executeQuery();
+    }
+    async executeWithRetry(fn, retryOptions) {
+        let lastError;
+        for (let attempt = 0; attempt <= retryOptions.max; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const shouldRetry = retryOptions.match.some((p) => lastError.message.toLowerCase().includes(p.toLowerCase()));
+                if (!shouldRetry || attempt === retryOptions.max)
+                    throw lastError;
+                await new Promise((resolve) => setTimeout(resolve, retryOptions.timeout));
+            }
+        }
+        throw lastError;
+    }
+    // ---------------------------------------------------------------------------
+    // Escaping / identifiers
+    // ---------------------------------------------------------------------------
+    escape(value) {
+        if (value instanceof prorm_1.Literal)
+            return value.val;
+        if (value === null || value === undefined)
+            return 'NULL';
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value ? 'TRUE' : 'FALSE';
+        if (value instanceof Date)
+            return `'${this.formatDate(value)}'`;
+        if (Buffer.isBuffer(value))
+            return `'${value.toString('hex')}'`;
+        if (Array.isArray(value)) {
+            // Redshift's SUPER type accepts JSON literals directly.
+            return `JSON_PARSE('${this.escapeString(JSON.stringify(value))}')`;
+        }
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    escapeString(str) {
+        return str.replace(/'/g, "''").replace(/\\/g, '\\\\');
+    }
+    formatDate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    }
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    quoteIdentifier(identifier) {
+        return this.escapeId(identifier);
+    }
+    quoteTable(tableName, schema) {
+        if (schema && schema !== 'public') {
+            return `${this.escapeId(schema)}.${this.escapeId(tableName)}`;
+        }
+        return this.escapeId(tableName);
+    }
+    async getDatabaseVersion() {
+        const result = await this.query('SELECT version() as version');
+        return result.rows[0]?.version || 'Unknown';
+    }
+    // ---------------------------------------------------------------------------
+    // Schemas / database DDL
+    // ---------------------------------------------------------------------------
+    async createSchema(schema) {
+        await this.query(`CREATE SCHEMA ${this.escapeId(schema)}`);
+    }
+    async dropSchema(schema, options) {
+        let sql = 'DROP SCHEMA';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(schema)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async showAllSchemas() {
+        const result = await this.query(`SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('pg_catalog', 'information_schema') ORDER BY schema_name`);
+        return result.rows?.map((row) => row.schema_name) || [];
+    }
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    createDatabaseSQL(options) {
+        return `CREATE DATABASE ${this.quoteIdentifier(options.name)}`;
+    }
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE ${this.quoteIdentifier(name)}`;
+    }
+    createSavepointSQL(name) {
+        return `SAVEPOINT ${name || `sp_${Date.now()}`}`;
+    }
+    releaseSavepointSQL(name) {
+        return `RELEASE SAVEPOINT ${name}`;
+    }
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TO SAVEPOINT ${name}`;
+    }
+    // ---------------------------------------------------------------------------
+    // Extensions - Redshift has no CREATE EXTENSION mechanism.
+    // ---------------------------------------------------------------------------
+    async createExtension(_extensionName, _options) {
+        throw new index_1.DatabaseError('Extensions are not supported by Redshift. This is a PostgreSQL-specific feature.');
+    }
+    async dropExtension(_extensionName, _options) {
+        throw new index_1.DatabaseError('Extensions are not supported by Redshift. This is a PostgreSQL-specific feature.');
+    }
+    async getExtensions() {
+        throw new index_1.DatabaseError('Extensions are not supported by Redshift. This is a PostgreSQL-specific feature.');
+    }
+    async hasExtension(_extensionName) {
+        throw new index_1.DatabaseError('Extensions are not supported by Redshift. This is a PostgreSQL-specific feature.');
+    }
+    // ---------------------------------------------------------------------------
+    // Tables
+    // ---------------------------------------------------------------------------
+    /**
+     * Create a table.
+     *
+     * Emits Redshift's DISTSTYLE/DISTKEY/SORTKEY table-level clauses (the
+     * replacement for traditional B-tree indexes) when present on `options`.
+     *
+     * FOREIGN KEY / UNIQUE / PRIMARY KEY constraints given via `options.constraints`
+     * are still emitted as DDL — Redshift's parser accepts the syntax and stores
+     * it in the catalog for the query planner and for documentation/ERD tooling
+     * — but NONE of them are enforced at write time. Do not rely on this DDL for
+     * actual data integrity guarantees.
+     */
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.getColumnDefinitionSql(columnName, definition));
+        }
+        // Constraint DDL is accepted but NOT enforced by Redshift (see class doc comment).
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql)
+                    columnDefs.push(constraintSql);
+            }
+        }
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists)
+            sql += ' IF NOT EXISTS';
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // ---- DISTSTYLE / DISTKEY / SORTKEY: Redshift's replacement for indexes ----
+        if (options?.diststyle) {
+            sql += ` DISTSTYLE ${options.diststyle}`;
+        }
+        if (options?.distKey) {
+            sql += ` DISTKEY (${this.escapeId(options.distKey)})`;
+        }
+        if (options?.sortKey) {
+            const sortKeyType = options.sortkeyType || 'COMPOUND';
+            const sortCols = Array.isArray(options.sortKey) ? options.sortKey : [options.sortKey];
+            sql += ` ${sortKeyType} SORTKEY (${sortCols.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        if (options?.engine) {
+            console.warn(`Redshift: engine option '${options.engine}' is not supported and will be ignored`);
+        }
+        if (options?.charset) {
+            console.warn(`Redshift: charset option '${options.charset}' is not supported and will be ignored`);
+        }
+        if (options?.rowFormat) {
+            console.warn(`Redshift: rowFormat option '${options.rowFormat}' is not supported and will be ignored`);
+        }
+        await this.query(sql);
+        if (options?.uniqueKeys) {
+            // Also unenforced in Redshift - see class doc comment.
+            if (Array.isArray(options.uniqueKeys)) {
+                for (const uk of options.uniqueKeys) {
+                    const constraintName = uk.name || `${tableName}_${uk.fields.join('_')}_key`;
+                    await this.query(`ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} UNIQUE (${uk.fields.map((f) => this.escapeId(f)).join(', ')})`);
+                }
+            }
+            else {
+                for (const [keyName, fields] of Object.entries(options.uniqueKeys)) {
+                    const constraintName = keyName || `${tableName}_${fields.join('_')}_key`;
+                    await this.query(`ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} UNIQUE (${fields.map((f) => this.escapeId(f)).join(', ')})`);
+                }
+            }
+        }
+        if (options?.comment) {
+            await this.commentTable(tableName, options.comment);
+        }
+        if (options?.indexes && options.indexes.length > 0) {
+            // Redshift has no CREATE INDEX at all; fail loudly instead of silently
+            // ignoring a request the caller probably expects to matter.
+            throw new index_1.DatabaseError('Redshift does not support secondary indexes. Use the distKey/sortKey/diststyle table options instead of options.indexes.');
+        }
+    }
+    /**
+     * Build constraint SQL for table creation.
+     *
+     * NOTE: Redshift accepts PRIMARY KEY / UNIQUE / FOREIGN KEY DDL but never
+     * enforces any of it. CHECK constraints are not supported at all by
+     * Redshift and will throw.
+     */
+    buildConstraintSql(constraint) {
+        const name = constraint.name ? this.escapeId(constraint.name) : '';
+        const fields = constraint.fields?.map((f) => this.escapeId(f)).join(', ') || '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `${name ? name + ' ' : ''}PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${name ? name + ' ' : ''}UNIQUE (${fields})`;
+            case 'FOREIGN KEY': {
+                if (!constraint.references)
+                    return null;
+                const refField = constraint.references.field;
+                const refFieldSql = Array.isArray(refField)
+                    ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                    : `(${this.escapeId(refField)})`;
+                // Accepted-but-unenforced: Redshift stores this for the query planner only.
+                let fkSql = `${name ? name + ' ' : ''}FOREIGN KEY (${fields}) `;
+                fkSql += `REFERENCES ${this.escapeId(constraint.references.table)}${refFieldSql}`;
+                return fkSql;
+            }
+            case 'CHECK':
+                throw new index_1.DatabaseError('Redshift does not support CHECK constraints');
+            default:
+                return null;
+        }
+    }
+    /**
+     * Generate column definition SQL.
+     *
+     * Auto-increment columns use Redshift's `IDENTITY(seed, step)` clause
+     * instead of Postgres's `SERIAL`/`BIGSERIAL` (Redshift has no SERIAL type
+     * and no sequence objects backing it).
+     *
+     * Also emits Redshift's column-level `ENCODE <type>` compression clause
+     * (e.g. `ENCODE AZ64`, `ENCODE ZSTD`, `ENCODE BYTEDICT`, ...) immediately
+     * after the data type when `definition.encode` (see `RedshiftColumnDefinition`)
+     * is set. This is a perf-critical, Redshift-specific storage option with no
+     * Postgres equivalent.
+     */
+    getColumnDefinitionSql(columnName, definition) {
+        const dt = definition.type;
+        if (definition.autoIncrement) {
+            // Redshift's IDENTITY clause can be attached to SMALLINT/INT2, INTEGER/INT4,
+            // and BIGINT/INT8 columns; each keeps its own storage width and value range,
+            // so a SMALLINT autoIncrement column must stay SMALLINT IDENTITY rather than
+            // silently widening to INTEGER.
+            const identityBaseTypes = {
+                SMALLINT: 'SMALLINT',
+                INT2: 'SMALLINT',
+                INTEGER: 'INTEGER',
+                INT: 'INTEGER',
+                INT4: 'INTEGER',
+                BIGINT: 'BIGINT',
+                INT8: 'BIGINT',
+            };
+            const baseType = identityBaseTypes[String(dt?.key)] ?? 'INTEGER';
+            const identityOpts = definition.identity;
+            const seed = identityOpts?.seed ?? 1;
+            const step = identityOpts?.step ?? 1;
+            let sql = `${this.escapeId(columnName)} ${baseType} IDENTITY(${seed}, ${step})`;
+            if (definition.encode)
+                sql += ` ENCODE ${definition.encode}`;
+            if (definition.primaryKey)
+                sql += ' PRIMARY KEY';
+            if (definition.allowNull === false)
+                sql += ' NOT NULL';
+            if (definition.unique)
+                sql += ' UNIQUE'; // unenforced - see class doc comment
+            if (definition.references) {
+                const refField = definition.references.field;
+                const refFieldSql = Array.isArray(refField)
+                    ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                    : this.escapeId(refField);
+                // Accepted-but-unenforced FK reference.
+                sql += ` REFERENCES ${this.escapeId(definition.references.table)}(${refFieldSql})`;
+            }
+            return sql;
+        }
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.encode)
+            sql += ` ENCODE ${definition.encode}`;
+        if (definition.allowNull === false)
+            sql += ' NOT NULL';
+        if (definition.defaultValue !== undefined)
+            sql += ` DEFAULT ${this.getDefaultValue(definition.defaultValue)}`;
+        if (definition.primaryKey)
+            sql += ' PRIMARY KEY'; // unenforced by Redshift
+        if (definition.unique) {
+            // unenforced by Redshift - accepted for documentation/planner purposes only
+            sql += typeof definition.unique === 'string' ? ` UNIQUE (${this.escapeId(definition.unique)})` : ' UNIQUE';
+        }
+        if (definition.references) {
+            const refField = definition.references.field;
+            const refFieldSql = Array.isArray(refField)
+                ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                : this.escapeId(refField);
+            // Accepted-but-unenforced FK reference (see class doc comment).
+            sql += ` REFERENCES ${this.escapeId(definition.references.table)}(${refFieldSql})`;
+        }
+        return sql;
+    }
+    getDefaultValue(value) {
+        if (value === null)
+            return 'NULL';
+        if (typeof value === 'string') {
+            if (value.toUpperCase().includes('CURRENT_') || value.toUpperCase() === 'NULL')
+                return value;
+            return `'${this.escapeString(value)}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (value instanceof Date)
+            return `'${this.formatDate(value)}'`;
+        if (typeof value === 'object' && value !== null && typeof value.toDefaultValue === 'function') {
+            return value.toDefaultValue();
+        }
+        return `'${this.escapeString(String(value))}'`;
+    }
+    async dropTable(tableName, options) {
+        let sql = 'DROP TABLE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(tableName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Native table partitioning - Redshift has no declarative partitioning.
+    // Use DISTKEY/SORTKEY for the equivalent performance tuning instead.
+    // ---------------------------------------------------------------------------
+    async createPartitionedTable() {
+        throw new index_1.DatabaseError('Redshift does not support declarative table partitioning. Use the distKey/sortKey/diststyle table options instead.');
+    }
+    async createPartition(_options) {
+        throw new index_1.DatabaseError('Redshift does not support table partitions.');
+    }
+    async attachPartition(_options) {
+        throw new index_1.DatabaseError('Redshift does not support table partitions.');
+    }
+    async detachPartition(_options) {
+        throw new index_1.DatabaseError('Redshift does not support table partitions.');
+    }
+    async dropPartition(_partitionName, _options) {
+        throw new index_1.DatabaseError('Redshift does not support table partitions.');
+    }
+    // ---------------------------------------------------------------------------
+    // Views
+    // ---------------------------------------------------------------------------
+    async createView(viewName, query, options) {
+        const viewNameWithSchema = options?.schema ? `${this.escapeId(options.schema)}.${this.escapeId(viewName)}` : this.escapeId(viewName);
+        let sql = options?.replace ? 'CREATE OR REPLACE VIEW' : 'CREATE VIEW';
+        sql += ` ${viewNameWithSchema} AS ${query}`;
+        await this.query(sql);
+        if (options?.comment) {
+            await this.query(`COMMENT ON VIEW ${viewNameWithSchema} IS ${this.escape(options.comment)}`);
+        }
+    }
+    async dropView(viewName, options) {
+        let sql = 'DROP VIEW';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(viewName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async showViews() {
+        const result = await this.query(`SELECT table_name FROM information_schema.views WHERE table_schema = 'public' ORDER BY table_name`);
+        return result.rows?.map((row) => row.table_name) || [];
+    }
+    // ---------------------------------------------------------------------------
+    // Materialized views - supported natively by Redshift (with optional AUTO
+    // REFRESH, BACKUP NO, and DISTKEY/SORTKEY on the view's result table).
+    // ---------------------------------------------------------------------------
+    async createMaterializedView(options) {
+        const viewNameWithSchema = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.name)}`
+            : this.escapeId(options.name);
+        let sql = 'CREATE MATERIALIZED VIEW';
+        if (options.ifNotExists)
+            sql = 'CREATE MATERIALIZED VIEW IF NOT EXISTS';
+        sql += ` ${viewNameWithSchema}`;
+        if (options.backup === false) {
+            sql += ' BACKUP NO';
+        }
+        if (options.diststyle) {
+            sql += ` DISTSTYLE ${options.diststyle}`;
+        }
+        if (options.distKey) {
+            sql += ` DISTKEY (${this.escapeId(options.distKey)})`;
+        }
+        if (options.sortKey) {
+            const sortKeyType = options.sortkeyType || 'COMPOUND';
+            const sortCols = Array.isArray(options.sortKey) ? options.sortKey : [options.sortKey];
+            sql += ` ${sortKeyType} SORTKEY (${sortCols.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        if (options.autoRefresh) {
+            sql += ' AUTO REFRESH YES';
+        }
+        sql += ` AS ${options.query}`;
+        await this.query(sql);
+    }
+    async refreshMaterializedView(viewName, _options) {
+        await this.query(`REFRESH MATERIALIZED VIEW ${this.escapeId(viewName)}`);
+    }
+    /**
+     * Toggle Redshift's `AUTO REFRESH` mode on an existing materialized view
+     * after creation, via `ALTER MATERIALIZED VIEW ... AUTO REFRESH YES|NO`.
+     * This is distinct from `refreshMaterializedView`, which performs a single
+     * manual blocking refresh; this method instead changes whether Redshift
+     * automatically re-refreshes the view in the background going forward.
+     */
+    async setMaterializedViewAutoRefresh(viewName, autoRefresh) {
+        await this.query(`ALTER MATERIALIZED VIEW ${this.escapeId(viewName)} AUTO REFRESH ${autoRefresh ? 'YES' : 'NO'}`);
+    }
+    async dropMaterializedView(viewName, options) {
+        let sql = 'DROP MATERIALIZED VIEW';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(viewName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async hasMaterializedView(viewName) {
+        const result = await this.query(`SELECT 1 FROM pg_matviews WHERE matviewname = ${this.escape(viewName)}`);
+        return (result.rows?.length ?? 0) > 0;
+    }
+    async showMaterializedViews() {
+        const result = await this.query(`SELECT matviewname FROM pg_matviews WHERE schemaname = 'public' ORDER BY matviewname`);
+        return result.rows?.map((row) => row.matviewname) || [];
+    }
+    // ---------------------------------------------------------------------------
+    // Columns
+    // ---------------------------------------------------------------------------
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    async removeColumn(tableName, columnName) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)}`);
+    }
+    /**
+     * Change a column's type. Note: Redshift's ALTER COLUMN TYPE support is far
+     * more limited than Postgres's — it generally only allows widening VARCHAR
+     * lengths and a handful of numeric-type widenings, not arbitrary type
+     * changes. The SQL is still emitted here; Redshift itself will reject
+     * unsupported conversions.
+     */
+    async changeColumn(tableName, columnName, definition) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} TYPE ${this.getDataTypeSql(definition.type)}`);
+        if (definition.allowNull === false) {
+            await this.query(`ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} SET NOT NULL`);
+        }
+        else if (definition.allowNull === true) {
+            await this.query(`ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} DROP NOT NULL`);
+        }
+    }
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldColumnName)} TO ${this.escapeId(newColumnName)}`);
+    }
+    /**
+     * Add a foreign key to a table.
+     *
+     * IMPORTANT: Redshift accepts this DDL and records it in the catalog, but
+     * NEVER enforces it. Inserts/updates that violate the relationship will
+     * succeed. See class doc comment.
+     */
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        const constraintName = options?.name || `${tableName}_${columnName}_fkey`;
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)}(${this.escapeId(referencedColumnName)})`;
+        await this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Bulk insert - plain multi-row INSERT for ORM/CRUD compatibility.
+    // For real bulk loads, use copyFromS3() instead (see class doc comment).
+    // ---------------------------------------------------------------------------
+    async bulkInsert(tableName, records, _options) {
+        if (records.length === 0)
+            return { rows: [], rowCount: 0, fields: [] };
+        const values = [];
+        const placeholders = [];
+        const columns = Object.keys(records[0]);
+        for (const record of records) {
+            const rowPlaceholders = [];
+            for (let i = 0; i < columns.length; i++) {
+                rowPlaceholders.push(`$${values.length + i + 1}`);
+                values.push(record[columns[i]]);
+            }
+            placeholders.push(`(${rowPlaceholders.join(', ')})`);
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES ${placeholders.join(', ')}`;
+        return this.query(sql, { replacements: values });
+    }
+    /**
+     * Bulk-load data into a table from Amazon S3 using Redshift's `COPY`
+     * command. This is NOT part of the `Dialect` interface (it's Redshift-
+     * specific) — it's an addition on top of the standard CRUD surface, which
+     * still works via plain `INSERT` through `bulkInsert`/`buildInsertQuery`.
+     *
+     * Authentication is via either an IAM role ARN (recommended) or static
+     * credentials — exactly one of `options.iamRole` / `options.credentials`
+     * must be supplied.
+     */
+    async copyFromS3(tableName, s3Path, options) {
+        if (!options?.iamRole && !options?.credentials) {
+            throw new index_1.DatabaseError('copyFromS3 requires either options.iamRole or options.credentials');
+        }
+        if (options.iamRole && options.credentials) {
+            throw new index_1.DatabaseError('copyFromS3 accepts either options.iamRole or options.credentials, not both');
+        }
+        let sql = `COPY ${this.quoteTable(tableName)} FROM '${this.escapeString(s3Path)}'`;
+        if (options.iamRole) {
+            sql += ` IAM_ROLE '${this.escapeString(options.iamRole)}'`;
+        }
+        else if (options.credentials) {
+            const { accessKeyId, secretAccessKey, sessionToken } = options.credentials;
+            let creds = `aws_access_key_id=${accessKeyId};aws_secret_access_key=${secretAccessKey}`;
+            if (sessionToken)
+                creds += `;token=${sessionToken}`;
+            sql += ` CREDENTIALS '${this.escapeString(creds)}'`;
+        }
+        const format = options.format || 'CSV';
+        switch (format) {
+            case 'CSV':
+                sql += ' FORMAT AS CSV';
+                if (options.delimiter)
+                    sql += ` DELIMITER '${options.delimiter}'`;
+                if (options.ignoreHeader)
+                    sql += ` IGNOREHEADER ${options.ignoreHeader}`;
+                break;
+            case 'JSON':
+                sql += ` FORMAT AS JSON '${options.jsonOption || 'auto'}'`;
+                break;
+            case 'PARQUET':
+                sql += ' FORMAT AS PARQUET';
+                break;
+            case 'AVRO':
+                sql += ` FORMAT AS AVRO '${options.jsonOption || 'auto'}'`;
+                break;
+            case 'ORC':
+                sql += ' FORMAT AS ORC';
+                break;
+        }
+        if (options.compression)
+            sql += ` ${options.compression}`;
+        if (options.region)
+            sql += ` REGION '${options.region}'`;
+        if (options.maxError !== undefined)
+            sql += ` MAXERROR ${options.maxError}`;
+        if (options.extra)
+            sql += ` ${options.extra}`;
+        return this.query(sql);
+    }
+    /**
+     * Bulk-export the result of a query to Amazon S3 using Redshift's `UNLOAD`
+     * command — the write-side counterpart to `copyFromS3`. Like `copyFromS3`,
+     * this is NOT part of the `Dialect` interface (it's Redshift-specific).
+     *
+     * Authentication is via either an IAM role ARN (recommended) or static
+     * credentials — exactly one of `options.iamRole` / `options.credentials`
+     * must be supplied.
+     *
+     * Builds: `UNLOAD ('<query>') TO 's3://...' IAM_ROLE '...' [FORMAT AS
+     * PARQUET|CSV|JSON] [DELIMITER ...] [PARALLEL ON|OFF] [MANIFEST] ...`
+     */
+    async unloadToS3(query, s3Path, options) {
+        if (!options?.iamRole && !options?.credentials) {
+            throw new index_1.DatabaseError('unloadToS3 requires either options.iamRole or options.credentials');
+        }
+        if (options.iamRole && options.credentials) {
+            throw new index_1.DatabaseError('unloadToS3 accepts either options.iamRole or options.credentials, not both');
+        }
+        let sql = `UNLOAD ('${this.escapeString(query)}') TO '${this.escapeString(s3Path)}'`;
+        if (options.iamRole) {
+            sql += ` IAM_ROLE '${this.escapeString(options.iamRole)}'`;
+        }
+        else if (options.credentials) {
+            const { accessKeyId, secretAccessKey, sessionToken } = options.credentials;
+            let creds = `aws_access_key_id=${accessKeyId};aws_secret_access_key=${secretAccessKey}`;
+            if (sessionToken)
+                creds += `;token=${sessionToken}`;
+            sql += ` CREDENTIALS '${this.escapeString(creds)}'`;
+        }
+        if (options.format === 'PARQUET') {
+            sql += ' FORMAT AS PARQUET';
+        }
+        else if (options.format === 'JSON') {
+            sql += ' FORMAT AS JSON';
+        }
+        else if (options.format === 'CSV') {
+            sql += ' FORMAT AS CSV';
+        }
+        if (options.delimiter)
+            sql += ` DELIMITER '${options.delimiter}'`;
+        if (options.header)
+            sql += ' HEADER';
+        if (options.compression)
+            sql += ` ${options.compression}`;
+        if (options.manifest)
+            sql += ' MANIFEST';
+        if (options.allowOverwrite)
+            sql += ' ALLOWOVERWRITE';
+        if (options.parallel !== undefined)
+            sql += ` PARALLEL ${options.parallel ? 'ON' : 'OFF'}`;
+        if (options.maxFileSize)
+            sql += ` MAXFILESIZE ${options.maxFileSize}`;
+        if (options.region)
+            sql += ` REGION '${options.region}'`;
+        if (options.extra)
+            sql += ` ${options.extra}`;
+        return this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Datashares (AWS Data Sharing) - not part of the `Dialect` interface, these
+    // are Redshift-specific escape hatches like `copyFromS3`/`unloadToS3` above.
+    //
+    // See https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATASHARE.html
+    // and related CREATE/ALTER/DROP DATASHARE, GRANT, and CREATE DATABASE
+    // reference pages. Unlike most Redshift DDL, CREATE/DROP DATASHARE do NOT
+    // support `IF NOT EXISTS`/`IF EXISTS` clauses - that's a deliberate
+    // omission here, not an oversight.
+    // ---------------------------------------------------------------------------
+    /**
+     * `CREATE DATASHARE datashare_name [SET PUBLICACCESSIBLE TRUE|FALSE]`
+     *
+     * Creates a new datashare in the current database, owned by the issuing
+     * user. Adding objects to it is a separate step - see
+     * `alterDatashareAddSchema`/`alterDatashareAddTable`.
+     */
+    async createDatashare(name, options) {
+        let sql = `CREATE DATASHARE ${this.escapeId(name)}`;
+        if (options?.publiclyAccessible !== undefined) {
+            sql += ` SET PUBLICACCESSIBLE ${options.publiclyAccessible ? 'TRUE' : 'FALSE'}`;
+        }
+        return this.query(sql);
+    }
+    /**
+     * `DROP DATASHARE datashare_name`
+     *
+     * Irreversible. Only a superuser or the datashare owner can run this.
+     */
+    async dropDatashare(name) {
+        return this.query(`DROP DATASHARE ${this.escapeId(name)}`);
+    }
+    /**
+     * `ALTER DATASHARE datashare_name ADD SCHEMA schema`
+     *
+     * Adding a schema does NOT add the objects inside it - each table still
+     * needs to be added explicitly via `alterDatashareAddTable`.
+     */
+    async alterDatashareAddSchema(datashareName, schemaName) {
+        return this.query(`ALTER DATASHARE ${this.escapeId(datashareName)} ADD SCHEMA ${this.escapeId(schemaName)}`);
+    }
+    /**
+     * `ALTER DATASHARE datashare_name ADD TABLE schema.table`
+     *
+     * The schema must already have been added to the datashare (via
+     * `alterDatashareAddSchema`) before tables within it can be added.
+     */
+    async alterDatashareAddTable(datashareName, schemaName, tableName) {
+        return this.query(`ALTER DATASHARE ${this.escapeId(datashareName)} ADD TABLE ${this.escapeId(schemaName)}.${this.escapeId(tableName)}`);
+    }
+    /**
+     * `GRANT USAGE ON DATASHARE datashare_name TO NAMESPACE 'guid' | ACCOUNT 'accountnumber' [VIA DATA CATALOG]`
+     *
+     * Grants a consumer (another namespace in the same account, or an entire
+     * other AWS account) read-only access to the datashare. The caller must
+     * already have been granted the `SHARE` permission on the datashare (via
+     * `GRANT SHARE ON DATASHARE ... TO ...`) unless they're the owner/superuser.
+     */
+    async grantDatashareUsage(datashareName, target) {
+        let sql = `GRANT USAGE ON DATASHARE ${this.escapeId(datashareName)} TO `;
+        if ('namespace' in target) {
+            sql += `NAMESPACE '${this.escapeString(target.namespace)}'`;
+        }
+        else {
+            sql += `ACCOUNT '${this.escapeString(target.account)}'`;
+            if (target.viaDataCatalog)
+                sql += ' VIA DATA CATALOG';
+        }
+        return this.query(sql);
+    }
+    /**
+     * Consumer-side: `CREATE DATABASE db_name [WITH PERMISSIONS] FROM DATASHARE
+     * datashare_name OF [ACCOUNT account_id] NAMESPACE namespace_guid`
+     *
+     * Creates a local database backed by a datashare a producer has granted
+     * this cluster/namespace `USAGE` on. Only one consumer database can be
+     * created per datashare on a given cluster.
+     */
+    async createDatabaseFromDatashare(dbName, datashareName, fromNamespace, options) {
+        let sql = `CREATE DATABASE ${this.escapeId(dbName)}`;
+        if (options?.withPermissions)
+            sql += ' WITH PERMISSIONS';
+        sql += ` FROM DATASHARE ${this.escapeId(datashareName)} OF`;
+        if (options?.account)
+            sql += ` ACCOUNT '${this.escapeString(options.account)}'`;
+        sql += ` NAMESPACE '${this.escapeString(fromNamespace)}'`;
+        return this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Federated query to Amazon RDS/Aurora (PostgreSQL/MySQL) - distinct from
+    // Redshift Spectrum's S3/data-catalog `CREATE EXTERNAL SCHEMA FROM DATA
+    // CATALOG|HIVE METASTORE`. Federated query connects live to an OLTP
+    // database rather than reading files, and uses its own `FROM POSTGRES` /
+    // `FROM MYSQL` syntax. Not part of the `Dialect` interface.
+    //
+    // See https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html
+    // ---------------------------------------------------------------------------
+    /**
+     * `CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name FROM POSTGRES|MYSQL
+     * DATABASE 'db' [SCHEMA 'schema'] URI 'host' [PORT n] IAM_ROLE 'role'
+     * SECRET_ARN 'arn'`
+     *
+     * `options.schema` is only valid (and only emitted) for `POSTGRES` -
+     * Redshift federated queries to MySQL don't support a separate schema
+     * namespace.
+     */
+    async createExternalSchemaFederated(schemaName, options) {
+        if (options.engine === 'MYSQL' && options.schema) {
+            throw new index_1.DatabaseError('createExternalSchemaFederated: options.schema is not supported for federated queries to MySQL ' +
+                '(SCHEMA is only valid for FROM POSTGRES). Omit options.schema for MySQL.');
+        }
+        let sql = `CREATE EXTERNAL SCHEMA${options.ifNotExists ? ' IF NOT EXISTS' : ''} ${this.escapeId(schemaName)}`;
+        sql += ` FROM ${options.engine}`;
+        sql += ` DATABASE '${this.escapeString(options.database)}'`;
+        if (options.engine === 'POSTGRES' && options.schema) {
+            sql += ` SCHEMA '${this.escapeString(options.schema)}'`;
+        }
+        sql += ` URI '${this.escapeString(options.uri)}'`;
+        if (options.port !== undefined)
+            sql += ` PORT ${options.port}`;
+        sql += ` IAM_ROLE '${this.escapeString(options.iamRole)}'`;
+        sql += ` SECRET_ARN '${this.escapeString(options.secretArn)}'`;
+        return this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Introspection
+    // ---------------------------------------------------------------------------
+    async showTables() {
+        const result = await this.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'`);
+        return result.rows.map((row) => row.table_name);
+    }
+    /**
+     * Show constraints for a table. Remember: any FK/UNIQUE/PK rows returned
+     * here describe DECLARED, not ENFORCED, constraints in Redshift.
+     */
+    async showConstraints(tableName) {
+        const sql = `
+      SELECT
+        tc.constraint_name,
+        tc.table_name,
+        kcu.column_name,
+        tc.constraint_type
+      FROM information_schema.table_constraints AS tc
+      LEFT JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+      WHERE tc.table_name = $1
+    `;
+        const result = await this.query(sql, { replacements: [tableName] });
+        return result.rows;
+    }
+    /**
+     * Add a constraint. NOTE: Redshift accepts PRIMARY KEY/UNIQUE/FOREIGN KEY
+     * here but never enforces them (see class doc comment). CHECK constraints
+     * are rejected outright since Redshift has no CHECK constraint support.
+     */
+    async addConstraint(tableName, options) {
+        if (options.type === 'CHECK') {
+            throw new index_1.DatabaseError('Redshift does not support CHECK constraints');
+        }
+        const constraintName = options.name || `${tableName}_${options.fields.join('_')}_${options.type.toLowerCase().replace(/\s+/g, '_')}`;
+        const fieldsSql = options.fields.map((f) => this.escapeId(f)).join(', ');
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} `;
+        switch (options.type) {
+            case 'UNIQUE':
+                sql += `UNIQUE (${fieldsSql})`;
+                break;
+            case 'PRIMARY KEY':
+                sql += `PRIMARY KEY (${fieldsSql})`;
+                break;
+            case 'FOREIGN KEY':
+                sql += `FOREIGN KEY (${fieldsSql}) REFERENCES ${this.escapeId(options.references.table)} (${options.references.fields.map((f) => this.escapeId(f)).join(', ')})`;
+                break;
+        }
+        await this.query(sql);
+    }
+    async removeConstraint(tableName, constraintName) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} DROP CONSTRAINT ${this.escapeId(constraintName)}`);
+    }
+    async createConstraint(tableName, constraintDef) {
+        if (constraintDef.type === 'CHECK') {
+            throw new index_1.DatabaseError('Redshift does not support CHECK constraints');
+        }
+        await this.addConstraint(tableName, {
+            type: constraintDef.type,
+            fields: constraintDef.fields || [],
+            name: constraintDef.name,
+            references: constraintDef.references
+                ? { table: constraintDef.references.table, fields: [constraintDef.references.field] }
+                : undefined,
+        });
+    }
+    async dropConstraint(tableName, constraintName, options) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} DROP CONSTRAINT`;
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(constraintName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async describeTable(tableName) {
+        const sql = `
+      SELECT column_name, data_type, is_nullable, column_default, character_maximum_length
+      FROM information_schema.columns
+      WHERE table_name = $1 AND table_schema = 'public'
+    `;
+        const result = await this.query(sql, { replacements: [tableName] });
+        const description = {};
+        for (const row of result.rows) {
+            const rowData = row;
+            const columnName = rowData.column_name;
+            let type = rowData.data_type;
+            if (rowData.character_maximum_length)
+                type += `(${rowData.character_maximum_length})`;
+            const isIdentity = rowData.column_default?.toString().toLowerCase().includes('identity');
+            description[columnName] = {
+                type,
+                allowNull: rowData.is_nullable === 'YES',
+                defaultValue: rowData.column_default,
+                primaryKey: false,
+                autoIncrement: !!isIdentity,
+            };
+        }
+        return description;
+    }
+    async renameTable(oldName, newName) {
+        await this.query(`ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)}`);
+    }
+    async changeOwner(newOwner, tableName) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} OWNER TO ${this.escapeId(newOwner)}`);
+    }
+    // ---------------------------------------------------------------------------
+    // Indexes - Redshift has no traditional B-tree secondary indexes at all.
+    // Use DISTKEY/SORTKEY table options (createTable) instead.
+    // ---------------------------------------------------------------------------
+    noIndexSupport() {
+        throw new index_1.DatabaseError('Redshift has no traditional secondary indexes. Use DISTKEY/SORTKEY/DISTSTYLE table options (see RedshiftTableOptions on createTable) instead of CREATE INDEX.');
+    }
+    async showIndexes(_tableName) {
+        this.noIndexSupport();
+    }
+    async addIndex(_tableName, _indexName, _fields, _options) {
+        this.noIndexSupport();
+    }
+    async removeIndex(_tableName, _indexName) {
+        this.noIndexSupport();
+    }
+    async createIndex(_tableName, _indexDef) {
+        this.noIndexSupport();
+    }
+    async dropIndex(_tableName, _indexName, _options) {
+        this.noIndexSupport();
+    }
+    async createFulltextIndex() {
+        this.noIndexSupport();
+    }
+    async createSpatialIndex() {
+        this.noIndexSupport();
+    }
+    async createPartialIndex() {
+        this.noIndexSupport();
+    }
+    async createExpressionIndex() {
+        this.noIndexSupport();
+    }
+    // ---------------------------------------------------------------------------
+    // Foreign Data Wrappers - Redshift uses Redshift Spectrum external schemas
+    // (CREATE EXTERNAL SCHEMA ... FROM DATA CATALOG / HIVE METASTORE) instead of
+    // Postgres-style FDWs, so all of these throw with guidance.
+    // ---------------------------------------------------------------------------
+    noFdwSupport() {
+        throw new index_1.DatabaseError('Foreign Data Wrappers are not supported by Redshift. This is a PostgreSQL-specific feature. ' +
+            'Use Redshift Spectrum external schemas (CREATE EXTERNAL SCHEMA) for federated/external data access instead.');
+    }
+    async createForeignDataWrapper() {
+        this.noFdwSupport();
+    }
+    async dropForeignDataWrapper() {
+        this.noFdwSupport();
+    }
+    async createForeignServer() {
+        this.noFdwSupport();
+    }
+    async dropForeignServer() {
+        this.noFdwSupport();
+    }
+    async createForeignTable() {
+        this.noFdwSupport();
+    }
+    buildCreateServerQuery(_name, _opts) {
+        this.noFdwSupport();
+    }
+    buildAlterServerQuery(_name, _opts) {
+        this.noFdwSupport();
+    }
+    buildDropServerQuery(_name, _opts) {
+        this.noFdwSupport();
+    }
+    buildCreateUserMappingQuery(_opts) {
+        this.noFdwSupport();
+    }
+    buildAlterUserMappingQuery(_opts) {
+        this.noFdwSupport();
+    }
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        this.noFdwSupport();
+    }
+    async createUserMapping() {
+        this.noFdwSupport();
+    }
+    async dropUserMapping() {
+        this.noFdwSupport();
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        this.noFdwSupport();
+    }
+    buildDropForeignTableQuery(_tableName, _opts) {
+        this.noFdwSupport();
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        this.noFdwSupport();
+    }
+    getServersQuery() {
+        this.noFdwSupport();
+    }
+    // ---------------------------------------------------------------------------
+    // Row-level security - not supported by Redshift.
+    // ---------------------------------------------------------------------------
+    async createSecurityPolicy() {
+        throw new index_1.DatabaseError('Row-level security policies are not supported by Redshift');
+    }
+    async dropSecurityPolicy() {
+        throw new index_1.DatabaseError('Row-level security policies are not supported by Redshift');
+    }
+    async createPolicy(_options) {
+        throw new index_1.DatabaseError('Row-level security policies are not supported by Redshift');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        throw new index_1.DatabaseError('Row-level security policies are not supported by Redshift');
+    }
+    async enableRLS() {
+        throw new index_1.DatabaseError('Row-level security is not supported by Redshift');
+    }
+    async disableRLS() {
+        throw new index_1.DatabaseError('Row-level security is not supported by Redshift');
+    }
+    async hasPolicy() {
+        throw new index_1.DatabaseError('Row-level security policies are not supported by Redshift');
+    }
+    // ---------------------------------------------------------------------------
+    // Sequences - Redshift has no CREATE SEQUENCE/nextval. Use IDENTITY columns
+    // (see getColumnDefinitionSql) for auto-increment behavior instead.
+    // ---------------------------------------------------------------------------
+    noSequenceSupport() {
+        throw new index_1.DatabaseError('Redshift does not support sequences (no CREATE SEQUENCE/nextval). Use an IDENTITY(seed, step) column instead (set autoIncrement: true on the column definition).');
+    }
+    async createSequence(_options) {
+        this.noSequenceSupport();
+    }
+    async dropSequence(_sequenceName, _options) {
+        this.noSequenceSupport();
+    }
+    async nextSequenceValue(_sequenceName) {
+        this.noSequenceSupport();
+    }
+    async hasSequence(_sequenceName) {
+        this.noSequenceSupport();
+    }
+    async listSequences() {
+        this.noSequenceSupport();
+    }
+    // ---------------------------------------------------------------------------
+    // Triggers - Redshift has no trigger support at all.
+    // ---------------------------------------------------------------------------
+    async createTrigger(_options) {
+        throw new index_1.DatabaseError('Redshift does not support triggers');
+    }
+    async dropTrigger(_triggerName, _tableName, _options) {
+        throw new index_1.DatabaseError('Redshift does not support triggers');
+    }
+    async hasTrigger() {
+        throw new index_1.DatabaseError('Redshift does not support triggers');
+    }
+    // ---------------------------------------------------------------------------
+    // Identity / computed columns
+    // ---------------------------------------------------------------------------
+    async createIdentityColumn() {
+        throw new index_1.DatabaseError('Redshift IDENTITY columns can only be defined at CREATE TABLE time, not added later via ALTER TABLE. Set autoIncrement: true on the column definition when creating the table instead.');
+    }
+    async createComputedColumn() {
+        throw new index_1.DatabaseError('Redshift does not support computed/generated columns');
+    }
+    // ---------------------------------------------------------------------------
+    // Comments - Redshift supports COMMENT ON TABLE/COLUMN
+    // ---------------------------------------------------------------------------
+    async commentTable(tableName, comment) {
+        await this.query(`COMMENT ON TABLE ${this.quoteTable(tableName)} IS ${this.escape(comment)}`);
+    }
+    async commentColumn(tableName, columnName, comment) {
+        await this.query(`COMMENT ON COLUMN ${this.quoteTable(tableName)}.${this.quoteIdentifier(columnName)} IS ${this.escape(comment)}`);
+    }
+    // ---------------------------------------------------------------------------
+    // Stored procedures - Redshift supports a limited plpgsql-like dialect.
+    // ---------------------------------------------------------------------------
+    async createStoredProcedure(options) {
+        const schema = options.schema || 'public';
+        const procName = `${this.escapeId(schema)}.${this.escapeId(options.name)}`;
+        let sql = options.replace ? 'CREATE OR REPLACE PROCEDURE' : 'CREATE PROCEDURE';
+        if (options.params && options.params.length > 0) {
+            const params = options.params
+                .map((p) => `${this.escapeId(p.name)} ${p.type}`)
+                .join(', ');
+            sql += ` ${procName} (${params})`;
+        }
+        else {
+            sql += ` ${procName}()`;
+        }
+        sql += ` AS $$ ${options.body} $$ LANGUAGE plpgsql`;
+        await this.query(sql);
+    }
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    async dropStoredProcedure(procedureName, options) {
+        const schema = options?.schema || 'public';
+        let sql = 'DROP PROCEDURE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(schema)}.${this.escapeId(procedureName)}`;
+        await this.query(sql);
+    }
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    async executeStoredProcedure(options) {
+        const schema = options.schema || 'public';
+        const procName = `${this.escapeId(schema)}.${this.escapeId(options.procedureName)}`;
+        let sql = `CALL ${procName}`;
+        if (options.params && Object.keys(options.params).length > 0) {
+            sql += `(${Object.values(options.params).map((v) => this.escape(v)).join(', ')})`;
+        }
+        else {
+            sql += '()';
+        }
+        return this.query(sql);
+    }
+    async hasStoredProcedure(procedureName, schema) {
+        const db = schema || 'public';
+        const sql = `SELECT proname FROM pg_proc p JOIN pg_namespace n ON p.pronamespace = n.oid WHERE n.nspname = $1 AND proname = $2`;
+        const result = await this.query(sql, { replacements: [db, procedureName] });
+        return (result.rows?.length ?? 0) > 0;
+    }
+    // ---------------------------------------------------------------------------
+    // Maintenance - VACUUM / ANALYZE
+    //
+    // Unlike Postgres-family dialects where autovacuum transparently reclaims
+    // dead tuples and refreshes planner stats, Redshift requires callers to run
+    // these explicitly. This matters especially here because `buildUpsertQuery`
+    // (see the staging-table + DELETE + INSERT upsert path) generates frequent
+    // DELETE/INSERT churn, which both bloats unsorted/deleted-but-not-reclaimed
+    // blocks and skews `ANALYZE` statistics over time if nothing ever runs
+    // VACUUM/ANALYZE against the affected tables.
+    // ---------------------------------------------------------------------------
+    /**
+     * Run Redshift's `VACUUM` maintenance command, which resorts rows within
+     * sort key order and reclaims space from deleted rows. Neither of these
+     * happen automatically the way Postgres's autovacuum does.
+     *
+     * Builds: `VACUUM [FULL|SORT ONLY|DELETE ONLY|REINDEX] [<table>] [TO <n> PERCENT] [BOOST]`
+     */
+    async vacuum(tableName, options) {
+        let sql = 'VACUUM';
+        const mode = options?.mode;
+        if (mode && mode !== 'FULL') {
+            sql += ` ${mode}`;
+        }
+        if (tableName) {
+            sql += ` ${this.escapeId(tableName)}`;
+        }
+        if (options?.toPercent !== undefined) {
+            if (options.toPercent < 1 || options.toPercent > 100) {
+                throw new index_1.DatabaseError('vacuum() options.toPercent must be between 1 and 100');
+            }
+            sql += ` TO ${options.toPercent} PERCENT`;
+        }
+        if (options?.boost) {
+            sql += ' BOOST';
+        }
+        return this.query(sql);
+    }
+    /**
+     * Run Redshift's `ANALYZE` maintenance command to refresh planner
+     * statistics (or `ANALYZE COMPRESSION` to get column encoding
+     * recommendations). Redshift's query planner relies entirely on these
+     * explicitly-collected stats; there is no background stats collector like
+     * Postgres's autovacuum/autoanalyze.
+     *
+     * Builds: `ANALYZE [<table> [(<col>, ...)]] [PREDICATE COLUMNS]`
+     */
+    async analyze(tableName, options) {
+        if (options?.columns?.length && options?.predicateColumns) {
+            throw new index_1.DatabaseError('analyze() accepts either options.columns or options.predicateColumns, not both');
+        }
+        let sql = 'ANALYZE';
+        if (tableName) {
+            sql += ` ${this.escapeId(tableName)}`;
+            if (options?.columns?.length) {
+                sql += ` (${options.columns.map((c) => this.escapeId(c)).join(', ')})`;
+            }
+        }
+        if (options?.predicateColumns) {
+            sql += ' PREDICATE COLUMNS';
+        }
+        return this.query(sql);
+    }
+    /**
+     * Run Redshift's `ANALYZE COMPRESSION` command, which samples a table (or
+     * the whole database when `tableName` is omitted) and recommends column
+     * encodings. This is a separate command from `ANALYZE` in Redshift - it
+     * does not update planner statistics, it only reports encoding advice.
+     */
+    async analyzeCompression(tableName) {
+        let sql = 'ANALYZE COMPRESSION';
+        if (tableName)
+            sql += ` ${this.escapeId(tableName)}`;
+        return this.query(sql);
+    }
+    getIsolationLevelSql(isolationLevel) {
+        const level = isolationLevel.toUpperCase().trim();
+        if (!RedshiftDialect.SUPPORTED_ISOLATION_LEVELS.has(level)) {
+            throw new index_1.DatabaseError(`Redshift does not support isolation level '${isolationLevel}'. Redshift only supports ` +
+                `READ COMMITTED and SERIALIZABLE (the ANSI READ UNCOMMITTED/REPEATABLE READ levels have ` +
+                `no equivalent in Redshift's concurrency model).`);
+        }
+        return level;
+    }
+    async startTransaction(options) {
+        if (!this.pool)
+            throw new Error('Not connected to database');
+        const client = await this.pool.connect();
+        let beginSql = 'BEGIN';
+        if (options?.isolationLevel) {
+            beginSql += ` ISOLATION LEVEL ${this.getIsolationLevelSql(options.isolationLevel)}`;
+        }
+        const readOnly = options?.readOnly;
+        if (readOnly !== undefined) {
+            beginSql += readOnly ? ' READ ONLY' : ' READ WRITE';
+        }
+        await client.query(beginSql);
+        return new RedshiftTransaction(client, this.transactionDepth++, options);
+    }
+    async commitTransaction(transaction) {
+        const tx = transaction;
+        if (tx.client) {
+            await tx.client.query('COMMIT');
+            tx.client.release();
+            tx.finished = true;
+        }
+    }
+    async rollbackTransaction(transaction) {
+        const tx = transaction;
+        if (tx.client) {
+            await tx.client.query('ROLLBACK');
+            tx.client.release();
+            tx.finished = true;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Data types
+    // ---------------------------------------------------------------------------
+    /**
+     * Get the SQL for a data type.
+     *
+     * Notably: Redshift has no native JSON/JSONB type (that only exists in
+     * Postgres). Both `JSON` and `JSONB` DataTypes map to Redshift's
+     * semi-structured `SUPER` type instead.
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string')
+            return dataType;
+        if (!dataType || typeof dataType !== 'object')
+            return 'VARCHAR(255)';
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+                return `VARCHAR(${dt.length || 255})`;
+            case 'CHAR':
+                return `CHAR(${dt.length || 1})`;
+            case 'TEXT':
+                return dt.length ? `VARCHAR(${dt.length})` : 'VARCHAR(65535)';
+            case 'INTEGER':
+                // NOTE: auto-increment INTEGER columns are handled in
+                // getColumnDefinitionSql via IDENTITY(seed, step), not here.
+                return 'INTEGER';
+            case 'BIGINT':
+                return 'BIGINT';
+            case 'FLOAT':
+                return 'REAL';
+            case 'DOUBLE':
+                return 'DOUBLE PRECISION';
+            case 'DECIMAL':
+                return `DECIMAL(${dt.precision || 18},${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+                return 'TIMESTAMP';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return 'TIME';
+            case 'BLOB':
+                return 'VARBYTE';
+            case 'ENUM': {
+                // Redshift has no native ENUM type; fall back to VARCHAR with the
+                // longest declared value as a rough width guide.
+                const values = dt.values || [];
+                const maxLen = values.reduce((m, v) => Math.max(m, v.length), 1);
+                return `VARCHAR(${Math.max(maxLen, 255)})`;
+            }
+            case 'JSON':
+            case 'JSONB':
+                // Redshift has no JSON/JSONB type before SUPER - map both to SUPER.
+                return 'SUPER';
+            case 'UUID':
+                return 'VARCHAR(36)';
+            case 'ARRAY':
+                // Redshift represents nested/array data via SUPER, not native array types.
+                return 'SUPER';
+            case 'VIRTUAL':
+                return '';
+            default:
+                return 'VARCHAR(255)';
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Query builders
+    // ---------------------------------------------------------------------------
+    buildWhereClause(where, _options) {
+        const values = [];
+        if (!where || Object.keys(where).length === 0)
+            return { sql: '', values };
+        const buildCondition = (condition) => {
+            if (!condition || typeof condition !== 'object')
+                return '';
+            const cond = condition;
+            if (cond.$and || cond.$or || cond.$not) {
+                const parts = [];
+                if (cond.$and)
+                    parts.push(`(${cond.$and.map((c) => buildCondition(c)).join(' AND ')})`);
+                if (cond.$or)
+                    parts.push(`(${cond.$or.map((c) => buildCondition(c)).join(' OR ')})`);
+                if (cond.$not)
+                    parts.push(`NOT (${buildCondition(cond.$not)})`);
+                return parts.join(' AND ');
+            }
+            const fieldConditions = [];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key.startsWith('$'))
+                    continue;
+                if (value && typeof value === 'object' && !(value instanceof Date)) {
+                    const valueObj = value;
+                    if (valueObj.$eq !== undefined) {
+                        values.push(valueObj.$eq);
+                        fieldConditions.push(`${this.escapeId(key)} = $${values.length}`);
+                    }
+                    else if (valueObj.$ne !== undefined) {
+                        values.push(valueObj.$ne);
+                        fieldConditions.push(`${this.escapeId(key)} != $${values.length}`);
+                    }
+                    else if (valueObj.$gt !== undefined) {
+                        values.push(valueObj.$gt);
+                        fieldConditions.push(`${this.escapeId(key)} > $${values.length}`);
+                    }
+                    else if (valueObj.$gte !== undefined) {
+                        values.push(valueObj.$gte);
+                        fieldConditions.push(`${this.escapeId(key)} >= $${values.length}`);
+                    }
+                    else if (valueObj.$lt !== undefined) {
+                        values.push(valueObj.$lt);
+                        fieldConditions.push(`${this.escapeId(key)} < $${values.length}`);
+                    }
+                    else if (valueObj.$lte !== undefined) {
+                        values.push(valueObj.$lte);
+                        fieldConditions.push(`${this.escapeId(key)} <= $${values.length}`);
+                    }
+                    else if (valueObj.$like !== undefined) {
+                        values.push(valueObj.$like);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE $${values.length}`);
+                    }
+                    else if (valueObj.$in) {
+                        const inValues = valueObj.$in;
+                        values.push(...inValues);
+                        const placeholders = inValues.map((_, i) => `$${values.length - inValues.length + i + 1}`).join(',');
+                        fieldConditions.push(`${this.escapeId(key)} IN (${placeholders})`);
+                    }
+                    else if (valueObj.$notIn) {
+                        const notInValues = valueObj.$notIn;
+                        values.push(...notInValues);
+                        const placeholders = notInValues.map((_, i) => `$${values.length - notInValues.length + i + 1}`).join(',');
+                        fieldConditions.push(`${this.escapeId(key)} NOT IN (${placeholders})`);
+                    }
+                    else if (valueObj.$between) {
+                        const between = valueObj.$between;
+                        values.push(between[0], between[1]);
+                        fieldConditions.push(`${this.escapeId(key)} BETWEEN $${values.length - 1} AND $${values.length}`);
+                    }
+                    else if (valueObj.$isNull !== undefined) {
+                        fieldConditions.push(`${this.escapeId(key)} IS ${valueObj.$isNull ? '' : 'NOT '}NULL`);
+                    }
+                    else {
+                        values.push(value);
+                        fieldConditions.push(`${this.escapeId(key)} = $${values.length}`);
+                    }
+                }
+                else {
+                    values.push(value);
+                    fieldConditions.push(`${this.escapeId(key)} = $${values.length}`);
+                }
+            }
+            return fieldConditions.join(' AND ');
+        };
+        return { sql: buildCondition(where), values };
+    }
+    buildOrderClause(order, _options) {
+        const orderArray = order;
+        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0)
+            return '';
+        const orderParts = [];
+        for (const item of orderArray) {
+            if (Array.isArray(item)) {
+                const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
+                const direction = item[1] ? ` ${item[1]}` : '';
+                orderParts.push(`${field}${direction}`);
+            }
+            else if (typeof item === 'string') {
+                orderParts.push(this.escapeId(item));
+            }
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    buildLimitOffset(limit, offset) {
+        let sql = '';
+        if (limit !== undefined) {
+            sql += ` LIMIT ${Number(limit)}`;
+            if (offset !== undefined)
+                sql += ` OFFSET ${Number(offset)}`;
+        }
+        return sql;
+    }
+    buildInsertQuery(tableName, values, options) {
+        if (options?.upsert) {
+            throw new index_1.DatabaseError('Redshift does not support ON CONFLICT / upsert-via-INSERT. Use buildUpsertQuery() instead, which returns the staging-table + DELETE + INSERT statements Redshift documents for upserts.');
+        }
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        let paramIndex = 1;
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                placeholders.push(value.val);
+            }
+            else {
+                placeholders.push(`$${paramIndex}`);
+                processedValues.push(value);
+                paramIndex++;
+            }
+        }
+        let sql = `INSERT INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        if (options?.returning) {
+            sql += options.returning === true ? ' RETURNING *' : ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Generate a collision-resistant temp/staging table name.
+     *
+     * Previously this used `${tableName}_staging_${Date.now()}` — millisecond
+     * wall-clock time only, with no randomness. Two concurrent upserts against
+     * the same table within the same millisecond (realistic under load, or in
+     * a tight parallel batch) would produce an identical staging table name.
+     * A random component (via `generateShortUUID()`) makes collisions
+     * practically impossible even when many upserts race within the same
+     * millisecond, on the same connection, or across processes/hosts.
+     *
+     * Also guards against exceeding Redshift's 127-byte identifier limit by
+     * truncating the base table name portion if necessary.
+     */
+    generateStagingTableName(tableName) {
+        const suffix = `_staging_${Date.now()}_${(0, index_2.generateShortUUID)()}`;
+        const maxBaseLen = Math.max(1, 127 - suffix.length);
+        const base = tableName.length > maxBaseLen ? tableName.slice(0, maxBaseLen) : tableName;
+        return `${base}${suffix}`;
+    }
+    /**
+     * Build an UPSERT "query" for Redshift.
+     *
+     * Why not `ON CONFLICT ... DO UPDATE` (what the Postgres dialect uses)?
+     * Redshift has never supported `ON CONFLICT` — it is a Postgres 9.5+
+     * feature, and Redshift's SQL layer, forked from Postgres 8.0, does not
+     * have it. Attempting to send `ON CONFLICT` SQL to a real Redshift cluster
+     * fails with a syntax error.
+     *
+     * Two strategies are available:
+     *
+     * 1. (default) AWS's documented "merge by replacing existing rows"
+     *    staging-table pattern, which works on every Redshift version:
+     *      a. Load the new/changed row(s) into a staging table (temp table
+     *         with the same shape as the target).
+     *      b. `DELETE FROM target USING staging WHERE target.<key> = staging.<key>`
+     *         to remove rows that are about to be replaced.
+     *      c. `INSERT INTO target SELECT * FROM staging` to insert the new
+     *         versions (and any brand new rows).
+     *
+     * 2. (opt-in via `options.useMerge`) A native `MERGE INTO ... USING ...
+     *    WHEN MATCHED THEN UPDATE ... WHEN NOT MATCHED THEN INSERT ...`
+     *    statement. Redshift only added `MERGE` support in 2023, so this is
+     *    NOT the default (it would fail with a syntax error on older/still-
+     *    common cluster versions) — set `options.useMerge: true` only when you
+     *    know the target cluster supports it. It has the advantage of being a
+     *    single atomic statement with no staging table required at all.
+     *
+     * IMPORTANT — atomicity: the staging-table strategy is inherently multiple
+     * statements (not a single parameterized `INSERT`), so the returned `sql`
+     * is a semicolon-separated multi-statement string. Running these
+     * statements one at a time through a connection pool (rather than a single
+     * pinned connection wrapped in `BEGIN`/`COMMIT`) risks the temp table
+     * created by statement 1 not being visible to later statements (temp
+     * tables are session-scoped), and leaves no rollback path if a
+     * mid-sequence statement fails. Use `upsert()` (below), which pins a
+     * single connection and wraps the whole sequence in an explicit
+     * transaction, rather than sending this string through the pooled
+     * `query()` method directly.
+     */
+    buildUpsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const conflictFields = options?.conflictFields && options.conflictFields.length > 0 ? options.conflictFields : columns;
+        const queryValues = Object.values(values);
+        const quotedTarget = this.escapeId(tableName);
+        const quotedColumns = columns.map((c) => this.escapeId(c)).join(', ');
+        if (options?.useMerge) {
+            const sql = this.buildMergeStatement(tableName, [columns], conflictFields, options);
+            return { sql, values: queryValues };
+        }
+        const stagingTable = this.generateStagingTableName(tableName);
+        const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
+        const quotedStaging = this.escapeId(stagingTable);
+        const joinCondition = conflictFields
+            .map((f) => `${quotedTarget}.${this.escapeId(f)} = ${quotedStaging}.${this.escapeId(f)}`)
+            .join(' AND ');
+        const statements = [
+            // 1. Staging table shaped like the target, holding just the incoming row(s).
+            `CREATE TEMP TABLE ${quotedStaging} (LIKE ${quotedTarget})`,
+            `INSERT INTO ${quotedStaging} (${quotedColumns}) VALUES (${placeholders})`,
+            // 2. Remove rows in the target that this upsert is about to replace.
+            `DELETE FROM ${quotedTarget} USING ${quotedStaging} WHERE ${joinCondition}`,
+            // 3. Insert the new/updated rows (and brand-new ones) from staging.
+            `INSERT INTO ${quotedTarget} (${quotedColumns}) SELECT ${quotedColumns} FROM ${quotedStaging}`,
+            `DROP TABLE ${quotedStaging}`,
+        ];
+        return { sql: statements.join(';\n'), values: queryValues };
+    }
+    /**
+     * Bulk variant of `buildUpsertQuery`: accepts an array of rows and builds
+     * ONE staging table populated with a single multi-row `INSERT`, rather
+     * than requiring one `buildUpsertQuery`/`upsert` call per row.
+     *
+     * This matches how the staging-table pattern is actually used in
+     * production Redshift pipelines — AWS documents it primarily as a *bulk*
+     * upsert technique (commonly fed by a `COPY` into the staging table for
+     * very large batches), so a single-row-only implementation undermines the
+     * main reason to prefer it over row-by-row `INSERT`/`UPDATE`.
+     *
+     * Not part of the `Dialect` interface (whose `buildUpsertQuery` takes a
+     * single `Record`) — this is a Redshift-specific addition, similar to
+     * `copyFromS3`.
+     */
+    buildBulkUpsertQuery(tableName, rows, options) {
+        if (rows.length === 0) {
+            return { sql: '', values: [] };
+        }
+        const columns = Object.keys(rows[0]);
+        const conflictFields = options?.conflictFields && options.conflictFields.length > 0 ? options.conflictFields : columns;
+        if (options?.useMerge) {
+            const sql = this.buildMergeStatement(tableName, rows.map(() => columns), conflictFields, options);
+            const values = rows.flatMap((row) => columns.map((c) => row[c]));
+            return { sql, values };
+        }
+        const stagingTable = this.generateStagingTableName(tableName);
+        const quotedTarget = this.escapeId(tableName);
+        const quotedStaging = this.escapeId(stagingTable);
+        const quotedColumns = columns.map((c) => this.escapeId(c)).join(', ');
+        const queryValues = [];
+        const rowPlaceholders = [];
+        let paramIndex = 1;
+        for (const row of rows) {
+            const placeholders = columns.map((c) => {
+                queryValues.push(row[c]);
+                return `$${paramIndex++}`;
+            });
+            rowPlaceholders.push(`(${placeholders.join(', ')})`);
+        }
+        const joinCondition = conflictFields
+            .map((f) => `${quotedTarget}.${this.escapeId(f)} = ${quotedStaging}.${this.escapeId(f)}`)
+            .join(' AND ');
+        const statements = [
+            `CREATE TEMP TABLE ${quotedStaging} (LIKE ${quotedTarget})`,
+            `INSERT INTO ${quotedStaging} (${quotedColumns}) VALUES ${rowPlaceholders.join(', ')}`,
+            `DELETE FROM ${quotedTarget} USING ${quotedStaging} WHERE ${joinCondition}`,
+            `INSERT INTO ${quotedTarget} (${quotedColumns}) SELECT ${quotedColumns} FROM ${quotedStaging}`,
+            `DROP TABLE ${quotedStaging}`,
+        ];
+        return { sql: statements.join(';\n'), values: queryValues };
+    }
+    /**
+     * Build a native `MERGE INTO` statement (Redshift 2023+ only). Shared by
+     * the single-row and bulk upsert paths — `columnsPerRow` is one entry per
+     * incoming row (all rows are expected to share the same column set).
+     */
+    buildMergeStatement(tableName, columnsPerRow, conflictFields, options) {
+        const columns = columnsPerRow[0];
+        const quotedTarget = this.escapeId(tableName);
+        const quotedColumns = columns.map((c) => this.escapeId(c));
+        let paramIndex = 1;
+        const valueRows = columnsPerRow.map((cols) => `(${cols.map(() => `$${paramIndex++}`).join(', ')})`);
+        const usingSql = `(VALUES ${valueRows.join(', ')}) AS src (${quotedColumns.join(', ')})`;
+        const onCondition = conflictFields.map((f) => `${quotedTarget}.${this.escapeId(f)} = src.${this.escapeId(f)}`).join(' AND ');
+        const updateColumns = options?.updateColumns && options.updateColumns.length > 0
+            ? options.updateColumns
+            : columns.filter((c) => !conflictFields.includes(c));
+        const updateSet = updateColumns.length > 0
+            ? updateColumns.map((c) => `${this.escapeId(c)} = src.${this.escapeId(c)}`).join(', ')
+            : null;
+        let sql = `MERGE INTO ${quotedTarget} USING ${usingSql} ON ${onCondition}`;
+        if (updateSet) {
+            sql += ` WHEN MATCHED THEN UPDATE SET ${updateSet}`;
+        }
+        sql += ` WHEN NOT MATCHED THEN INSERT (${quotedColumns.join(', ')}) VALUES (${quotedColumns.map((c) => `src.${c}`).join(', ')})`;
+        return sql;
+    }
+    /**
+     * Execute a single-row upsert against Redshift, pinning ONE connection for
+     * the whole multi-statement sequence and wrapping it in an explicit
+     * `BEGIN`/`COMMIT` (`ROLLBACK` on any failure). This is the fix for the
+     * correctness bug in the raw `buildUpsertQuery()` string: sending that
+     * string's statements through the pooled `query()` method one at a time
+     * can land different statements on different physical connections (temp
+     * tables are session-scoped in Redshift, so the staging table created in
+     * statement 1 may not exist by the time statement 3 runs), and gives no
+     * atomicity/rollback if a statement mid-sequence fails.
+     *
+     * When `options.useMerge` is set, this still pins a connection and wraps
+     * the (single) `MERGE` statement in `BEGIN`/`COMMIT` for a consistent
+     * calling convention, even though a single statement is already atomic on
+     * its own.
+     */
+    async upsert(tableName, values, options) {
+        const { sql, values: params } = this.buildUpsertQuery(tableName, values, options);
+        return this.runUpsertStatements(sql, params);
+    }
+    /**
+     * Bulk counterpart to `upsert()`: builds one staging-table (or `MERGE`)
+     * statement sequence for the whole `rows` array via `buildBulkUpsertQuery`,
+     * then runs it on a single pinned connection inside an explicit
+     * transaction, exactly like `upsert()`.
+     */
+    async bulkUpsert(tableName, rows, options) {
+        if (rows.length === 0)
+            return { rows: [], rowCount: 0, fields: [] };
+        const { sql, values: params } = this.buildBulkUpsertQuery(tableName, rows, options);
+        return this.runUpsertStatements(sql, params);
+    }
+    /**
+     * Shared execution path for `upsert()`/`bulkUpsert()`: pins a single
+     * client from the pool, runs `BEGIN`, then each `;`-separated statement in
+     * `sql` in order (substituting `params` into only the first statement that
+     * needs them, i.e. the staging-table INSERT or the MERGE's USING clause),
+     * then `COMMIT`. Any failure triggers `ROLLBACK` before re-throwing, and
+     * the client is always released back to the pool.
+     */
+    async runUpsertStatements(sql, params) {
+        if (!this.pool)
+            throw new Error('Not connected to database');
+        if (!sql)
+            return { rows: [], rowCount: 0, fields: [] };
+        const client = await this.pool.connect();
+        let lastResult;
+        try {
+            await client.query('BEGIN');
+            const statements = sql.split(';\n').map((s) => s.trim()).filter((s) => s.length > 0);
+            let paramsConsumed = false;
+            for (const statement of statements) {
+                // Only the statement(s) containing positional placeholders need the
+                // parameter values; substitute them in once via replaceReplacements
+                // (matching how the pooled `query()` method handles replacements).
+                const needsParams = !paramsConsumed && /\$1(?!\d)/.test(statement);
+                const finalSql = needsParams ? this.replaceReplacements(statement, params) : statement;
+                if (needsParams)
+                    paramsConsumed = true;
+                lastResult = (await client.query(finalSql));
+            }
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            try {
+                await client.query('ROLLBACK');
+            }
+            catch {
+                // Ignore rollback failures - the original error is more useful.
+            }
+            throw new Error(`Redshift upsert error: ${error}`);
+        }
+        finally {
+            client.release();
+        }
+        const rows = lastResult?.rows ?? [];
+        return { rows, rowCount: lastResult?.rowCount ?? rows.length, fields: [] };
+    }
+    buildIncrementQuery(tableName, fields, where, options) {
+        const by = options?.by ?? 1;
+        const setClauses = [];
+        const queryValues = [];
+        let paramIndex = 1;
+        if (typeof fields === 'string') {
+            setClauses.push(`${this.escapeId(fields)} = ${this.escapeId(fields)} + $${paramIndex}`);
+            queryValues.push(by);
+            paramIndex++;
+        }
+        else if (Array.isArray(fields)) {
+            for (const field of fields) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + $${paramIndex}`);
+                queryValues.push(by);
+                paramIndex++;
+            }
+        }
+        else {
+            for (const [field, value] of Object.entries(fields)) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + $${paramIndex}`);
+                queryValues.push(value);
+                paramIndex++;
+            }
+        }
+        const whereClause = this.buildWhereClause(where);
+        const adjustedWhere = whereClause.sql.replace(/\$(\d+)/g, (_, num) => `$${paramIndex + parseInt(num, 10) - 1}`);
+        queryValues.push(...whereClause.values);
+        const sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')} WHERE ${adjustedWhere}`;
+        return { sql, values: queryValues };
+    }
+    buildUpdateQuery(tableName, values, where, options) {
+        const setClauses = [];
+        const queryValues = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                setClauses.push(`${this.escapeId(key)} = $${paramIndex}`);
+                queryValues.push(value);
+                paramIndex++;
+            }
+        }
+        const whereClause = this.buildWhereClause(where);
+        const allValues = [...queryValues, ...whereClause.values];
+        let sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql)
+            sql += ` WHERE ${whereClause.sql}`;
+        if (options?.returning) {
+            sql += options.returning === true ? ' RETURNING *' : ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+        }
+        return { sql, values: allValues };
+    }
+    buildDeleteQuery(tableName, where, options) {
+        const whereClause = this.buildWhereClause(where);
+        let sql = `DELETE FROM ${this.escapeId(tableName)}`;
+        if (whereClause.sql)
+            sql += ` WHERE ${whereClause.sql}`;
+        if (options?.returning) {
+            sql += options.returning === true ? ' RETURNING *' : ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+        }
+        if (options?.truncate) {
+            sql = `TRUNCATE ${this.escapeId(tableName)}`;
+        }
+        return { sql, values: whereClause.values };
+    }
+    /**
+     * Format a single SELECT-list attribute into SQL.
+     *
+     * `options.attributes` isn't limited to plain column-name strings: the
+     * typed window-function builder library (`src/query-builders/functions/
+     * window.ts`, e.g. `rowNumber().partitionBy(...).as('rn')`) and the
+     * `fn()`/`col()`/`literal()`/`cast()`/`extract()` helpers in
+     * `src/operators.ts` all resolve to either a raw `LiteralExpression`
+     * (`{ __type: 'literal', sql }`) or a `[expression, alias]` tuple.
+     *
+     * Blindly calling `escapeId()` on those (as this method used to do) is
+     * broken: `escapeId` stringifies whatever it's given and wraps it in
+     * double quotes, so a tuple like `[literalExpr('ROW_NUMBER() OVER (...)'),
+     * 'rn']` became the identifier `"[object Object],rn"` instead of
+     * `ROW_NUMBER() OVER (...) AS "rn"`. This mirrors the attribute-resolution
+     * logic in `SqlCompiler.attributeToSqlWithAlias`/`processAttribute`
+     * (`src/query-builders/sql-compiler.ts`), but is implemented locally so it
+     * always renders identifiers via this dialect's own `escapeId`.
+     */
+    formatSelectAttribute(attr) {
+        // [expression, alias] tuple - render the expression, then ` AS "alias"`.
+        if (Array.isArray(attr)) {
+            const [expr, alias] = attr;
+            const exprSql = this.formatSelectAttribute(expr);
+            return alias ? `${exprSql} AS ${this.escapeId(alias)}` : exprSql;
+        }
+        // FnExpression: { __type: 'fn', fn: 'COUNT', args: [...] }
+        if ((0, operators_1.isFnExpression)(attr)) {
+            const args = attr.args.map((a) => this.formatSelectAttribute(a)).join(', ');
+            return `${attr.fn}(${args})`;
+        }
+        // ColExpression: { __type: 'col', col: 'table.field' | 'field' }
+        if ((0, operators_1.isColExpression)(attr)) {
+            const col = attr.col;
+            return col.includes('.')
+                ? col.split('.').map((part) => this.escapeId(part)).join('.')
+                : this.escapeId(col);
+        }
+        // LiteralExpression: { __type: 'literal', sql } or { $literal: sql }.
+        // This is the shape produced by window.ts's `.toLiteral()`/`.as()` and
+        // by `literal()` in operators.ts - already raw, dialect-agnostic SQL, so
+        // it's passed through verbatim (this is exactly what was previously
+        // being mis-handled by escapeId).
+        //
+        // Note: `isLiteralExpression` probes for a `$literal` key via the `in`
+        // operator, which throws on non-object values (e.g. plain strings) -
+        // guard with a typeof check first rather than calling it unconditionally.
+        if (attr !== null && typeof attr === 'object' && (0, operators_1.isLiteralExpression)(attr)) {
+            return attr.sql ?? attr.$literal ?? '';
+        }
+        // CastExpression: { __type: 'cast', value, type }
+        if ((0, operators_1.isCastExpression)(attr)) {
+            const value = this.formatSelectAttribute(attr.value);
+            return `CAST(${value} AS ${attr.type || 'TEXT'})`;
+        }
+        // ExtractExpression: { __type: 'extract', field, part }
+        if ((0, operators_1.isExtractExpression)(attr)) {
+            const field = this.formatSelectAttribute(attr.field);
+            const part = (attr.part || 'YEAR').toUpperCase();
+            return `EXTRACT(${part} FROM ${field})`;
+        }
+        // Plain string: either a bare column name or a raw SQL expression
+        // (heuristically detected via parens/whitespace, matching the
+        // permissive convention SqlCompiler and the other dialects use).
+        if (typeof attr === 'string') {
+            if (attr.includes('(') || attr.includes(' ')) {
+                return attr;
+            }
+            return this.escapeId(attr);
+        }
+        return this.escapeId(attr);
+    }
+    /**
+     * Build a `WITH [RECURSIVE] name [(cols)] AS (query), ...` prefix from
+     * `options.cte`.
+     *
+     * Each entry's `query` may be a raw SQL string, or a nested `SelectOptions`
+     * object (compiled recursively via `buildSelectQuery`); nested `SelectOptions`
+     * CTE bodies never carry positional parameter values of their own in this
+     * dialect - callers needing bound values in a CTE body should pass a raw
+     * SQL string with the values already inlined/escaped, or use `Literal`.
+     *
+     * If any entry sets `recursive: true`, the WHOLE clause is emitted as
+     * `WITH RECURSIVE` - Redshift, like Postgres and most other engines,
+     * applies `RECURSIVE` to the entire `WITH` clause rather than per-CTE.
+     *
+     * NOTE on version support: Amazon Redshift only added `WITH RECURSIVE`
+     * support relatively recently (RA3 node types on a sufficiently current
+     * maintenance track); clusters on older node types/tracks will reject
+     * `WITH RECURSIVE` with a syntax error even though plain (non-recursive)
+     * `WITH` CTEs have always been supported. This method does not attempt to
+     * detect the cluster's capabilities - it emits `WITH RECURSIVE` whenever
+     * asked and leaves it to the caller to know their cluster supports it.
+     */
+    buildCteClause(cte) {
+        if (!cte || cte.length === 0)
+            return '';
+        const recursive = cte.some((c) => c.recursive);
+        const body = cte
+            .map((c) => {
+            const columns = c.columns && c.columns.length > 0 ? ` (${c.columns.map((col) => this.escapeId(col)).join(', ')})` : '';
+            const inner = typeof c.query === 'string' ? c.query : this.buildSelectQuery(c.query).sql;
+            return `${this.escapeId(c.name)}${columns} AS (${inner})`;
+        })
+            .join(', ');
+        return `WITH ${recursive ? 'RECURSIVE ' : ''}${body} `;
+    }
+    buildSelectQuery(options) {
+        const queryValues = [];
+        let selectSql = '*';
+        let distinctClause = '';
+        if (options.distinct) {
+            distinctClause = options.col ? `DISTINCT ${this.escapeId(options.col)} ` : 'DISTINCT ';
+            // Note: Redshift does not support Postgres's DISTINCT ON (...) syntax.
+        }
+        if (options.attributes) {
+            if (Array.isArray(options.attributes)) {
+                selectSql = options.attributes.map((a) => this.formatSelectAttribute(a)).join(', ');
+            }
+            else if (options.attributes.include) {
+                selectSql = options.attributes.include.map((a) => this.escapeId(a)).join(', ');
+            }
+        }
+        const cteClause = this.buildCteClause(options.cte);
+        let sql = `${cteClause}SELECT ${distinctClause}${selectSql} FROM ${this.escapeId(options.tableName)}`;
+        if (options.include && options.include.length > 0) {
+            for (const include of options.include) {
+                const joinType = include.required ? 'INNER JOIN' : 'LEFT JOIN';
+                const modelTableName = include.model?.tableName;
+                const modelName = modelTableName || String(include.model);
+                const alias = include.as || modelName;
+                sql += ` ${joinType} ${this.escapeId(modelName)} ${this.escapeId(alias)}`;
+                if (include.where) {
+                    const whereClause = this.buildWhereClause(include.where);
+                    sql += ` ON ${whereClause.sql}`;
+                    queryValues.push(...whereClause.values);
+                }
+            }
+        }
+        if (options.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                queryValues.push(...whereClause.values);
+            }
+        }
+        if (options.group) {
+            const groupArray = Array.isArray(options.group) ? options.group : [options.group];
+            if (groupArray.length > 0) {
+                sql += ` GROUP BY ${groupArray.map((f) => this.escapeId(f)).join(', ')}`;
+            }
+        }
+        if (options.having) {
+            const havingClause = this.buildWhereClause(options.having);
+            if (havingClause.sql) {
+                sql += ` HAVING ${havingClause.sql}`;
+                queryValues.push(...havingClause.values);
+            }
+        }
+        if (options.order) {
+            const orderClause = this.buildOrderClause(options.order);
+            if (orderClause)
+                sql += ` ${orderClause}`;
+        }
+        sql += this.buildLimitOffset(options.limit, options.offset);
+        if (options.union && options.union.length > 0) {
+            const unionType = options.unionType || 'UNION';
+            for (const unionQuery of options.union) {
+                const unionModel = unionQuery.model;
+                const unionTableName = unionModel.tableName || unionModel.name || '';
+                let unionSql = `SELECT * FROM ${this.escapeId(unionTableName)}`;
+                if (unionQuery.where) {
+                    const whereClause = this.buildWhereClause(unionQuery.where);
+                    if (whereClause.sql) {
+                        unionSql += ` WHERE ${whereClause.sql}`;
+                        queryValues.push(...whereClause.values);
+                    }
+                }
+                sql += ` ${unionType} ${unionSql}`;
+            }
+        }
+        return { sql, values: queryValues };
+    }
+    replaceReplacements(sql, replacements) {
+        if (!replacements)
+            return sql;
+        if (Array.isArray(replacements)) {
+            let result = sql;
+            replacements.forEach((value, index) => {
+                const placeholder = `$${index + 1}`;
+                const re = new RegExp(placeholder.replace('$', '\\$'), 'g');
+                if (value === null)
+                    result = result.replace(re, 'NULL');
+                else if (typeof value === 'string')
+                    result = result.replace(re, `'${value.replace(/'/g, "''")}'`);
+                else if (value instanceof Date)
+                    result = result.replace(re, `'${value.toISOString()}'`);
+                else
+                    result = result.replace(re, String(value));
+            });
+            return result;
+        }
+        let result = sql;
+        for (const [key, value] of Object.entries(replacements)) {
+            const re = new RegExp(`:${key}\\b`.replace(/:/g, '\\:'), 'g');
+            if (value === null)
+                result = result.replace(re, 'NULL');
+            else if (typeof value === 'string')
+                result = result.replace(re, `'${value.replace(/'/g, "''")}'`);
+            else if (value instanceof Date)
+                result = result.replace(re, `'${value.toISOString()}'`);
+            else
+                result = result.replace(re, String(value));
+        }
+        return result;
+    }
+    // ---------------------------------------------------------------------------
+    // User / privilege management - Redshift supports its own CREATE/ALTER/DROP
+    // USER syntax (a subset of Postgres's).
+    // ---------------------------------------------------------------------------
+    buildCreateUserQuery(username, options) {
+        const opts = options || {};
+        let sql = `CREATE USER ${this.escapeId(username)}`;
+        if (opts.password) {
+            sql += ` PASSWORD '${this.escapeString(String(opts.password))}'`;
+        }
+        else {
+            sql += ' PASSWORD DISABLE';
+        }
+        if (opts.createdb === true)
+            sql += ' CREATEDB';
+        if (opts.superuser === true)
+            sql += ' CREATEUSER';
+        return sql;
+    }
+    buildAlterUserQuery(username, options) {
+        const opts = options || {};
+        let sql = `ALTER USER ${this.escapeId(username)}`;
+        if (opts.renameTo)
+            return `${sql} RENAME TO ${this.escapeId(opts.renameTo)}`;
+        if (opts.password)
+            sql += ` PASSWORD '${this.escapeString(String(opts.password))}'`;
+        return sql;
+    }
+    buildDropUserQuery(username, options) {
+        let sql = 'DROP USER';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(username)}`;
+        return sql;
+    }
+    getUsersQuery() {
+        return `SELECT usename AS "user" FROM pg_user ORDER BY usename`;
+    }
+    async createUser(username, options) {
+        await this.query(this.buildCreateUserQuery(username, options));
+    }
+    buildGrantQuery(_options) {
+        throw new index_1.DatabaseError('Fine-grained GRANT query building is not implemented for Redshift');
+    }
+    buildRevokeQuery(_options) {
+        throw new index_1.DatabaseError('Fine-grained REVOKE query building is not implemented for Redshift');
+    }
+    buildShowGrantsQuery(_username, _host) {
+        throw new index_1.DatabaseError('SHOW GRANTS is not supported by Redshift');
+    }
+    buildFlushPrivilegesQuery() {
+        throw new index_1.DatabaseError('FLUSH PRIVILEGES is not applicable to Redshift');
+    }
+    buildCreateRoleQuery(_roleName, _options) {
+        throw new index_1.DatabaseError('Roles are not supported by Redshift in the Postgres sense; use users/groups instead');
+    }
+    buildDropRoleQuery(_roleName, _options) {
+        throw new index_1.DatabaseError('Roles are not supported by Redshift in the Postgres sense; use users/groups instead');
+    }
+    buildGrantRoleQuery(_role, _to, _options) {
+        throw new index_1.DatabaseError('Roles are not supported by Redshift in the Postgres sense; use users/groups instead');
+    }
+    buildRevokeRoleQuery(_role, _from, _options) {
+        throw new index_1.DatabaseError('Roles are not supported by Redshift in the Postgres sense; use users/groups instead');
+    }
+    getRolesQuery() {
+        throw new index_1.DatabaseError('Roles are not supported by Redshift in the Postgres sense; use users/groups instead');
+    }
+    /**
+     * Build a JSON_TABLE-equivalent expression to shred a JSON array into relational rows.
+     * Not supported: Redshift has no `JSON_TABLE`, no `OPENJSON`, and no
+     * `json_to_recordset`/`jsonb_to_recordset` (it has no JSONB type at all — JSON is
+     * mapped to the `SUPER` type, see `getDataTypeSql`). Redshift's real answer to
+     * shredding nested/array `SUPER` data is `UNNEST`/implicit lateral unnest over a
+     * `SUPER` column already stored in a table, not a general `(json, path) => rows`
+     * function that can operate on an arbitrary JSON expression, so it cannot be exposed
+     * through this API shape.
+     */
+    buildJsonTable(_jsonExpression, _rowPath, _columns, _alias) {
+        throw new index_1.DatabaseError('Redshift does not support JSON_TABLE, OPENJSON, or json_to_recordset/jsonb_to_recordset; ' +
+            'shredding SUPER arrays requires UNNEST over a stored SUPER column, not an arbitrary JSON expression');
+    }
+}
+exports.RedshiftDialect = RedshiftDialect;
+// ---------------------------------------------------------------------------
+// Transactions
+// ---------------------------------------------------------------------------
+/**
+ * Redshift only supports two isolation levels: READ COMMITTED (the
+ * default) and SERIALIZABLE. Unlike Postgres, it has no MVCC snapshot
+ * mode equivalent to REPEATABLE READ, and no dirty-read mode (READ
+ * UNCOMMITTED). Requesting either of those would silently give the caller
+ * a *different, unrequested* isolation guarantee if we just ignored the
+ * option, so both are rejected outright instead.
+ */
+RedshiftDialect.SUPPORTED_ISOLATION_LEVELS = new Set(['READ COMMITTED', 'SERIALIZABLE']);
+/**
+ * Transaction handle for Redshift, backed by a single pooled `pg` client.
+ */
+class RedshiftTransaction {
+    constructor(client, _depth, options) {
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        this.client = null;
+        this.savepointCount = 0;
+        this.id = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.options = options || {};
+        this.client = client;
+    }
+    async createSavepoint(name) {
+        const savepointName = name || `sp_${this.savepointCount++}`;
+        if (this.client) {
+            await this.client.query(`SAVEPOINT ${savepointName}`);
+            this.savepoints.push(savepointName);
+        }
+        return savepointName;
+    }
+    async rollbackToSavepoint(name) {
+        if (this.client)
+            await this.client.query(`ROLLBACK TO SAVEPOINT ${name}`);
+    }
+    async releaseSavepoint(name) {
+        if (this.client) {
+            await this.client.query(`RELEASE SAVEPOINT ${name}`);
+            this.savepoints = this.savepoints.filter((sp) => sp !== name);
+        }
+    }
+    async commit() {
+        if (this.client)
+            await this.client.query('COMMIT');
+        this.finished = true;
+    }
+    async rollback() {
+        if (this.client)
+            await this.client.query('ROLLBACK');
+        this.finished = true;
+    }
+}
+exports.RedshiftTransaction = RedshiftTransaction;
+/**
+ * Create a new Redshift dialect instance.
+ */
+function createRedshiftDialect(options) {
+    return new RedshiftDialect(options || {});
+}
+exports.default = RedshiftDialect;