ts-prorm-orm 1.1.0

package/dist/dialects/snowflake/index.js

@@ -0,0 +1,2082 @@
+"use strict";
+/**
+ * Snowflake dialect implementation for the TypeScript ORM
+ *
+ * Notes on Snowflake-specific semantics that differ from most other dialects
+ * implemented in this project:
+ *  - Snowflake has no traditional B-tree indexes. Storage is organized via
+ *    automatic micro-partitioning, and the closest user-facing concept is a
+ *    "clustering key" (ALTER TABLE ... CLUSTER BY (...)). Index-shaped
+ *    interface methods (addIndex/createIndex/removeIndex/dropIndex/etc.) are
+ *    therefore implemented as documented no-ops that emit a console warning,
+ *    mirroring how src/dialects/sqlite/index.ts handles options that are
+ *    accepted for interface-compatibility but have no real effect for that
+ *    dialect (e.g. `engine`/`charset`/table comments).
+ *  - Semi-structured data uses VARIANT/OBJECT/ARRAY types with PARSE_JSON(),
+ *    `:` path access and GET/GET_PATH functions instead of JSON/JSONB.
+ *  - Upserts use MERGE INTO (standard SQL, well supported).
+ *  - Pagination uses standard LIMIT/OFFSET (unlike Oracle/MSSQL's
+ *    OFFSET...FETCH-only style).
+ *  - Auto-increment uses AUTOINCREMENT/IDENTITY column properties.
+ *  - Sequences are supported via CREATE SEQUENCE / NEXTVAL.
+ *  - Connections require an "account" identifier and may specify a
+ *    "warehouse" (the compute resource that must be active for queries to
+ *    run). If provided, `USE WAREHOUSE <name>` is issued right after connect.
+ *  - Auth supports both password auth and key-pair auth (privateKey /
+ *    privateKeyPath), matching the snowflake-sdk driver's ConnectionOptions.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowflakeDialect = void 0;
+const snowflake_sdk_1 = __importDefault(require("snowflake-sdk"));
+const types_1 = require("../../types");
+const query_stream_helper_1 = require("../query-stream-helper");
+const prorm_1 = require("../../prorm");
+/**
+ * Default retry options for connection/query errors
+ */
+const DEFAULT_RETRY_OPTIONS = {
+    max: 3,
+    timeout: 1000,
+    match: [
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ETIMEDOUT',
+        'connection timeout',
+        'connect timeout',
+        'Connection is down',
+        // Transient warehouse states worth retrying (auto-suspend/resume churn).
+        // Deliberately NOT the bare word 'warehouse' — that would also match
+        // permanent, non-transient errors like "warehouse does not exist" or
+        // permission-denied messages that merely mention a warehouse name,
+        // wasting time on retries that can never succeed and masking real
+        // configuration problems from the caller.
+        'warehouse is currently suspended',
+        'warehouse is resuming',
+        'warehouse is being resized',
+    ],
+    backoff: false,
+    backoffMultiplier: 2,
+    backoffMax: 10000,
+};
+class SnowflakeDialect {
+    constructor(config) {
+        this.name = 'snowflake';
+        this.library = 'snowflake-sdk';
+        this.connection = null;
+        this._isConnected = false;
+        this.config = { ...config };
+        this.retryOptions = config.retry || {};
+    }
+    // ---------------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------------
+    /**
+     * Connect to Snowflake. Wraps the callback-based snowflake-sdk API
+     * (`createConnection(...).connect(callback)`) in a Promise. If a
+     * `warehouse` was configured, activates it with `USE WAREHOUSE` right
+     * after the connection is established.
+     */
+    async connect() {
+        const options = {
+            account: this.config.account,
+            username: this.config.username,
+            password: this.config.password,
+            database: this.config.database,
+            schema: this.config.schema,
+            warehouse: this.config.warehouse,
+            role: this.config.role,
+            privateKey: this.config.privateKey,
+            privateKeyPath: this.config.privateKeyPath,
+            privateKeyPass: this.config.privateKeyPass,
+            authenticator: this.config.authenticator,
+            application: this.config.application,
+            clientSessionKeepAlive: this.config.clientSessionKeepAlive,
+        };
+        try {
+            const conn = snowflake_sdk_1.default.createConnection(options);
+            await new Promise((resolve, reject) => {
+                conn.connect((err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            this.connection = conn;
+            this._isConnected = true;
+            if (this.config.warehouse) {
+                await this.query(`USE WAREHOUSE ${this.quoteIdentifier(this.config.warehouse)}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Snowflake database: ${error}`);
+        }
+    }
+    /**
+     * Disconnect from Snowflake, terminating the connection immediately.
+     *
+     * A failed `destroy()` callback is surfaced by rejecting this promise
+     * (rather than silently resolving as if the disconnect succeeded), so
+     * callers relying on disconnect() aren't misled into thinking the
+     * underlying socket was cleanly torn down. The local connection state is
+     * still cleared in a `finally` regardless of outcome, since from this
+     * dialect's perspective the connection should no longer be used either way.
+     */
+    async disconnect() {
+        if (this.connection) {
+            const conn = this.connection;
+            try {
+                await new Promise((resolve, reject) => {
+                    conn.destroy((err) => {
+                        if (err) {
+                            reject(new Error(`Failed to disconnect from Snowflake: ${err.message || err}`));
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            }
+            finally {
+                this.connection = null;
+                this._isConnected = false;
+            }
+        }
+    }
+    getConnection() {
+        return this.connection;
+    }
+    isConnected() {
+        return this._isConnected && this.connection !== null && this.connection.isUp();
+    }
+    /**
+     * Builds the shared `complete` callback used by both `query()` and
+     * `queryWithCancel()` to translate a snowflake-sdk statement completion
+     * into a resolved/rejected `QueryResult` promise.
+     */
+    makeCompleteHandler(resolve, reject) {
+        return (err, stmt, rows) => {
+            if (err) {
+                reject(new Error(`Snowflake Query error: ${err.message || err}`));
+                return;
+            }
+            const resultRows = rows || [];
+            const columns = stmt.getColumns ? stmt.getColumns() : undefined;
+            const fields = columns
+                ? columns.map((col) => ({
+                    name: typeof col.getName === 'function' ? col.getName() : col.name,
+                    type: typeof col.getType === 'function' ? col.getType() : 'VARIANT',
+                    length: 0,
+                    tableID: 0,
+                    columnID: 0,
+                    nullable: typeof col.isNullable === 'function' ? col.isNullable() : true,
+                    isEnum: false,
+                    isPrimaryKey: false,
+                }))
+                : [];
+            resolve({
+                rows: resultRows,
+                rowCount: stmt.getNumRows ? stmt.getNumRows() : resultRows.length,
+                fields,
+            });
+        };
+    }
+    resolveExecuteArgs(sql, options) {
+        const replacements = options?.replacements;
+        const binds = Array.isArray(replacements) ? replacements : undefined;
+        const finalSql = replacements !== undefined && !Array.isArray(replacements)
+            ? this.replaceReplacements(sql, replacements)
+            : sql;
+        return { sqlText: finalSql, binds };
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Execute a raw SQL query, wrapping the callback-based
+     * `connection.execute({ sqlText, binds, complete })` API in a Promise.
+     */
+    async query(sql, options) {
+        const executeQuery = async () => {
+            if (!this.connection) {
+                throw new Error('Not connected to database');
+            }
+            const { sqlText, binds } = this.resolveExecuteArgs(sql, options);
+            return new Promise((resolve, reject) => {
+                this.connection.execute({
+                    sqlText,
+                    binds: binds,
+                    complete: this.makeCompleteHandler(resolve, reject),
+                });
+            });
+        };
+        const retryConfig = { ...DEFAULT_RETRY_OPTIONS, ...this.retryOptions };
+        if (retryConfig.max && retryConfig.max > 0) {
+            return this.executeWithRetry(executeQuery, retryConfig);
+        }
+        return executeQuery();
+    }
+    /**
+     * Execute a query and return a handle that allows cancelling it before it
+     * completes, via snowflake-sdk's `Statement.cancel()` API. This is the
+     * long-running-query abort path that plain `query()` does not offer: once
+     * a query has been submitted, `query()` gives the caller no way to stop it
+     * short of waiting (or retrying, which only compounds wait time under
+     * warehouse auto-suspend/resume scenarios).
+     *
+     * Unlike `query()`, this method does not go through the retry wrapper —
+     * callers that need cancellation are expected to manage their own
+     * retry/backoff around the returned `result` promise if desired.
+     */
+    queryWithCancel(sql, options) {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        const { sqlText, binds } = this.resolveExecuteArgs(sql, options);
+        let statement;
+        const result = new Promise((resolve, reject) => {
+            statement = this.connection.execute({
+                sqlText,
+                binds: binds,
+                complete: this.makeCompleteHandler(resolve, reject),
+            });
+        });
+        const cancel = () => new Promise((resolve, reject) => {
+            const stmt = statement;
+            if (!stmt || typeof stmt.cancel !== 'function') {
+                resolve();
+                return;
+            }
+            stmt.cancel((err) => {
+                if (err) {
+                    reject(new Error(`Failed to cancel Snowflake statement: ${err.message || err}`));
+                    return;
+                }
+                resolve();
+            });
+        });
+        const getQueryId = () => {
+            const stmt = statement;
+            return stmt && typeof stmt.getQueryId === 'function' ? stmt.getQueryId() : undefined;
+        };
+        return { result, cancel, getQueryId };
+    }
+    async executeWithRetry(fn, retryOptions) {
+        let lastError;
+        for (let attempt = 0; attempt <= retryOptions.max; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const message = lastError.message.toLowerCase();
+                const shouldRetry = retryOptions.match.some((pattern) => message.includes(pattern.toLowerCase()));
+                if (!shouldRetry || attempt === retryOptions.max) {
+                    throw lastError;
+                }
+                const delay = retryOptions.backoff
+                    ? Math.min(retryOptions.timeout * Math.pow(retryOptions.backoffMultiplier || 2, attempt), retryOptions.backoffMax || 10000)
+                    : retryOptions.timeout;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        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 === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (value instanceof Date) {
+            return `'${this.formatDate(value)}'`;
+        }
+        if (Buffer.isBuffer(value)) {
+            return `TO_BINARY('${value.toString('hex')}', 'HEX')`;
+        }
+        if (Array.isArray(value)) {
+            // Represent as an Snowflake ARRAY literal via PARSE_JSON
+            return `PARSE_JSON('${this.escapeString(JSON.stringify(value))}')`;
+        }
+        // Objects map to VARIANT/OBJECT using PARSE_JSON
+        return `PARSE_JSON('${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) {
+            return `${this.escapeId(schema)}.${this.escapeId(tableName)}`;
+        }
+        if (this.config.schema) {
+            return `${this.escapeId(this.config.schema)}.${this.escapeId(tableName)}`;
+        }
+        return this.escapeId(tableName);
+    }
+    // ---------------------------------------------------------------------------
+    // Schemas / database
+    // ---------------------------------------------------------------------------
+    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 ('INFORMATION_SCHEMA')`);
+        return result.rows?.map((row) => row.SCHEMA_NAME || row.schema_name) || [];
+    }
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    createDatabaseSQL(options) {
+        return `CREATE DATABASE ${this.quoteIdentifier(options.name)}`;
+    }
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE IF EXISTS ${this.quoteIdentifier(name)}`;
+    }
+    createSavepointSQL(name) {
+        // Snowflake does not support savepoints; this is a documented no-op that
+        // returns an inert SQL comment so callers that always issue this SQL
+        // don't blow up. Real transactional rollback should use ROLLBACK.
+        const savepointName = name || `sp_${Date.now()}`;
+        console.warn(`Snowflake: savepoints are not supported; '${savepointName}' will not create a real savepoint`);
+        return `-- SAVEPOINT ${savepointName} (no-op: not supported by Snowflake)`;
+    }
+    releaseSavepointSQL(name) {
+        return `-- RELEASE SAVEPOINT ${name} (no-op: not supported by Snowflake)`;
+    }
+    rollbackToSavepointSQL(name) {
+        return `-- ROLLBACK TO SAVEPOINT ${name} (no-op: not supported by Snowflake)`;
+    }
+    // Extensions are a PostgreSQL-only concept
+    createExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    getExtensions() {
+        throw new Error('Extensions are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    hasExtension(_extensionName) {
+        throw new Error('Extensions are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async getDatabaseVersion() {
+        const result = await this.query(`SELECT CURRENT_VERSION() AS version`);
+        return result.rows?.[0]?.VERSION || result.rows?.[0]?.version || 'Unknown';
+    }
+    // ---------------------------------------------------------------------------
+    // Tables / columns
+    // ---------------------------------------------------------------------------
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.getColumnDefinitionSql(columnName, definition));
+        }
+        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.quoteTable(tableName)} (${columnDefs.join(', ')})`;
+        if (options?.comment) {
+            sql += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        }
+        if (options?.engine) {
+            console.warn(`Snowflake: engine option '${options.engine}' is not supported and will be ignored`);
+        }
+        if (options?.charset) {
+            console.warn(`Snowflake: charset option '${options.charset}' is not supported and will be ignored`);
+        }
+        if (options?.rowFormat) {
+            console.warn(`Snowflake: rowFormat option '${options.rowFormat}' is not supported and will be ignored`);
+        }
+        if (options?.tablespace) {
+            console.warn('Snowflake: tablespaces are not supported and will be ignored');
+        }
+        await this.query(sql);
+        if (options?.uniqueKeys) {
+            const entries = Array.isArray(options.uniqueKeys)
+                ? options.uniqueKeys.map((uk) => [uk.name, uk.fields])
+                : Object.entries(options.uniqueKeys);
+            for (const [keyName, fields] of entries) {
+                const constraintName = keyName || `uq_${tableName}_${fields.join('_')}`;
+                await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} UNIQUE (${fields
+                    .map((f) => this.escapeId(f))
+                    .join(', ')})`);
+            }
+        }
+        // Index-like options are not applicable to Snowflake's storage engine;
+        // addIndex() itself documents and no-ops this, so we simply delegate.
+        if (options?.indexes) {
+            for (const index of options.indexes) {
+                await this.addIndex(tableName, index.name || `idx_${tableName}_${index.fields.join('_')}`, index.fields, { unique: index.unique });
+            }
+        }
+    }
+    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 ? `CONSTRAINT ${name} ` : ''}PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${name ? `CONSTRAINT ${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)})`;
+                let fkSql = `${name ? `CONSTRAINT ${name} ` : ''}FOREIGN KEY (${fields}) REFERENCES ${this.escapeId(constraint.references.table)}${refFieldSql}`;
+                if (constraint.references.onDelete)
+                    fkSql += ` ON DELETE ${constraint.references.onDelete}`;
+                if (constraint.references.onUpdate)
+                    fkSql += ` ON UPDATE ${constraint.references.onUpdate}`;
+                return fkSql;
+            }
+            case 'CHECK':
+                if (!constraint.check)
+                    return null;
+                return `${name ? `CONSTRAINT ${name} ` : ''}CHECK (${constraint.check})`;
+            default:
+                return null;
+        }
+    }
+    getColumnDefinitionSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.autoIncrement) {
+            sql += ' AUTOINCREMENT';
+        }
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.getDefaultValue(definition.defaultValue)}`;
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.unique) {
+            sql += ' UNIQUE';
+        }
+        if (definition.references) {
+            const refField = definition.references.field;
+            const refFieldSql = Array.isArray(refField)
+                ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                : this.escapeId(refField);
+            sql += ` REFERENCES ${this.escapeId(definition.references.table)}(${refFieldSql})`;
+            if (definition.references.onDelete)
+                sql += ` ON DELETE ${definition.references.onDelete}`;
+            if (definition.references.onUpdate)
+                sql += ` ON UPDATE ${definition.references.onUpdate}`;
+        }
+        if (definition.comment) {
+            sql += ` COMMENT '${this.escapeString(definition.comment)}'`;
+        }
+        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.quoteTable(tableName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    // Native range/list/hash partitioning is not a user-facing Snowflake
+    // concept (micro-partitioning is automatic); these throw clear errors
+    // rather than emitting invalid SQL, consistent with SQLite's handling of
+    // partitioning in this codebase.
+    async createPartitionedTable() {
+        throw new Error('Table partitioning is not supported by Snowflake. Snowflake automatically manages ' +
+            'micro-partitions; consider a clustering key (ALTER TABLE ... CLUSTER BY (...)) instead.');
+    }
+    async createPartition(_options) {
+        throw new Error('Table partitioning is not supported by Snowflake.');
+    }
+    async attachPartition(_options) {
+        throw new Error('Table partitioning is not supported by Snowflake.');
+    }
+    async detachPartition(_options) {
+        throw new Error('Table partitioning is not supported by Snowflake.');
+    }
+    async dropPartition() {
+        throw new Error('Table partitioning is not supported by Snowflake.');
+    }
+    /**
+     * Set (or clear) a clustering key for a table — Snowflake's replacement
+     * for manual indexing/partitioning to influence micro-partition pruning.
+     */
+    async setClusteringKey(tableName, fields) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} CLUSTER BY (${fields
+            .map((f) => this.escapeId(f))
+            .join(', ')})`;
+        await this.query(sql);
+    }
+    async dropClusteringKey(tableName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} DROP CLUSTERING KEY`);
+    }
+    // ---------------------------------------------------------------------------
+    // Views
+    // ---------------------------------------------------------------------------
+    async createView(viewName, query, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE VIEW' : 'CREATE VIEW';
+        sql += ` ${this.quoteTable(viewName, options?.schema)}`;
+        if (options?.comment) {
+            sql += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        }
+        sql += ` AS ${query}`;
+        await this.query(sql);
+    }
+    async dropView(viewName, options) {
+        let sql = 'DROP VIEW';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.quoteTable(viewName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async showViews() {
+        const result = await this.query('SHOW VIEWS');
+        return result.rows?.map((row) => row.name || row.NAME) || [];
+    }
+    async showMaterializedViews() {
+        const result = await this.query('SHOW MATERIALIZED VIEWS');
+        return result.rows?.map((row) => row.name || row.NAME) || [];
+    }
+    // ---------------------------------------------------------------------------
+    // Columns / constraints / tables metadata
+    // ---------------------------------------------------------------------------
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD COLUMN ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    async removeColumn(tableName, columnName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} DROP COLUMN ${this.escapeId(columnName)}`);
+    }
+    async changeColumn(tableName, columnName, definition) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ALTER COLUMN ${this.escapeId(columnName)} SET DATA TYPE ${this.getDataTypeSql(definition.type)}`);
+        if (definition.allowNull === false) {
+            await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ALTER COLUMN ${this.escapeId(columnName)} SET NOT NULL`);
+        }
+        else if (definition.allowNull === true) {
+            await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ALTER COLUMN ${this.escapeId(columnName)} DROP NOT NULL`);
+        }
+        if (definition.defaultValue !== undefined) {
+            await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ALTER COLUMN ${this.escapeId(columnName)} SET DEFAULT ${this.getDefaultValue(definition.defaultValue)}`);
+        }
+    }
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} RENAME COLUMN ${this.escapeId(oldColumnName)} TO ${this.escapeId(newColumnName)}`);
+    }
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        const constraintName = options?.name || `fk_${tableName}_${columnName}`;
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)} (${this.escapeId(referencedColumnName)})`;
+        if (options?.onDelete)
+            sql += ` ON DELETE ${options.onDelete}`;
+        if (options?.onUpdate)
+            sql += ` ON UPDATE ${options.onUpdate}`;
+        await this.query(sql);
+    }
+    async bulkInsert(tableName, records, _options) {
+        if (records.length === 0) {
+            return { rows: [], rowCount: 0, fields: [] };
+        }
+        const columns = Object.keys(records[0]);
+        const values = [];
+        const placeholders = [];
+        for (const record of records) {
+            const rowPlaceholders = columns.map((c) => {
+                values.push(record[c]);
+                return '?';
+            });
+            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 });
+    }
+    async showTables() {
+        const result = await this.query('SHOW TABLES');
+        return result.rows?.map((row) => row.name || row.NAME) || [];
+    }
+    async showConstraints(tableName) {
+        const result = await this.query(`SHOW UNIQUE KEYS IN TABLE ${this.quoteTable(tableName)}`);
+        return result.rows || [];
+    }
+    async addConstraint(tableName, options) {
+        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.quoteTable(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.quoteTable(options.references.table)} (${options.references.fields
+                    .map((f) => this.escapeId(f))
+                    .join(', ')})`;
+                break;
+            case 'CHECK':
+                sql += `CHECK (${options.check})`;
+                break;
+        }
+        await this.query(sql);
+    }
+    async removeConstraint(tableName, constraintName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} DROP CONSTRAINT ${this.escapeId(constraintName)}`);
+    }
+    /**
+     * Snowflake has no traditional indexes; it returns an empty list rather
+     * than throwing so generic ORM code paths that inspect "current indexes"
+     * degrade gracefully.
+     */
+    async showIndexes(_tableName) {
+        console.warn('Snowflake: showIndexes() is a no-op — Snowflake has no traditional indexes (micro-partitioning ' +
+            'and clustering keys are used instead). Returning an empty array.');
+        return [];
+    }
+    async describeTable(tableName) {
+        const result = await this.query(`DESCRIBE TABLE ${this.quoteTable(tableName)}`);
+        const description = {};
+        for (const row of result.rows || []) {
+            const name = row.name || row.NAME;
+            const type = String(row.type || row.TYPE || '');
+            const isNullable = (row['null?'] ?? row['NULL?'] ?? 'Y') === 'Y';
+            const defaultValue = row.default ?? row.DEFAULT ?? null;
+            const isPrimaryKey = (row['primary key'] ?? row['PRIMARY KEY'] ?? 'N') === 'Y';
+            description[name] = {
+                type,
+                allowNull: isNullable,
+                defaultValue,
+                primaryKey: isPrimaryKey,
+                autoIncrement: /AUTOINCREMENT|IDENTITY/i.test(String(row.default ?? row.DEFAULT ?? '')),
+            };
+        }
+        return description;
+    }
+    async renameTable(oldName, newName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(oldName)} RENAME TO ${this.quoteTable(newName)}`);
+    }
+    // ---------------------------------------------------------------------------
+    // Indexes — Snowflake has no traditional index structures. These are
+    // documented no-ops (they warn instead of throwing) so ORM-level code that
+    // unconditionally calls addIndex/createIndex/etc. after createTable (as
+    // this dialect's own createTable does) keeps working across all dialects.
+    // ---------------------------------------------------------------------------
+    async addIndex(tableName, indexName, _fields, _options) {
+        console.warn(`Snowflake: addIndex('${indexName}' on '${tableName}') is a no-op — Snowflake has no traditional ` +
+            'indexes. Use a clustering key (setClusteringKey) to influence micro-partition pruning instead.');
+    }
+    async removeIndex(tableName, indexName) {
+        console.warn(`Snowflake: removeIndex('${indexName}' on '${tableName}') is a no-op — Snowflake has no traditional indexes.`);
+    }
+    async createIndex(tableName, indexDef) {
+        console.warn(`Snowflake: createIndex('${indexDef.name}' on '${tableName}') is a no-op — Snowflake has no traditional indexes.`);
+    }
+    async dropIndex(tableName, indexName, _options) {
+        console.warn(`Snowflake: dropIndex('${indexName}' on '${tableName}') is a no-op — Snowflake has no traditional indexes.`);
+    }
+    async createFulltextIndex(tableName, indexName, _fields, _options) {
+        console.warn(`Snowflake: createFulltextIndex('${indexName}' on '${tableName}') is a no-op — Snowflake has no ` +
+            'fulltext index concept; consider Snowflake Search (CORTEX SEARCH) or SEARCH OPTIMIZATION instead.');
+    }
+    async createSpatialIndex(tableName, indexName, _fields, _options) {
+        console.warn(`Snowflake: createSpatialIndex('${indexName}' on '${tableName}') is a no-op — Snowflake has no spatial index concept.`);
+    }
+    async createConstraint(tableName, constraintDef) {
+        const sql = this.buildConstraintSql({
+            name: constraintDef.name,
+            type: constraintDef.type,
+            fields: constraintDef.fields,
+            references: constraintDef.references
+                ? {
+                    table: constraintDef.references.table,
+                    field: constraintDef.references.field,
+                    onDelete: constraintDef.references.onDelete,
+                    onUpdate: constraintDef.references.onUpdate,
+                }
+                : undefined,
+            check: constraintDef.check,
+        });
+        if (sql) {
+            await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ADD ${sql}`);
+        }
+    }
+    async dropConstraint(tableName, constraintName, options) {
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} DROP CONSTRAINT`;
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(constraintName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async changeOwner(newOwner, tableName) {
+        await this.query(`GRANT OWNERSHIP ON TABLE ${this.quoteTable(tableName)} TO ROLE ${this.escapeId(newOwner)}`);
+    }
+    // ---------------------------------------------------------------------------
+    // Foreign Data Wrappers — not a Snowflake concept (external tables /
+    // stages / integrations serve a similar purpose but are not equivalent).
+    // ---------------------------------------------------------------------------
+    async createForeignDataWrapper() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignDataWrapper() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignServer() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignServer() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignTable() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async createSecurityPolicy(_policyName, _tableName, _options) {
+        throw new Error('createSecurityPolicy is not supported by the Snowflake dialect; use Snowflake row access ' +
+            'policies (CREATE ROW ACCESS POLICY / ALTER TABLE ... ADD ROW ACCESS POLICY) directly.');
+    }
+    async dropSecurityPolicy(_policyName, _tableName) {
+        throw new Error('dropSecurityPolicy is not supported by the Snowflake dialect');
+    }
+    // ---------------------------------------------------------------------------
+    // Transactions
+    // ---------------------------------------------------------------------------
+    async startTransaction(_options) {
+        await this.query('BEGIN');
+        return new types_1.Transaction({ autocommit: false });
+    }
+    async commitTransaction(_transaction) {
+        await this.query('COMMIT');
+    }
+    async rollbackTransaction(_transaction) {
+        await this.query('ROLLBACK');
+    }
+    // ---------------------------------------------------------------------------
+    // Data types
+    // ---------------------------------------------------------------------------
+    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 'VARCHAR';
+            case 'INTEGER':
+                return 'NUMBER(38,0)';
+            case 'BIGINT':
+                return 'NUMBER(38,0)';
+            case 'FLOAT':
+                return 'FLOAT';
+            case 'DOUBLE':
+                return 'DOUBLE';
+            case 'DECIMAL':
+                return `NUMBER(${dt.precision || 38},${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+                return dt.precision ? `TIMESTAMP_NTZ(${dt.precision})` : 'TIMESTAMP_NTZ';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return dt.precision ? `TIME(${dt.precision})` : 'TIME';
+            case 'BLOB':
+                return 'BINARY';
+            case 'ENUM':
+                // Snowflake has no native ENUM type; approximate with VARCHAR plus a
+                // CHECK constraint would be added at the table level by callers.
+                return 'VARCHAR';
+            // Semi-structured types: Snowflake uses VARIANT/OBJECT/ARRAY instead of
+            // JSON/JSONB. VARIANT can hold any semi-structured value and is queried
+            // with `:`-path syntax or GET()/GET_PATH(), so JSON/JSONB map to it.
+            case 'JSON':
+            case 'JSONB':
+                return 'VARIANT';
+            case 'UUID':
+                return 'VARCHAR(36)';
+            case 'ARRAY':
+                return 'ARRAY';
+            case 'GEOMETRY':
+            case 'GEOGRAPHY':
+                return 'GEOGRAPHY';
+            case 'VIRTUAL':
+                return '';
+            default:
+                return 'VARCHAR(255)';
+        }
+    }
+    /**
+     * Build a Snowflake VARIANT/OBJECT path query using `:` path access
+     * (e.g. `data:key::STRING`) rather than JSON_EXTRACT.
+     */
+    buildJsonQuery(column, path, value, operator = '=') {
+        const values = [];
+        const columnRef = this.quoteIdentifier(column);
+        const pathAccess = path
+            .split('.')
+            .map((p, i) => (i === 0 ? `:${p}` : `.${p}`))
+            .join('');
+        const extraction = `${columnRef}${pathAccess}::STRING`;
+        if (value !== undefined) {
+            values.push(value);
+            return { sql: `${extraction} ${operator} ?`, values };
+        }
+        return { sql: extraction, values };
+    }
+    // ---------------------------------------------------------------------------
+    // Query builders
+    // ---------------------------------------------------------------------------
+    buildWhereClause(where, _options) {
+        const values = [];
+        if (!where || Object.keys(where).length === 0) {
+            return { sql: '', values };
+        }
+        const buildCondition = (condition) => {
+            if (!condition)
+                return '';
+            if (typeof condition !== 'object') {
+                values.push(condition);
+                return '?';
+            }
+            const cond = condition;
+            // Handle logical operators
+            if (cond.$and || cond.$or || cond.$not) {
+                const conditions = [];
+                if (cond.$and) {
+                    const andConditions = cond.$and.map((c) => buildCondition(c));
+                    conditions.push(`(${andConditions.join(' AND ')})`);
+                }
+                if (cond.$or) {
+                    const orConditions = cond.$or.map((c) => buildCondition(c));
+                    conditions.push(`(${orConditions.join(' OR ')})`);
+                }
+                if (cond.$not) {
+                    const result = buildCondition(cond.$not);
+                    conditions.push(`NOT (${result})`);
+                }
+                return conditions.join(' AND ');
+            }
+            // Handle field conditions
+            const fieldConditions = [];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key.startsWith('$'))
+                    continue;
+                if (value === null) {
+                    fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (const v of value)
+                        values.push(v);
+                    fieldConditions.push(`${this.escapeId(key)} IN (${value.map(() => '?').join(', ')})`);
+                    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)} = ?`);
+                    }
+                    else if (valueObj.$ne !== undefined) {
+                        values.push(valueObj.$ne);
+                        fieldConditions.push(`${this.escapeId(key)} != ?`);
+                    }
+                    else if (valueObj.$gt !== undefined) {
+                        values.push(valueObj.$gt);
+                        fieldConditions.push(`${this.escapeId(key)} > ?`);
+                    }
+                    else if (valueObj.$gte !== undefined) {
+                        values.push(valueObj.$gte);
+                        fieldConditions.push(`${this.escapeId(key)} >= ?`);
+                    }
+                    else if (valueObj.$lt !== undefined) {
+                        values.push(valueObj.$lt);
+                        fieldConditions.push(`${this.escapeId(key)} < ?`);
+                    }
+                    else if (valueObj.$lte !== undefined) {
+                        values.push(valueObj.$lte);
+                        fieldConditions.push(`${this.escapeId(key)} <= ?`);
+                    }
+                    else if (valueObj.$like !== undefined) {
+                        values.push(valueObj.$like);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notLike !== undefined) {
+                        values.push(valueObj.$notLike);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$iLike !== undefined) {
+                        values.push(valueObj.$iLike);
+                        fieldConditions.push(`ILIKE(${this.escapeId(key)}, ?)`);
+                    }
+                    else if (valueObj.$notILike !== undefined) {
+                        values.push(valueObj.$notILike);
+                        fieldConditions.push(`NOT ILIKE(${this.escapeId(key)}, ?)`);
+                    }
+                    else if (valueObj.$startsWith !== undefined) {
+                        values.push(`${valueObj.$startsWith}%`);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notStartsWith !== undefined) {
+                        values.push(`${valueObj.$notStartsWith}%`);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$endsWith !== undefined) {
+                        values.push(`%${valueObj.$endsWith}`);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notEndsWith !== undefined) {
+                        values.push(`%${valueObj.$notEndsWith}`);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$substring !== undefined) {
+                        values.push(`%${valueObj.$substring}%`);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notSubstring !== undefined) {
+                        values.push(`%${valueObj.$notSubstring}%`);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$in) {
+                        const inValues = valueObj.$in;
+                        values.push(...inValues);
+                        fieldConditions.push(`${this.escapeId(key)} IN (${inValues.map(() => '?').join(', ')})`);
+                    }
+                    else if (valueObj.$notIn) {
+                        const notInValues = valueObj.$notIn;
+                        values.push(...notInValues);
+                        fieldConditions.push(`${this.escapeId(key)} NOT IN (${notInValues.map(() => '?').join(', ')})`);
+                    }
+                    else if (valueObj.$between) {
+                        const between = valueObj.$between;
+                        values.push(between[0], between[1]);
+                        fieldConditions.push(`${this.escapeId(key)} BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$notBetween) {
+                        const notBetween = valueObj.$notBetween;
+                        values.push(notBetween[0], notBetween[1]);
+                        fieldConditions.push(`${this.escapeId(key)} NOT BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$isNull !== undefined) {
+                        fieldConditions.push(valueObj.$isNull
+                            ? `${this.escapeId(key)} IS NULL`
+                            : `${this.escapeId(key)} IS NOT NULL`);
+                    }
+                    else {
+                        values.push(value);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                }
+                else {
+                    values.push(value);
+                    fieldConditions.push(`${this.escapeId(key)} = ?`);
+                }
+            }
+            return fieldConditions.join(' AND ');
+        };
+        const sql = buildCondition(where);
+        return { sql, values };
+    }
+    buildOrderClause(order, _options) {
+        if (!order || (Array.isArray(order) && order.length === 0))
+            return '';
+        const orderParts = [];
+        const processOrder = (orderItem) => {
+            if (typeof orderItem === 'string') {
+                const parts = orderItem.split(' ');
+                if (parts.length === 1) {
+                    orderParts.push(this.escapeId(parts[0]));
+                }
+                else {
+                    orderParts.push(`${this.escapeId(parts[0])} ${parts[1].toUpperCase()}`);
+                }
+            }
+            else if (typeof orderItem === 'object' && orderItem !== null) {
+                for (const [key, value] of Object.entries(orderItem)) {
+                    if (key === '$raw') {
+                        orderParts.push(String(value));
+                    }
+                    else {
+                        const direction = value?.toUpperCase() || 'ASC';
+                        orderParts.push(`${this.escapeId(key)} ${direction}`);
+                    }
+                }
+            }
+        };
+        if (Array.isArray(order)) {
+            order.forEach(processOrder);
+        }
+        else {
+            processOrder(order);
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    /**
+     * Snowflake supports standard LIMIT/OFFSET pagination (unlike Oracle/MSSQL's
+     * FETCH FIRST-only style), so this is a direct passthrough.
+     */
+    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) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                placeholders.push(value.val);
+            }
+            else {
+                processedValues.push(value);
+                placeholders.push('?');
+            }
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName, options?.schema)} (${columns
+            .map((c) => this.escapeId(c))
+            .join(', ')}) VALUES (${placeholders.join(', ')})`;
+        // Snowflake's INSERT does not support a RETURNING clause; callers should
+        // follow up with a SELECT if they need the inserted row back.
+        return { sql, values: processedValues };
+    }
+    buildUpdateQuery(tableName, values, where, options) {
+        const processedValues = [];
+        const setClauses = [];
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                processedValues.push(value);
+                setClauses.push(`${this.escapeId(key)} = ?`);
+            }
+        }
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClauses.join(', ')}`;
+        if (where && Object.keys(where).length > 0) {
+            const whereClause = this.buildWhereClause(where);
+            sql += ` WHERE ${whereClause.sql}`;
+            processedValues.push(...whereClause.values);
+        }
+        if (options?.limit) {
+            console.warn('Snowflake: UPDATE does not support LIMIT; the limit option will be ignored');
+        }
+        return { sql, values: processedValues };
+    }
+    buildDeleteQuery(tableName, where, options) {
+        if (options?.truncate) {
+            return { sql: `TRUNCATE TABLE ${this.quoteTable(tableName)}`, values: [] };
+        }
+        let sql = `DELETE FROM ${this.quoteTable(tableName)}`;
+        const processedValues = [];
+        if (where && Object.keys(where).length > 0) {
+            const whereClause = this.buildWhereClause(where);
+            sql += ` WHERE ${whereClause.sql}`;
+            processedValues.push(...whereClause.values);
+        }
+        if (options?.limit) {
+            console.warn('Snowflake: DELETE does not support LIMIT; the limit option will be ignored');
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Formats a single SELECT attribute. Plain column names are identifier-
+     * quoted as before; entries that look like SQL expressions rather than
+     * bare identifiers (e.g. window functions like
+     * `ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn`, or
+     * any other expression containing parentheses/whitespace/an `AS` alias)
+     * are passed through unescaped so callers can use analytical SQL that a
+     * plain identifier-quoting pass would otherwise mangle.
+     */
+    formatSelectAttribute(attribute) {
+        if (attribute === '*')
+            return attribute;
+        if (/[\s(]/.test(attribute)) {
+            // Looks like a raw SQL expression (function call, window function,
+            // "expr AS alias", etc.) rather than a bare column name.
+            return attribute;
+        }
+        return this.escapeId(attribute);
+    }
+    /**
+     * Builds a `WITH [RECURSIVE] ...` prefix from `options.cte`, Snowflake's
+     * (standard-SQL) Common Table Expression syntax. Each entry may set its
+     * own `recursive` flag; if any entry is recursive the whole `WITH` clause
+     * is emitted as `WITH RECURSIVE` (Snowflake, like most engines, applies
+     * RECURSIVE to the entire WITH clause rather than per-CTE).
+     */
+    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(', ')})` : '';
+            return `${this.escapeId(c.name)}${columns} AS (${c.query})`;
+        })
+            .join(', ');
+        return `WITH ${recursive ? 'RECURSIVE ' : ''}${body} `;
+    }
+    /**
+     * Builds Snowflake's Time Travel clause (`AT(...)`/`BEFORE(...)`) to
+     * append right after a table reference in the FROM clause, e.g.
+     * `FROM "T" AT(TIMESTAMP => '2024-01-01 00:00:00')`.
+     */
+    buildTimeTravelClause(options) {
+        if (options.atTimestamp !== undefined) {
+            const ts = options.atTimestamp instanceof Date
+                ? this.formatDate(options.atTimestamp)
+                : options.atTimestamp;
+            return ` AT(TIMESTAMP => '${this.escapeString(String(ts))}'::TIMESTAMP_LTZ)`;
+        }
+        if (options.atOffset !== undefined) {
+            return ` AT(OFFSET => ${Number(options.atOffset)})`;
+        }
+        if (options.atStatement !== undefined) {
+            return ` AT(STATEMENT => '${this.escapeString(options.atStatement)}')`;
+        }
+        if (options.beforeStatement !== undefined) {
+            return ` BEFORE(STATEMENT => '${this.escapeString(options.beforeStatement)}')`;
+        }
+        return '';
+    }
+    buildSelectQuery(options) {
+        const queryValues = [];
+        const extended = options;
+        let sql = this.buildCteClause(extended.cte);
+        sql += 'SELECT';
+        if (options.distinct)
+            sql += ' DISTINCT';
+        if (options.attributes) {
+            if (Array.isArray(options.attributes)) {
+                sql += ` ${options.attributes.map((c) => this.formatSelectAttribute(c)).join(', ')}`;
+            }
+            else if (options.attributes.include) {
+                sql += ` ${options.attributes.include.map((c) => this.escapeId(c)).join(', ')}`;
+            }
+            else {
+                sql += ' *';
+            }
+        }
+        else {
+            sql += ' *';
+        }
+        const tableName = this.quoteTable(options.tableName, options.schema);
+        sql += ` FROM ${tableName}`;
+        const timeTravelClause = this.buildTimeTravelClause(extended);
+        if (timeTravelClause)
+            sql += timeTravelClause;
+        if (options.include && options.include.length > 0) {
+            for (const include of options.include) {
+                const joinType = include.required ? 'INNER JOIN' : 'LEFT JOIN';
+                const joinModel = include.model;
+                const joinTableName = joinModel.tableName || joinModel.name || '';
+                const joinAlias = include.as || joinTableName;
+                sql += ` ${joinType} ${this.quoteTable(joinTableName)} AS ${this.escapeId(joinAlias)}`;
+                if (include.on) {
+                    const onClause = this.buildWhereClause(include.on);
+                    sql += ` ON ${onClause.sql}`;
+                    queryValues.push(...onClause.values);
+                }
+            }
+        }
+        if (options.where && Object.keys(options.where).length > 0) {
+            const whereClause = this.buildWhereClause(options.where);
+            sql += ` WHERE ${whereClause.sql}`;
+            queryValues.push(...whereClause.values);
+        }
+        if (options.group) {
+            const groupBy = Array.isArray(options.group) ? options.group : [options.group];
+            sql += ` GROUP BY ${groupBy.map((g) => this.escapeId(g)).join(', ')}`;
+            if (options.having && Object.keys(options.having).length > 0) {
+                const havingClause = this.buildWhereClause(options.having);
+                sql += ` HAVING ${havingClause.sql}`;
+                queryValues.push(...havingClause.values);
+            }
+        }
+        // QUALIFY filters on the results of window functions without requiring
+        // a wrapping subquery, e.g. `QUALIFY ROW_NUMBER() OVER (...) = 1`.
+        // Supported by Snowflake (and a handful of other analytical warehouses)
+        // but not standard SQL, so it's exposed here as a raw expression string
+        // rather than a structured WhereOptions object.
+        if (extended.qualify) {
+            sql += ` QUALIFY ${extended.qualify}`;
+        }
+        if (options.order) {
+            const orderClause = this.buildOrderClause(options.order);
+            if (orderClause)
+                sql += ` ${orderClause}`;
+        }
+        // Standard LIMIT/OFFSET pagination
+        const limitOffset = this.buildLimitOffset(options.limit, options.offset);
+        if (limitOffset)
+            sql += limitOffset;
+        return { sql, values: queryValues };
+    }
+    /**
+     * Build an upsert using Snowflake's MERGE INTO, which is well-supported
+     * and close to standard SQL MERGE.
+     */
+    buildUpsertQuery(tableName, values, options) {
+        if (!options?.conflictFields || options.conflictFields.length === 0) {
+            throw new Error('Snowflake buildUpsertQuery requires explicit `conflictFields` to build the MERGE ' +
+                'ON clause — omitting it (and matching on all columns) would never find an existing ' +
+                'row to update, causing every upsert to insert a duplicate instead.');
+        }
+        const columns = Object.keys(values);
+        const queryValues = Object.values(values);
+        const updateFields = options?.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns;
+        const conflictFields = options.conflictFields;
+        const sourceValues = columns.map((c) => `? AS ${this.escapeId(c)}`).join(', ');
+        const onClauses = conflictFields
+            .map((c) => `target.${this.escapeId(c)} = source.${this.escapeId(c)}`)
+            .join(' AND ');
+        const updateSet = updateFields
+            .map((c) => `${this.escapeId(c)} = source.${this.escapeId(c)}`)
+            .join(', ');
+        const insertColumns = columns.map((c) => this.escapeId(c)).join(', ');
+        const insertValues = columns.map((c) => `source.${this.escapeId(c)}`).join(', ');
+        const sql = `MERGE INTO ${this.quoteTable(tableName, options?.schema)} AS target ` +
+            `USING (SELECT ${sourceValues}) AS source ON ${onClauses} ` +
+            `WHEN MATCHED THEN UPDATE SET ${updateSet} ` +
+            `WHEN NOT MATCHED THEN INSERT (${insertColumns}) VALUES (${insertValues})`;
+        return { sql, values: queryValues };
+    }
+    buildIncrementQuery(tableName, fields, where, options) {
+        const by = options?.by ?? 1;
+        const queryValues = [];
+        let setClauses;
+        if (typeof fields === 'string') {
+            queryValues.push(by);
+            setClauses = [`${this.escapeId(fields)} = ${this.escapeId(fields)} + ?`];
+        }
+        else if (Array.isArray(fields)) {
+            setClauses = fields.map((field) => {
+                queryValues.push(by);
+                return `${this.escapeId(field)} = ${this.escapeId(field)} + ?`;
+            });
+        }
+        else {
+            setClauses = Object.entries(fields).map(([field, value]) => {
+                queryValues.push(value);
+                return `${this.escapeId(field)} = ${this.escapeId(field)} + ?`;
+            });
+        }
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClauses.join(', ')}`;
+        if (where && Object.keys(where).length > 0) {
+            const whereClause = this.buildWhereClause(where);
+            sql += ` WHERE ${whereClause.sql}`;
+            queryValues.push(...whereClause.values);
+        }
+        return { sql, values: queryValues };
+    }
+    /**
+     * Replace placeholders in SQL with actual escaped values. Supports both
+     * named (:param) and positional (?) placeholders.
+     */
+    replaceReplacements(sql, replacements) {
+        if (!replacements)
+            return sql;
+        if (Array.isArray(replacements)) {
+            let result = sql;
+            let index = 0;
+            result = result.replace(/\?/g, () => {
+                const value = replacements[index++];
+                return this.escape(value);
+            });
+            return result;
+        }
+        let result = sql;
+        for (const [key, value] of Object.entries(replacements)) {
+            const regex = new RegExp(`:${key}\\b`, 'g');
+            result = result.replace(regex, this.escape(value));
+        }
+        return result;
+    }
+    // ---------------------------------------------------------------------------
+    // Foreign Data Wrapper query builders — not supported by Snowflake
+    // ---------------------------------------------------------------------------
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async createUserMapping() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    async dropUserMapping() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by Snowflake. This is a PostgreSQL-specific feature.');
+    }
+    // ---------------------------------------------------------------------------
+    // User / privilege management — Snowflake has real user/role management,
+    // but it is not the focus of this dialect implementation; throw a clear
+    // error rather than emitting incorrect SQL.
+    // ---------------------------------------------------------------------------
+    buildCreateUserQuery(_username, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildAlterUserQuery(_username, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildDropUserQuery(_username, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    getUsersQuery() {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildGrantQuery(_options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildRevokeQuery(_options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildShowGrantsQuery(_username, _host) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildFlushPrivilegesQuery() {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildCreateRoleQuery(_roleName, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildDropRoleQuery(_roleName, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildGrantRoleQuery(_role, _to, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    buildRevokeRoleQuery(_role, _from, _options) {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    getRolesQuery() {
+        throw new Error('User management is not implemented by the Snowflake dialect');
+    }
+    // ---------------------------------------------------------------------------
+    // Sequences — Snowflake supports CREATE SEQUENCE / NEXTVAL natively.
+    // ---------------------------------------------------------------------------
+    async createSequence(options) {
+        const seqName = options.schema
+            ? this.quoteTable(options.name, options.schema)
+            : this.escapeId(options.name);
+        let sql = options.ifNotExists ? 'CREATE SEQUENCE IF NOT EXISTS' : 'CREATE SEQUENCE';
+        sql += ` ${seqName}`;
+        if (options.startWith !== undefined)
+            sql += ` START = ${options.startWith}`;
+        if (options.incrementBy !== undefined)
+            sql += ` INCREMENT = ${options.incrementBy}`;
+        if (options.minvalue !== undefined || options.maxvalue !== undefined || options.cycle) {
+            console.warn('Snowflake: MINVALUE/MAXVALUE/CYCLE are not supported by CREATE SEQUENCE and will be ignored');
+        }
+        await this.query(sql);
+    }
+    async dropSequence(sequenceName, options) {
+        const seqName = options?.schema
+            ? this.quoteTable(sequenceName, options.schema)
+            : this.escapeId(sequenceName);
+        let sql = 'DROP SEQUENCE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${seqName}`;
+        await this.query(sql);
+    }
+    async nextSequenceValue(sequenceName) {
+        const result = await this.query(`SELECT ${this.escapeId(sequenceName)}.NEXTVAL AS value`);
+        return Number(result.rows?.[0]?.VALUE ?? result.rows?.[0]?.value);
+    }
+    async hasSequence(sequenceName) {
+        const result = await this.query(`SHOW SEQUENCES LIKE '${sequenceName.replace(/'/g, "''")}'`);
+        return (result.rows?.length || 0) > 0;
+    }
+    async listSequences() {
+        const result = await this.query('SHOW SEQUENCES');
+        return result.rows?.map((row) => row.name || row.NAME) || [];
+    }
+    // ---------------------------------------------------------------------------
+    // Stored procedures — Snowflake supports JavaScript/SQL/Python/etc.
+    // procedures via CREATE PROCEDURE ... AS $$ ... $$
+    // ---------------------------------------------------------------------------
+    async createStoredProcedure(options) {
+        const procName = options.schema
+            ? this.quoteTable(options.name, options.schema)
+            : this.escapeId(options.name);
+        let sql = options.replace ? 'CREATE OR REPLACE PROCEDURE' : 'CREATE PROCEDURE';
+        if (!options.replace && options.ifNotExists) {
+            sql = 'CREATE PROCEDURE IF NOT EXISTS';
+        }
+        const params = (options.params || [])
+            .map((p) => `${this.escapeId(p.name)} ${p.type}`)
+            .join(', ');
+        sql += ` ${procName} (${params})`;
+        sql += ` RETURNS ${options.returnType || 'STRING'}`;
+        sql += ` LANGUAGE ${options.language || 'SQL'}`;
+        sql += `\nAS\n$$\n${options.body}\n$$`;
+        await this.query(sql);
+    }
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    async dropStoredProcedure(procedureName, options) {
+        const procName = options?.schema
+            ? this.quoteTable(procedureName, options.schema)
+            : this.escapeId(procedureName);
+        // Snowflake identifies procedures by their full signature (name + argument
+        // types), since procedures can be overloaded — DROP PROCEDURE foo() only
+        // matches a zero-argument overload. Callers that created a procedure with
+        // parameters must pass the matching `paramTypes` so the correct overload is
+        // targeted; this falls back to the zero-arg signature when omitted.
+        const signature = (options?.paramTypes || []).join(', ');
+        let sql = 'DROP PROCEDURE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${procName}(${signature})`;
+        await this.query(sql);
+    }
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    async executeStoredProcedure(options) {
+        const procName = options.schema
+            ? this.quoteTable(options.procedureName, options.schema)
+            : this.escapeId(options.procedureName);
+        const args = Object.values(options.params || {})
+            .map((v) => this.escape(v))
+            .join(', ');
+        return this.query(`CALL ${procName}(${args})`);
+    }
+    async hasStoredProcedure(procedureName, schema) {
+        const result = await this.query(`SHOW PROCEDURES LIKE '${procedureName.replace(/'/g, "''")}'${schema ? ` IN SCHEMA ${this.escapeId(schema)}` : ''}`);
+        return (result.rows?.length || 0) > 0;
+    }
+    // ---------------------------------------------------------------------------
+    // Zero-copy CLONE — Snowflake's flagship instant, storage-efficient
+    // dev/test/backup mechanism (`CREATE TABLE/SCHEMA/DATABASE ... CLONE ...`).
+    // Optionally combined with Time Travel (`AT`/`BEFORE`) to clone a historical
+    // version of the source object.
+    // ---------------------------------------------------------------------------
+    /**
+     * Builds the optional `AT(...)`/`BEFORE(...)` suffix used by CLONE
+     * statements, reusing the same Time Travel clause builder as SELECT.
+     */
+    buildCloneTimeTravelClause(options) {
+        if (!options)
+            return '';
+        return this.buildTimeTravelClause({
+            atTimestamp: options.atTimestamp,
+            atOffset: options.atOffset,
+            atStatement: options.atStatement,
+            beforeStatement: options.beforeStatement,
+        });
+    }
+    /**
+     * Zero-copy clone of a table: `CREATE TABLE <target> CLONE <source>`.
+     * Supports an optional Time Travel clause (`atTimestamp`/`atOffset`/
+     * `atStatement`/`beforeStatement`) to clone a historical version of the
+     * source table, and `ifNotExists`/`replace` like `createTable`.
+     */
+    async cloneTable(source, target, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE TABLE' : 'CREATE TABLE';
+        if (!options?.replace && options?.ifNotExists)
+            sql = 'CREATE TABLE IF NOT EXISTS';
+        sql += ` ${this.quoteTable(target, options?.schema)} CLONE ${this.quoteTable(source, options?.schema)}`;
+        sql += this.buildCloneTimeTravelClause(options);
+        await this.query(sql);
+    }
+    /**
+     * Zero-copy clone of a schema: `CREATE SCHEMA <target> CLONE <source>`.
+     */
+    async cloneSchema(source, target, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE SCHEMA' : 'CREATE SCHEMA';
+        if (!options?.replace && options?.ifNotExists)
+            sql = 'CREATE SCHEMA IF NOT EXISTS';
+        sql += ` ${this.escapeId(target)} CLONE ${this.escapeId(source)}`;
+        sql += this.buildCloneTimeTravelClause(options);
+        await this.query(sql);
+    }
+    /**
+     * Zero-copy clone of a database: `CREATE DATABASE <target> CLONE <source>`.
+     */
+    async cloneDatabase(source, target, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE DATABASE' : 'CREATE DATABASE';
+        if (!options?.replace && options?.ifNotExists)
+            sql = 'CREATE DATABASE IF NOT EXISTS';
+        sql += ` ${this.escapeId(target)} CLONE ${this.escapeId(source)}`;
+        sql += this.buildCloneTimeTravelClause(options);
+        await this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Bulk load/unload — COPY INTO, FILE FORMAT and STAGE, Snowflake's primary
+    // bulk data-movement mechanism (analogous to the Redshift dialect's
+    // copyFromS3).
+    // ---------------------------------------------------------------------------
+    /**
+     * `CREATE FILE FORMAT <name> TYPE = <CSV|JSON|PARQUET|...> [options...]`.
+     * Supports the most commonly used per-type options; any additional/rare
+     * option can be passed through `raw` and is appended verbatim.
+     */
+    async createFileFormat(name, options) {
+        let sql = options.replace ? 'CREATE OR REPLACE FILE FORMAT' : 'CREATE FILE FORMAT';
+        if (!options.replace && options.ifNotExists)
+            sql = 'CREATE FILE FORMAT IF NOT EXISTS';
+        const formatName = options.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        sql += ` ${formatName} TYPE = ${options.type}`;
+        const clauses = [];
+        const type = options.type.toUpperCase();
+        if (type === 'CSV') {
+            if (options.fieldDelimiter !== undefined) {
+                clauses.push(`FIELD_DELIMITER = '${this.escapeString(options.fieldDelimiter)}'`);
+            }
+            if (options.recordDelimiter !== undefined) {
+                clauses.push(`RECORD_DELIMITER = '${this.escapeString(options.recordDelimiter)}'`);
+            }
+            if (options.skipHeader !== undefined)
+                clauses.push(`SKIP_HEADER = ${options.skipHeader}`);
+            if (options.fieldOptionallyEnclosedBy !== undefined) {
+                clauses.push(`FIELD_OPTIONALLY_ENCLOSED_BY = '${this.escapeString(options.fieldOptionallyEnclosedBy)}'`);
+            }
+            if (options.nullIf !== undefined) {
+                const values = (Array.isArray(options.nullIf) ? options.nullIf : [options.nullIf])
+                    .map((v) => `'${this.escapeString(v)}'`)
+                    .join(', ');
+                clauses.push(`NULL_IF = (${values})`);
+            }
+            if (options.compression !== undefined)
+                clauses.push(`COMPRESSION = ${options.compression}`);
+            if (options.emptyFieldAsNull !== undefined)
+                clauses.push(`EMPTY_FIELD_AS_NULL = ${options.emptyFieldAsNull}`);
+        }
+        else if (type === 'JSON') {
+            if (options.stripOuterArray !== undefined)
+                clauses.push(`STRIP_OUTER_ARRAY = ${options.stripOuterArray}`);
+            if (options.compression !== undefined)
+                clauses.push(`COMPRESSION = ${options.compression}`);
+        }
+        else if (type === 'PARQUET') {
+            if (options.compression !== undefined)
+                clauses.push(`COMPRESSION = ${options.compression}`);
+            if (options.binaryAsText !== undefined)
+                clauses.push(`BINARY_AS_TEXT = ${options.binaryAsText}`);
+        }
+        if (options.dateFormat !== undefined)
+            clauses.push(`DATE_FORMAT = '${this.escapeString(options.dateFormat)}'`);
+        if (options.timestampFormat !== undefined) {
+            clauses.push(`TIMESTAMP_FORMAT = '${this.escapeString(options.timestampFormat)}'`);
+        }
+        if (options.raw)
+            clauses.push(options.raw);
+        if (clauses.length > 0)
+            sql += ` ${clauses.join(' ')}`;
+        await this.query(sql);
+    }
+    async dropFileFormat(name, options) {
+        const formatName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        let sql = 'DROP FILE FORMAT';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${formatName}`;
+        await this.query(sql);
+    }
+    /**
+     * `CREATE STAGE <name> [URL = '...'] [CREDENTIALS = (...)] [FILE_FORMAT = ...]`.
+     * A stage is Snowflake's named reference to a bulk-load/unload location
+     * (internal, or external S3/Azure/GCS); required before `COPY INTO` can
+     * reference `@<stage>`.
+     */
+    async createStage(name, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE STAGE' : 'CREATE STAGE';
+        if (!options?.replace && options?.ifNotExists)
+            sql = 'CREATE STAGE IF NOT EXISTS';
+        const stageName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        sql += ` ${stageName}`;
+        if (options?.url)
+            sql += ` URL = '${this.escapeString(options.url)}'`;
+        if (options?.credentials) {
+            const creds = Object.entries(options.credentials)
+                .map(([k, v]) => `${k.toUpperCase()} = '${this.escapeString(String(v))}'`)
+                .join(' ');
+            sql += ` CREDENTIALS = (${creds})`;
+        }
+        if (options?.fileFormatName)
+            sql += ` FILE_FORMAT = (FORMAT_NAME = ${this.escapeId(options.fileFormatName)})`;
+        await this.query(sql);
+    }
+    async dropStage(name, options) {
+        const stageName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        let sql = 'DROP STAGE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${stageName}`;
+        await this.query(sql);
+    }
+    /**
+     * Bulk load: `COPY INTO <table> FROM @<stage>[/path] [FILES = (...)]
+     * [PATTERN = '...'] [FILE_FORMAT = (...)] [ON_ERROR = ...] [FORCE = ...]`.
+     * `stagePath` may be a bare stage name (`my_stage`) or already include the
+     * `@` prefix / sub-path (`@my_stage/2024/`); both are normalized.
+     */
+    async copyInto(tableName, stagePath, options) {
+        const stageRef = stagePath.startsWith('@') ? stagePath : `@${stagePath}`;
+        let sql = `COPY INTO ${this.quoteTable(tableName, options?.schema)} FROM ${stageRef}`;
+        if (options?.files && options.files.length > 0) {
+            sql += ` FILES = (${options.files.map((f) => `'${this.escapeString(f)}'`).join(', ')})`;
+        }
+        if (options?.pattern) {
+            sql += ` PATTERN = '${this.escapeString(options.pattern)}'`;
+        }
+        if (options?.fileFormatName) {
+            sql += ` FILE_FORMAT = (FORMAT_NAME = ${this.escapeId(options.fileFormatName)})`;
+        }
+        else if (options?.fileFormat) {
+            const ffEntries = Object.entries(options.fileFormat)
+                .map(([k, v]) => `${k.toUpperCase()} = ${typeof v === 'string' ? `'${this.escapeString(v)}'` : v}`)
+                .join(', ');
+            sql += ` FILE_FORMAT = (${ffEntries})`;
+        }
+        if (options?.onError)
+            sql += ` ON_ERROR = ${options.onError}`;
+        if (options?.force !== undefined)
+            sql += ` FORCE = ${options.force}`;
+        if (options?.purge !== undefined)
+            sql += ` PURGE = ${options.purge}`;
+        if (options?.matchByColumnName)
+            sql += ` MATCH_BY_COLUMN_NAME = ${options.matchByColumnName}`;
+        return this.query(sql);
+    }
+    /**
+     * Bulk unload: `COPY INTO @<stage>[/path] FROM <table> [FILE_FORMAT = (...)]
+     * [OVERWRITE = ...] [SINGLE = ...] [HEADER = ...]`.
+     */
+    async unloadTo(tableName, stagePath, options) {
+        const stageRef = stagePath.startsWith('@') ? stagePath : `@${stagePath}`;
+        let sql = `COPY INTO ${stageRef} FROM ${this.quoteTable(tableName, options?.schema)}`;
+        if (options?.fileFormatName) {
+            sql += ` FILE_FORMAT = (FORMAT_NAME = ${this.escapeId(options.fileFormatName)})`;
+        }
+        else if (options?.fileFormat) {
+            const ffEntries = Object.entries(options.fileFormat)
+                .map(([k, v]) => `${k.toUpperCase()} = ${typeof v === 'string' ? `'${this.escapeString(v)}'` : v}`)
+                .join(', ');
+            sql += ` FILE_FORMAT = (${ffEntries})`;
+        }
+        if (options?.overwrite !== undefined)
+            sql += ` OVERWRITE = ${options.overwrite}`;
+        if (options?.single !== undefined)
+            sql += ` SINGLE = ${options.single}`;
+        if (options?.header !== undefined)
+            sql += ` HEADER = ${options.header}`;
+        if (options?.maxFileSize !== undefined)
+            sql += ` MAX_FILE_SIZE = ${options.maxFileSize}`;
+        return this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Warehouses — virtual warehouses are Snowflake's compute layer. Only
+    // `USE WAREHOUSE` (activation on connect) existed previously; these add
+    // full lifecycle DDL management.
+    //
+    // Real Snowflake syntax (https://docs.snowflake.com/en/sql-reference/sql/create-warehouse,
+    // .../alter-warehouse, .../drop-warehouse):
+    //   CREATE [ OR REPLACE ] WAREHOUSE [ IF NOT EXISTS ] <name> [ WITH ]
+    //     [ WAREHOUSE_SIZE = '<size>' ]
+    //     [ AUTO_SUSPEND = <num> ]
+    //     [ AUTO_RESUME = TRUE | FALSE ]
+    //     [ MIN_CLUSTER_COUNT = <num> ]
+    //     [ MAX_CLUSTER_COUNT = <num> ]
+    //     [ SCALING_POLICY = 'STANDARD' | 'ECONOMY' ]
+    //     [ INITIALLY_SUSPENDED = TRUE | FALSE ]
+    //     [ RESOURCE_MONITOR = <name> ]
+    //     [ COMMENT = '<string>' ]
+    //   ALTER WAREHOUSE [ IF EXISTS ] <name> SET <same object properties, minus IF NOT EXISTS/INITIALLY_SUSPENDED>
+    //   ALTER WAREHOUSE [ IF EXISTS ] <name> SUSPEND | RESUME [ IF SUSPENDED ]
+    //   DROP WAREHOUSE [ IF EXISTS ] <name>
+    // ---------------------------------------------------------------------------
+    /**
+     * Builds the `WAREHOUSE_SIZE = '...' AUTO_SUSPEND = ... ...` object
+     * properties shared by `CREATE WAREHOUSE ... WITH ...` and
+     * `ALTER WAREHOUSE ... SET ...`. `includeCreateOnly` controls whether
+     * create-only properties (`INITIALLY_SUSPENDED`) are included, since
+     * `ALTER WAREHOUSE ... SET` does not accept them.
+     */
+    buildWarehousePropertiesSql(options, includeCreateOnly) {
+        const clauses = [];
+        if (options.size !== undefined)
+            clauses.push(`WAREHOUSE_SIZE = '${this.escapeString(options.size)}'`);
+        if (options.autoSuspend !== undefined)
+            clauses.push(`AUTO_SUSPEND = ${options.autoSuspend}`);
+        if (options.autoResume !== undefined)
+            clauses.push(`AUTO_RESUME = ${options.autoResume}`);
+        if (options.minClusterCount !== undefined)
+            clauses.push(`MIN_CLUSTER_COUNT = ${options.minClusterCount}`);
+        if (options.maxClusterCount !== undefined)
+            clauses.push(`MAX_CLUSTER_COUNT = ${options.maxClusterCount}`);
+        if (options.scalingPolicy !== undefined) {
+            clauses.push(`SCALING_POLICY = '${this.escapeString(options.scalingPolicy)}'`);
+        }
+        if (includeCreateOnly && options.initiallySuspended !== undefined) {
+            clauses.push(`INITIALLY_SUSPENDED = ${options.initiallySuspended}`);
+        }
+        if (options.resourceMonitor !== undefined) {
+            clauses.push(`RESOURCE_MONITOR = ${this.escapeId(options.resourceMonitor)}`);
+        }
+        if (options.comment !== undefined)
+            clauses.push(`COMMENT = '${this.escapeString(options.comment)}'`);
+        return clauses.join(' ');
+    }
+    /**
+     * `CREATE [OR REPLACE] WAREHOUSE [IF NOT EXISTS] <name> WITH <properties>`.
+     */
+    async createWarehouse(name, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE WAREHOUSE' : 'CREATE WAREHOUSE';
+        if (!options?.replace && options?.ifNotExists)
+            sql = 'CREATE WAREHOUSE IF NOT EXISTS';
+        sql += ` ${this.escapeId(name)}`;
+        const properties = options ? this.buildWarehousePropertiesSql(options, true) : '';
+        if (properties)
+            sql += ` WITH ${properties}`;
+        await this.query(sql);
+    }
+    /**
+     * `ALTER WAREHOUSE <name> SET <properties>`. Also used to (re)assign a
+     * resource monitor to a warehouse via `options.resourceMonitor`
+     * (`ALTER WAREHOUSE <name> SET RESOURCE_MONITOR = <monitor_name>`).
+     */
+    async alterWarehouse(name, options) {
+        const properties = this.buildWarehousePropertiesSql(options, false);
+        if (!properties) {
+            throw new Error('alterWarehouse requires at least one property to change');
+        }
+        await this.query(`ALTER WAREHOUSE ${this.escapeId(name)} SET ${properties}`);
+    }
+    async dropWarehouse(name, options) {
+        let sql = 'DROP WAREHOUSE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(name)}`;
+        await this.query(sql);
+    }
+    async suspendWarehouse(name) {
+        await this.query(`ALTER WAREHOUSE ${this.escapeId(name)} SUSPEND`);
+    }
+    async resumeWarehouse(name) {
+        await this.query(`ALTER WAREHOUSE ${this.escapeId(name)} RESUME`);
+    }
+    // ---------------------------------------------------------------------------
+    // Resource monitors — track Snowflake credit usage against a quota and
+    // trigger NOTIFY/SUSPEND/SUSPEND_IMMEDIATE actions on the warehouse(s) (or
+    // account) they're assigned to once usage crosses configured thresholds.
+    //
+    // Real Snowflake syntax (https://docs.snowflake.com/en/sql-reference/sql/create-resource-monitor,
+    // .../alter-resource-monitor, .../drop-resource-monitor):
+    //   CREATE [ OR REPLACE ] RESOURCE MONITOR <name> WITH
+    //     [ CREDIT_QUOTA = <num> ]
+    //     [ FREQUENCY = MONTHLY | DAILY | WEEKLY | YEARLY | NEVER ]
+    //     [ START_TIMESTAMP = <timestamp> | IMMEDIATELY ]
+    //     [ END_TIMESTAMP = <timestamp> ]
+    //     [ NOTIFY_USERS = ( <user_name> [ , <user_name> ... ] ) ]
+    //     [ TRIGGERS ( ON <num> PERCENT DO { NOTIFY | SUSPEND | SUSPEND_IMMEDIATE } )+ ]
+    //   ALTER RESOURCE MONITOR [ IF EXISTS ] <name> SET
+    //     [ CREDIT_QUOTA = <num> ] [ FREQUENCY = ... ] [ START_TIMESTAMP = ... ]
+    //     [ END_TIMESTAMP = ... ] [ NOTIFY_USERS = ( ... ) ]
+    //     [ TRIGGERS ( ON <num> PERCENT DO ... )+ ]
+    //   DROP RESOURCE MONITOR [ IF EXISTS ] <name>
+    //
+    // A monitor is assigned to a warehouse via `alterWarehouse(name, { resourceMonitor })`
+    // (`ALTER WAREHOUSE <name> SET RESOURCE_MONITOR = <monitor_name>`), and to
+    // the whole account via `ALTER ACCOUNT SET RESOURCE_MONITOR = <monitor_name>`.
+    // ---------------------------------------------------------------------------
+    /**
+     * Builds the `CREDIT_QUOTA = ... FREQUENCY = ... TRIGGERS ON ... PERCENT DO ...`
+     * body shared by `CREATE RESOURCE MONITOR ... WITH ...` and
+     * `ALTER RESOURCE MONITOR ... SET ...`.
+     */
+    buildResourceMonitorPropertiesSql(options) {
+        const clauses = [];
+        if (options.creditQuota !== undefined)
+            clauses.push(`CREDIT_QUOTA = ${options.creditQuota}`);
+        if (options.frequency !== undefined)
+            clauses.push(`FREQUENCY = ${options.frequency}`);
+        if (options.startTimestamp !== undefined) {
+            const isKeyword = options.startTimestamp.toUpperCase() === 'IMMEDIATELY';
+            clauses.push(`START_TIMESTAMP = ${isKeyword ? 'IMMEDIATELY' : `'${this.escapeString(options.startTimestamp)}'`}`);
+        }
+        if (options.endTimestamp !== undefined) {
+            clauses.push(`END_TIMESTAMP = '${this.escapeString(options.endTimestamp)}'`);
+        }
+        if (options.notifyUsers && options.notifyUsers.length > 0) {
+            clauses.push(`NOTIFY_USERS = (${options.notifyUsers.map((u) => this.escapeId(u)).join(', ')})`);
+        }
+        let sql = clauses.join(' ');
+        if (options.triggers && options.triggers.length > 0) {
+            const triggersSql = options.triggers
+                .map((t) => `ON ${t.threshold} PERCENT DO ${t.action}`)
+                .join(' ');
+            sql += `${sql ? ' ' : ''}TRIGGERS ${triggersSql}`;
+        }
+        return sql;
+    }
+    /** `CREATE [OR REPLACE] RESOURCE MONITOR [IF NOT EXISTS] <name> WITH <properties>`. */
+    async createResourceMonitor(name, options) {
+        let sql = options.replace ? 'CREATE OR REPLACE RESOURCE MONITOR' : 'CREATE RESOURCE MONITOR';
+        if (!options.replace && options.ifNotExists)
+            sql = 'CREATE RESOURCE MONITOR IF NOT EXISTS';
+        sql += ` ${this.escapeId(name)}`;
+        const properties = this.buildResourceMonitorPropertiesSql(options);
+        if (properties)
+            sql += ` WITH ${properties}`;
+        await this.query(sql);
+    }
+    /** `ALTER RESOURCE MONITOR <name> SET <properties>` (updates quota/frequency/triggers/etc). */
+    async alterResourceMonitor(name, options) {
+        const properties = this.buildResourceMonitorPropertiesSql(options);
+        if (!properties) {
+            throw new Error('alterResourceMonitor requires at least one property to change');
+        }
+        await this.query(`ALTER RESOURCE MONITOR ${this.escapeId(name)} SET ${properties}`);
+    }
+    async dropResourceMonitor(name, options) {
+        let sql = 'DROP RESOURCE MONITOR';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(name)}`;
+        await this.query(sql);
+    }
+    // ---------------------------------------------------------------------------
+    // Streams and Tasks — Snowflake's native CDC (change data capture) and
+    // scheduled/DAG job primitives. Minimal wrappers to support incremental
+    // ETL workflows from ORM consumers.
+    // ---------------------------------------------------------------------------
+    /**
+     * `CREATE STREAM <name> ON TABLE <table> [APPEND_ONLY = ...] [SHOW_INITIAL_ROWS = ...]`.
+     * A stream tracks row-level INSERT/UPDATE/DELETE changes on a table (or
+     * view) since it was created or last consumed, Snowflake's native CDC
+     * mechanism.
+     */
+    async createStream(name, tableName, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE STREAM' : 'CREATE STREAM';
+        if (!options?.replace && options?.ifNotExists)
+            sql = 'CREATE STREAM IF NOT EXISTS';
+        const streamName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        sql += ` ${streamName} ON TABLE ${this.quoteTable(tableName, options?.schema)}`;
+        if (options?.appendOnly !== undefined)
+            sql += ` APPEND_ONLY = ${options.appendOnly}`;
+        if (options?.showInitialRows !== undefined)
+            sql += ` SHOW_INITIAL_ROWS = ${options.showInitialRows}`;
+        if (options?.comment)
+            sql += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        await this.query(sql);
+    }
+    async dropStream(name, options) {
+        const streamName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        let sql = 'DROP STREAM';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${streamName}`;
+        await this.query(sql);
+    }
+    async showStreams() {
+        const result = await this.query('SHOW STREAMS');
+        return result.rows?.map((row) => row.name || row.NAME) || [];
+    }
+    /**
+     * `CREATE TASK <name> [WAREHOUSE = ...] [SCHEDULE = '...'] [AFTER <task>]
+     * AS <sql>`. A task runs a single SQL statement (often `CALL` on a stored
+     * procedure) on a schedule (cron/interval) or as part of a DAG (`AFTER`).
+     */
+    async createTask(name, sql, options) {
+        let ddl = options?.replace ? 'CREATE OR REPLACE TASK' : 'CREATE TASK';
+        if (!options?.replace && options?.ifNotExists)
+            ddl = 'CREATE TASK IF NOT EXISTS';
+        const taskName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        ddl += ` ${taskName}`;
+        if (options?.warehouse)
+            ddl += ` WAREHOUSE = ${this.escapeId(options.warehouse)}`;
+        if (options?.schedule)
+            ddl += ` SCHEDULE = '${this.escapeString(options.schedule)}'`;
+        if (options?.after) {
+            const predecessors = Array.isArray(options.after) ? options.after : [options.after];
+            ddl += ` AFTER ${predecessors.map((t) => this.quoteTable(t, options.schema)).join(', ')}`;
+        }
+        if (options?.when)
+            ddl += ` WHEN ${options.when}`;
+        if (options?.comment)
+            ddl += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        ddl += ` AS ${sql}`;
+        await this.query(ddl);
+    }
+    async dropTask(name, options) {
+        const taskName = options?.schema ? this.quoteTable(name, options.schema) : this.escapeId(name);
+        let sql = 'DROP TASK';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${taskName}`;
+        await this.query(sql);
+    }
+    async resumeTask(name, schema) {
+        await this.query(`ALTER TASK ${this.quoteTable(name, schema)} RESUME`);
+    }
+    async suspendTask(name, schema) {
+        await this.query(`ALTER TASK ${this.quoteTable(name, schema)} SUSPEND`);
+    }
+    /** Runs a task immediately, outside of its schedule: `EXECUTE TASK <name>`. */
+    async executeTask(name, schema) {
+        return this.query(`EXECUTE TASK ${this.quoteTable(name, schema)}`);
+    }
+    async showTasks() {
+        const result = await this.query('SHOW TASKS');
+        return result.rows?.map((row) => row.name || row.NAME) || [];
+    }
+    /**
+     * Build an expression to shred a JSON document/array into relational rows.
+     * Snowflake has no `JSON_TABLE`; its real equivalent is the `FLATTEN` table function
+     * (`TABLE(FLATTEN(input => ..., path => ...))`), which explodes a VARIANT array/object
+     * into rows exposing `value` (and `index` for array position). This wraps FLATTEN in a
+     * derived table that projects `value:<key>::<type>` per requested column, matching the
+     * named/typed column shape of JSON_TABLE/OPENJSON in the other dialects.
+     * Snowflake: (SELECT f.value:name::type AS name, ... FROM
+     *   TABLE(FLATTEN(input => expr, path => 'rowPath')) AS f) AS alias
+     */
+    buildJsonTable(jsonExpression, rowPath, columns, alias) {
+        const flattenAlias = `${alias}_f`;
+        const normalizedRowPath = rowPath ? rowPath.replace(/^\$\.?/, '') : '';
+        const pathArg = normalizedRowPath ? `, path => '${normalizedRowPath}'` : '';
+        const selectCols = columns
+            .map((col) => {
+            if (col.forOrdinality) {
+                return `${flattenAlias}.index AS ${this.escapeId(col.name)}`;
+            }
+            const key = (col.path || col.name).replace(/^\$\.?/, '');
+            const cast = col.type ? `::${col.type}` : '';
+            return `${flattenAlias}.value:${key}${cast} AS ${this.escapeId(col.name)}`;
+        })
+            .join(', ');
+        return `(SELECT ${selectCols} FROM TABLE(FLATTEN(input => ${jsonExpression}${pathArg})) AS ${flattenAlias}) AS ${this.escapeId(alias)}`;
+    }
+}
+exports.SnowflakeDialect = SnowflakeDialect;
+exports.default = SnowflakeDialect;