ts-prorm-orm 1.1.0

package/dist/dialects/oracle/index.js

@@ -0,0 +1,2999 @@
+"use strict";
+/**
+ * Oracle dialect implementation for the TypeScript ORM
+ * Uses the oracledb driver for database connectivity
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleDialect = void 0;
+exports.createOracleDialect = createOracleDialect;
+const oracledb_1 = __importDefault(require("oracledb"));
+const query_stream_helper_1 = require("../query-stream-helper");
+const errors_1 = require("../../errors");
+const crypto_1 = require("crypto");
+/**
+ * Oracle-specific transaction class
+ */
+class OracleTransaction {
+    constructor(connection, options) {
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        this.connection = null;
+        this.id = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.options = options || {};
+        this.parent = null;
+        this.savepoints = [];
+        this.connection = connection;
+    }
+    async commit() {
+        this.finished = true;
+    }
+    async rollback() {
+        this.finished = true;
+    }
+}
+/**
+ * Default pool options for Oracle
+ */
+const DEFAULT_POOL_OPTIONS = {
+    max: 10,
+    min: 2,
+    increment: 2,
+    timeout: 30,
+};
+/**
+ * Default retry options for connection
+ */
+const DEFAULT_RETRY_OPTIONS = {
+    max: 3,
+    timeout: 5000,
+    match: ['ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'ORA-12514', 'ORA-12541', 'ORA-12154'],
+    backoff: false,
+    backoffMultiplier: 2,
+    backoffMax: 10000,
+};
+/**
+ * Oracle dialect class that implements the Dialect interface
+ */
+class OracleDialect {
+    constructor(config) {
+        this.name = 'oracle';
+        this.library = 'oracledb';
+        this.pool = null;
+        this._isConnected = false;
+        this.retryOptions = config.retry || {};
+        this.config = {
+            host: 'localhost',
+            port: 1521,
+            ...config,
+        };
+    }
+    /**
+     * Execute a function with retry logic
+     */
+    async withRetry(fn) {
+        const retryConfig = {
+            ...DEFAULT_RETRY_OPTIONS,
+            ...this.retryOptions,
+        };
+        let lastError;
+        for (let attempt = 0; attempt <= retryConfig.max; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const errorMessage = lastError.message;
+                // Check if this error should be retried
+                const shouldRetry = retryConfig.match.some((match) => errorMessage.includes(match));
+                if (!shouldRetry || attempt === retryConfig.max) {
+                    throw lastError;
+                }
+                // Calculate backoff
+                let delay = retryConfig.timeout;
+                if (retryConfig.backoff) {
+                    delay = Math.min(retryConfig.timeout * Math.pow(retryConfig.backoffMultiplier, attempt), retryConfig.backoffMax);
+                }
+                // Wait before retry
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Escape a string for SQL (replace ' with '')
+     */
+    escapeString(str) {
+        return str.replace(/'/g, "''");
+    }
+    /**
+     * Connect to the Oracle database
+     */
+    async connect() {
+        try {
+            // `initOracleClient()` forces thick mode, which requires an Instant
+            // Client install. When `config.thinMode` is requested, skip it
+            // entirely so the driver stays in its pure-JS thin mode (its default
+            // when the client isn't initialized) instead of unconditionally
+            // switching to thick mode.
+            if (!this.config.thinMode) {
+                await oracledb_1.default.initOracleClient();
+            }
+            const poolOptions = {
+                ...DEFAULT_POOL_OPTIONS,
+                ...this.config.pool,
+                user: this.config.username,
+                password: this.config.password,
+                connectString: `${this.config.host}:${this.config.port}/${this.config.database}`,
+            };
+            this.pool = await oracledb_1.default.createPool(poolOptions);
+            this._isConnected = true;
+        }
+        catch (error) {
+            // Surface the real underlying error (message, ORA code, stack, etc.)
+            // instead of collapsing it into a generic string, which previously
+            // hid the actual cause of connection failures.
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to connect to Oracle database: ${message}`);
+        }
+    }
+    /**
+     * Disconnect from the Oracle database
+     */
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.close(0);
+            this.pool = null;
+            this._isConnected = false;
+        }
+    }
+    /**
+     * Get the current connection from pool
+     */
+    async getConnection() {
+        if (!this.pool) {
+            throw new Error('Not connected to database. Call connect() first.');
+        }
+        return await this.pool.getConnection();
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this._isConnected && this.pool !== null;
+    }
+    /**
+     * Stream query results using a correct ROWNUM-windowed pagination query
+     * (see `createOracleQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * rather than this dialect's own `buildLimitOffset()`, whose bare
+     * `WHERE ROWNUM <= n` doesn't actually skip the first `offset` rows.
+     * @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.createOracleQueryStream)(this, sql, options);
+    }
+    /**
+     * Execute a query
+     */
+    async query(sql, options) {
+        const connection = await this.getConnection();
+        try {
+            const queryOptions = {
+                autoCommit: true,
+                outFormat: oracledb_1.default.OUT_FORMAT_OBJECT,
+            };
+            // Callers pass bind values under different option keys (`replacements`,
+            // `bindings`, or `bind`); oracledb accepts either a positional array
+            // (for `:1`-style binds) or a named object (for `:name`-style binds).
+            const bindParams = options?.bind ??
+                options?.replacements ??
+                options?.bindings ??
+                [];
+            const result = await connection.execute(sql, bindParams, queryOptions);
+            const fields = (result.metaData || []).map((meta) => ({
+                name: meta.name,
+                // `meta.dbType` is an oracledb `DbType` object (e.g. DB_TYPE_VARCHAR),
+                // not a plain number, so it can't be used as a key into the
+                // `oracledb` module's exports (those are keyed by constant name, a
+                // name -> number/object map, not number -> name). The driver already
+                // computes the human-readable type name for us on `dbTypeName`
+                // (falling back to `dbType.name` for older driver versions), which is
+                // the correct reverse lookup to use here.
+                type: meta.dbTypeName || meta.dbType?.name || 'UNKNOWN',
+                length: meta.byteSize || 0,
+                tableID: 0,
+                columnID: 0,
+                nullable: true,
+                isEnum: false,
+                isPrimaryKey: false,
+                isAutoIncrement: false,
+                isJson: false,
+                isEnumLiteral: false,
+            }));
+            return {
+                rows: result.rows || [],
+                rowCount: result.rows?.length || 0,
+                fields,
+            };
+        }
+        finally {
+            await connection.close();
+        }
+    }
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'number') {
+            return value.toString();
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        if (value instanceof Date) {
+            // Oracle date format
+            const year = value.getFullYear();
+            const month = String(value.getMonth() + 1).padStart(2, '0');
+            const day = String(value.getDate()).padStart(2, '0');
+            const hours = String(value.getHours()).padStart(2, '0');
+            const minutes = String(value.getMinutes()).padStart(2, '0');
+            const seconds = String(value.getSeconds()).padStart(2, '0');
+            return `TO_DATE('${year}-${month}-${day} ${hours}:${minutes}:${seconds}', 'YYYY-MM-DD HH24:MI:SS')`;
+        }
+        if (Buffer.isBuffer(value)) {
+            // A bare quoted hex string (e.g. 'deadbeef') is a Oracle CHAR/VARCHAR2
+            // literal containing those literal ASCII characters, not the raw
+            // bytes. To insert the actual binary payload into a RAW/BLOB column,
+            // the hex text must be wrapped in HEXTORAW(...), which Oracle converts
+            // to the corresponding raw bytes at the server.
+            return `HEXTORAW('${value.toString('hex')}')`;
+        }
+        if (Array.isArray(value)) {
+            return `(${value.map((v) => this.escape(v)).join(', ')})`;
+        }
+        // String - escape single quotes by doubling them
+        const escaped = String(value).replace(/'/g, "''");
+        return `'${escaped}'`;
+    }
+    /**
+     * Escape an identifier (Oracle uses double quotes, same as quoteIdentifier).
+     * Without the surrounding quotes, Oracle folds unquoted identifiers to
+     * uppercase, which breaks lookups for mixed-case table/column names created
+     * elsewhere via quoteIdentifier()/quoteTable().
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Quote an identifier with double quotes (Oracle standard)
+     */
+    quoteIdentifier(identifier) {
+        const id = String(identifier ?? '');
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Quote a table name with optional schema
+     */
+    quoteTable(tableName, schema) {
+        if (schema) {
+            return `${this.quoteIdentifier(schema)}.${this.quoteIdentifier(tableName)}`;
+        }
+        return this.quoteIdentifier(tableName);
+    }
+    /**
+     * Get database version
+     */
+    async getDatabaseVersion() {
+        const result = await this.query('SELECT VERSION FROM V$INSTANCE');
+        return result.rows[0]?.VERSION || 'Unknown';
+    }
+    /**
+     * `IF [NOT] EXISTS` on `CREATE`/`DROP` DDL (tables, users, roles, etc.) was
+     * only added in Oracle 23c. Against the 19c/21c versions this dialect
+     * otherwise targets, that syntax raises `ORA-00922: missing or invalid
+     * option`. This helper provides a portable, version-independent
+     * equivalent by wrapping the plain (no `IF [NOT] EXISTS`) DDL statement in
+     * an anonymous PL/SQL block that executes it via `EXECUTE IMMEDIATE` and
+     * swallows only the specific "already exists" / "does not exist" ORA
+     * error code(s) supplied, letting any other failure propagate normally.
+     *
+     * @param sql - The plain DDL statement, without any `IF [NOT] EXISTS`.
+     * @param oraCodes - The ORA error number(s) (positive, e.g. `955` for
+     *   ORA-00955) that should be silently ignored.
+     */
+    wrapIgnoringOraErrors(sql, oraCodes) {
+        const escapedSql = sql.replace(/'/g, "''");
+        const codeList = oraCodes.map((code) => -Math.abs(code)).join(', ');
+        return (`BEGIN\n` +
+            `  EXECUTE IMMEDIATE '${escapedSql}';\n` +
+            `EXCEPTION\n` +
+            `  WHEN OTHERS THEN\n` +
+            `    IF SQLCODE NOT IN (${codeList}) THEN\n` +
+            `      RAISE;\n` +
+            `    END IF;\n` +
+            `END;`);
+    }
+    // ==================== Schema Operations ====================
+    /**
+     * Create a schema.
+     *
+     * Oracle has a `CREATE SCHEMA` statement, but it only exists to bundle a
+     * batch of `CREATE TABLE`/`CREATE VIEW`/`GRANT` statements into one
+     * transaction (`CREATE SCHEMA AUTHORIZATION x <stmt> <stmt> ...`) - it does
+     * not, by itself, create a schema as a standalone object, and
+     * `CREATE SCHEMA AUTHORIZATION x` with no accompanying statements is not
+     * valid Oracle usage. In Oracle a schema *is* a user (every user owns
+     * exactly one schema, and objects are always created "in" a user's
+     * schema), so creating a schema really means creating a user. A random
+     * password is generated since `CREATE USER` requires one; callers that
+     * need a specific password (or other user attributes) should use the
+     * User Management API (`buildCreateUserQuery`/`UserManager.createUser`)
+     * directly instead.
+     */
+    async createSchema(schema) {
+        const password = (0, crypto_1.randomBytes)(24).toString('base64').replace(/[^A-Za-z0-9]/g, '') + 'Aa1';
+        await this.query(`CREATE USER ${this.quoteIdentifier(schema)} IDENTIFIED BY "${password}"`);
+    }
+    /**
+     * Drop a schema.
+     *
+     * Since a schema in Oracle *is* a user, dropping a schema means dropping
+     * that user (`DROP SCHEMA`/`DROP SCHEMA ... CASCADE` are not Oracle
+     * statements at all). `CASCADE` is always applied so that the user's
+     * owned objects are dropped along with the user, matching the intent of
+     * "drop this schema and everything in it". When `ifExists` is requested,
+     * the statement is wrapped so that ORA-01918 ("user does not exist") is
+     * silently ignored (see {@link wrapIgnoringOraErrors}); Oracle's own
+     * `DROP USER ... IF EXISTS` syntax is 23c-only and would fail against the
+     * 19c/21c versions this dialect targets.
+     */
+    async dropSchema(schema, options) {
+        const sql = `DROP USER ${this.quoteIdentifier(schema)} CASCADE`;
+        const finalSql = options?.ifExists
+            ? this.wrapIgnoringOraErrors(sql, [OracleDialect.ORA_USER_DOES_NOT_EXIST])
+            : sql;
+        await this.query(finalSql);
+    }
+    /**
+     * Show all schemas
+     */
+    async showAllSchemas() {
+        const result = await this.query('SELECT USERNAME FROM ALL_USERS ORDER BY USERNAME');
+        return result.rows.map((row) => row.USERNAME);
+    }
+    /**
+     * List all schemas (Oracle users)
+     */
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    /**
+     * Create database SQL (Oracle uses tablespaces)
+     */
+    createDatabaseSQL(options) {
+        const parts = [];
+        parts.push(`CREATE DATABASE ${this.quoteIdentifier(options.name)}`);
+        if (options.tablespace) {
+            parts.push(`DEFAULT TABLESPACE ${options.tablespace}`);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Drop database SQL
+     */
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE ${this.quoteIdentifier(name)}`;
+    }
+    // ==================== Table Operations ====================
+    /**
+     * Create a table
+     */
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.buildColumnDefinition(columnName, definition));
+        }
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                columnDefs.push(this.buildConstraintDefinition(constraint));
+            }
+        }
+        const plainSql = `CREATE TABLE ${this.quoteTable(tableName)} (${columnDefs.join(', ')})`;
+        // Oracle's `CREATE TABLE IF NOT EXISTS` is 23c-only syntax and raises
+        // ORA-00922 against the 19c/21c versions this dialect targets. Use a
+        // portable existence check instead: run the plain DDL and silently
+        // ignore ORA-00955 ("name is already used by an existing object").
+        const sql = options?.ifNotExists
+            ? this.wrapIgnoringOraErrors(plainSql, [OracleDialect.ORA_NAME_ALREADY_USED])
+            : plainSql;
+        await this.query(sql);
+        // Create indexes if specified
+        if (options?.indexes) {
+            for (const index of options.indexes) {
+                await this.createIndex(tableName, {
+                    name: index.name || `${tableName}_${index.fields.join('_')}_idx`,
+                    fields: index.fields,
+                    unique: index.unique,
+                    type: index.type,
+                });
+            }
+        }
+    }
+    /**
+     * Build column definition for Oracle
+     */
+    buildColumnDefinition(columnName, definition) {
+        let sql = `${this.quoteIdentifier(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        // Oracle's column_definition grammar requires `DEFAULT expr` to appear
+        // immediately after the datatype and *before* any inline constraints
+        // (NOT NULL, PRIMARY KEY, UNIQUE, REFERENCES, CHECK). Emitting it after
+        // those constraints (as e.g. `... NOT NULL DEFAULT 'x'`) raises
+        // ORA-03076 ("unexpected item DEFAULT in a column definition or inline
+        // constraint") because the parser has already committed to the
+        // constraint clause by the time it sees DEFAULT.
+        if (definition.defaultValue !== undefined) {
+            // A handful of well-known Oracle default expressions/keywords (e.g.
+            // CURRENT_TIMESTAMP, used for auto-managed createdAt/updatedAt
+            // columns) must be emitted unquoted - escaping them as a string
+            // literal would store the literal text "CURRENT_TIMESTAMP" instead of
+            // evaluating the expression.
+            const rawDefaultKeywords = new Set([
+                'CURRENT_TIMESTAMP',
+                'CURRENT_DATE',
+                'SYSDATE',
+                'SYSTIMESTAMP',
+                'LOCALTIMESTAMP',
+                'NULL',
+            ]);
+            const defaultValue = definition.defaultValue;
+            const defaultSql = typeof defaultValue === 'string' && rawDefaultKeywords.has(defaultValue.toUpperCase())
+                ? defaultValue.toUpperCase()
+                : this.escape(defaultValue);
+            sql += ` DEFAULT ${defaultSql}`;
+        }
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.autoIncrement) {
+            // Oracle uses sequences for auto-increment
+            // This is handled separately via triggers
+        }
+        if (definition.unique) {
+            if (typeof definition.unique === 'string') {
+                sql += ` UNIQUE (${this.quoteIdentifier(definition.unique)})`;
+            }
+            else {
+                sql += ' UNIQUE';
+            }
+        }
+        if (definition.references) {
+            const refTable = definition.references.table;
+            const refFields = Array.isArray(definition.references.field)
+                ? definition.references.field.join(', ')
+                : definition.references.field;
+            sql += ` REFERENCES ${this.quoteTable(refTable)} (${this.quoteIdentifier(refFields)})`;
+            if (definition.references.onDelete) {
+                sql += ` ON DELETE ${definition.references.onDelete.toUpperCase()}`;
+            }
+        }
+        return sql;
+    }
+    /**
+     * Build constraint definition
+     */
+    buildConstraintDefinition(constraint) {
+        const constraintName = constraint.name ? this.quoteIdentifier(constraint.name) : '';
+        const fields = constraint.fields
+            ? constraint.fields.map((f) => this.quoteIdentifier(f)).join(', ')
+            : '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `${constraintName} PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${constraintName} UNIQUE (${fields})`;
+            case 'FOREIGN KEY': {
+                const refTable = constraint.references?.table;
+                const refFields = constraint.references?.field;
+                return `${constraintName} FOREIGN KEY (${fields}) REFERENCES ${this.quoteTable(refTable)} (${this.quoteIdentifier(refFields)})`;
+            }
+            case 'CHECK':
+                return `${constraintName} CHECK (${constraint.check})`;
+            default:
+                return '';
+        }
+    }
+    /**
+     * Drop a table
+     */
+    async dropTable(tableName, options) {
+        const plainSql = `DROP TABLE ${this.quoteTable(tableName)} CASCADE CONSTRAINTS`;
+        // Oracle's `DROP TABLE ... IF EXISTS` is 23c-only syntax and raises
+        // ORA-00922 against the 19c/21c versions this dialect targets. Use a
+        // portable existence check instead: run the plain DDL and silently
+        // ignore ORA-00942 ("table or view does not exist").
+        const sql = options?.ifExists
+            ? this.wrapIgnoringOraErrors(plainSql, [OracleDialect.ORA_TABLE_DOES_NOT_EXIST])
+            : plainSql;
+        await this.query(sql);
+    }
+    /**
+     * Create partitioned table (Oracle supports RANGE, LIST, HASH, and INTERVAL partitioning)
+     */
+    async createPartitionedTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.buildColumnDefinition(columnName, definition));
+        }
+        const partitionType = options?.partitionBy?.type || 'range';
+        let sql = `CREATE TABLE ${this.quoteTable(tableName)} (${columnDefs.join(', ')}) PARTITION BY ${partitionType.toUpperCase()}`;
+        if (partitionType === 'reference') {
+            // Reference partitioning has no partition key column of its own - the
+            // child table inherits its parent's partitioning scheme via an FK
+            // constraint: `PARTITION BY REFERENCE (constraint_name)`. The
+            // referenced constraint must already be defined on this table (e.g.
+            // via `options.constraints` / an inline column-level REFERENCES) and
+            // must point at a partitioned parent table.
+            if (!options?.partitionBy?.referenceConstraint) {
+                throw new Error("createPartitionedTable: partitionBy.type 'reference' requires " +
+                    'partitionBy.referenceConstraint (the name of the FK constraint whose parent ' +
+                    "table's partitioning scheme should be inherited).");
+            }
+            sql += ` (${this.quoteIdentifier(options.partitionBy.referenceConstraint)})`;
+            // Unlike RANGE/LIST/HASH, individual partitions (if named at all) take
+            // no VALUES/bound clause - they simply mirror the parent's partitions,
+            // optionally with their own name/tablespace.
+            if (options?.partitions && options.partitions.length > 0) {
+                const partitionDefs = options.partitions.map((part) => {
+                    let partDef = `PARTITION ${this.quoteIdentifier(part.name)}`;
+                    if (part.tablespace) {
+                        partDef += ` TABLESPACE ${part.tablespace}`;
+                    }
+                    return partDef;
+                });
+                sql += ` (${partitionDefs.join(', ')})`;
+            }
+            await this.query(sql);
+            return;
+        }
+        const partitionColumn = Array.isArray(options?.partitionBy?.column)
+            ? options.partitionBy.column.join(', ')
+            : options?.partitionBy?.column;
+        // Handle INTERVAL partitioning
+        if (partitionType === 'interval' && options?.partitionBy?.interval) {
+            sql += ` INTERVAL (${options.partitionBy.interval})`;
+        }
+        sql += ` (${this.quoteIdentifier(partitionColumn)}) (`;
+        if (options?.partitions) {
+            const partitionDefs = options.partitions.map((part) => {
+                let partDef = `PARTITION ${this.quoteIdentifier(part.name)}`;
+                if (part.bound) {
+                    if ('values' in part.bound && part.bound.values) {
+                        // LIST partition
+                        const values = part.bound.values.map((v) => (typeof v === 'string' ? `'${this.escapeString(String(v))}'` : v)).join(', ');
+                        partDef += ` VALUES (${values})`;
+                    }
+                    else if ('modulus' in part.bound && part.bound.modulus !== undefined) {
+                        // HASH partition
+                        const hashBound = part.bound;
+                        partDef += ` VALUES (MODULUS ${hashBound.modulus}, REMAINDER ${hashBound.remainder})`;
+                    }
+                    else {
+                        // RANGE partition
+                        const rangeBound = part.bound;
+                        partDef += ` VALUES LESS THAN (${rangeBound.from})`;
+                    }
+                }
+                if (part.tablespace) {
+                    partDef += ` TABLESPACE ${part.tablespace}`;
+                }
+                if (part.compression) {
+                    partDef += ` COMPRESS`;
+                }
+                if (part.storageParameters) {
+                    const params = Object.entries(part.storageParameters)
+                        .map(([key, value]) => `${key} = ${value}`)
+                        .join(', ');
+                    partDef += ` STORAGE (${params})`;
+                }
+                return partDef;
+            });
+            sql += partitionDefs.join(', ');
+        }
+        sql += ')';
+        // Handle subpartitions
+        if (options?.subpartitionBy) {
+            sql += ` SUBPARTITION BY ${options.subpartitionBy.type.toUpperCase()}`;
+            const subpartitionColumn = Array.isArray(options.subpartitionBy.column)
+                ? options.subpartitionBy.column.join(', ')
+                : options.subpartitionBy.column;
+            sql += ` (${this.quoteIdentifier(subpartitionColumn)}) (`;
+            if (options?.subpartitions) {
+                const subpartitionDefs = options.subpartitions.map((part) => {
+                    let partDef = `SUBPARTITION ${this.quoteIdentifier(part.name)}`;
+                    if (part.bound) {
+                        if ('values' in part.bound && part.bound.values) {
+                            const values = part.bound.values.map((v) => (typeof v === 'string' ? `'${this.escapeString(String(v))}'` : v)).join(', ');
+                            partDef += ` VALUES (${values})`;
+                        }
+                        else if ('modulus' in part.bound && part.bound.modulus !== undefined) {
+                            const hashBound = part.bound;
+                            partDef += ` VALUES (MODULUS ${hashBound.modulus}, REMAINDER ${hashBound.remainder})`;
+                        }
+                        else {
+                            const rangeBound = part.bound;
+                            partDef += ` VALUES LESS THAN (${rangeBound.from})`;
+                        }
+                    }
+                    if (part.tablespace) {
+                        partDef += ` TABLESPACE ${part.tablespace}`;
+                    }
+                    return partDef;
+                });
+                sql += subpartitionDefs.join(', ');
+            }
+            sql += ')';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create partition
+     * Supports subpartitions in Oracle
+     */
+    async createPartition(options) {
+        let sql = `ALTER TABLE ${this.quoteTable(options.parentTable)} ADD PARTITION ${this.quoteIdentifier(options.name)}`;
+        if (options.bound) {
+            if ('values' in options.bound && options.bound.values) {
+                const values = options.bound.values.map((v) => (typeof v === 'string' ? `'${this.escapeString(String(v))}'` : v)).join(', ');
+                sql += ` VALUES (${values})`;
+            }
+            else if ('modulus' in options.bound && options.bound.modulus !== undefined) {
+                const hashBound = options.bound;
+                sql += ` VALUES (MODULUS ${hashBound.modulus}, REMAINDER ${hashBound.remainder})`;
+            }
+            else {
+                const rangeBound = options.bound;
+                sql += ` VALUES LESS THAN (${rangeBound.from})`;
+            }
+        }
+        if (options.tablespace) {
+            sql += ` TABLESPACE ${options.tablespace}`;
+        }
+        if (options.compression) {
+            sql += ` COMPRESS`;
+        }
+        if (options.storageParameters) {
+            const params = Object.entries(options.storageParameters)
+                .map(([key, value]) => `${key} = ${value}`)
+                .join(', ');
+            sql += ` STORAGE (${params})`;
+        }
+        // Handle subpartitions
+        if (options?.subpartitionBy) {
+            sql += ` SUBPARTITION BY ${options.subpartitionBy.type.toUpperCase()}`;
+            const subpartitionColumn = Array.isArray(options.subpartitionBy.column)
+                ? options.subpartitionBy.column.join(', ')
+                : options.subpartitionBy.column;
+            sql += ` (${this.quoteIdentifier(subpartitionColumn)}) (`;
+            if (options?.subpartitions) {
+                const subpartitionDefs = options.subpartitions.map((part) => {
+                    let partDef = `SUBPARTITION ${this.quoteIdentifier(part.name)}`;
+                    if (part.bound) {
+                        if ('values' in part.bound && part.bound.values) {
+                            const values = part.bound.values.map((v) => (typeof v === 'string' ? `'${this.escapeString(String(v))}'` : v)).join(', ');
+                            partDef += ` VALUES (${values})`;
+                        }
+                        else if ('modulus' in part.bound && part.bound.modulus !== undefined) {
+                            const hashBound = part.bound;
+                            partDef += ` VALUES (MODULUS ${hashBound.modulus}, REMAINDER ${hashBound.remainder})`;
+                        }
+                        else {
+                            const rangeBound = part.bound;
+                            partDef += ` VALUES LESS THAN (${rangeBound.from})`;
+                        }
+                    }
+                    if (part.tablespace) {
+                        partDef += ` TABLESPACE ${part.tablespace}`;
+                    }
+                    return partDef;
+                });
+                sql += subpartitionDefs.join(', ');
+            }
+            sql += ')';
+        }
+        await this.query(sql);
+    }
+    /**
+     * "Attach" a partition (Oracle has no PostgreSQL-style `ATTACH PARTITION`
+     * statement). The real Oracle equivalent for bringing an existing
+     * standalone table's data into a partitioned table's partition is
+     * `ALTER TABLE ... EXCHANGE PARTITION ... WITH TABLE ...`, which swaps the
+     * data segment of the partition with that of the standalone table as a
+     * fast, DDL-only (no data movement) operation.
+     *
+     * `options.exchangeTable` names the standalone table whose data becomes
+     * the partition's data; it defaults to `options.partitionName` for
+     * backwards compatibility with callers that used the partition name and
+     * the exchange-table name interchangeably.
+     */
+    async attachPartition(options) {
+        const exchangeTable = options.exchangeTable || options.partitionName;
+        let sql = `ALTER TABLE ${this.quoteTable(options.parentTable)} EXCHANGE PARTITION ${this.quoteIdentifier(options.partitionName)} WITH TABLE ${this.quoteTable(exchangeTable)}`;
+        if (options.includingIndexes) {
+            sql += ' INCLUDING INDEXES';
+        }
+        sql += ` ${options.validation || 'WITH VALIDATION'}`;
+        await this.query(sql);
+    }
+    /**
+     * "Detach" a partition (Oracle has no PostgreSQL-style `DETACH PARTITION`
+     * statement). The real Oracle equivalent for extracting a partition's data
+     * out into a standalone table is the same `EXCHANGE PARTITION` statement
+     * used by {@link attachPartition} - it symmetrically swaps segments, so
+     * "detaching" is exchanging the partition with an (often empty) standalone
+     * table, leaving that table holding the former partition's data.
+     */
+    async detachPartition(options) {
+        const exchangeTable = options.exchangeTable || options.partitionName;
+        let sql = `ALTER TABLE ${this.quoteTable(options.parentTable)} EXCHANGE PARTITION ${this.quoteIdentifier(options.partitionName)} WITH TABLE ${this.quoteTable(exchangeTable)}`;
+        if (options.includingIndexes) {
+            sql += ' INCLUDING INDEXES';
+        }
+        sql += options.validate === false ? ' WITHOUT VALIDATION' : ' WITH VALIDATION';
+        await this.query(sql);
+    }
+    /**
+     * Drop partition
+     * Enhanced with cascade option for Oracle
+     */
+    async dropPartition(partitionName, options) {
+        let sql = 'ALTER TABLE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.quoteTable(partitionName)} DROP PARTITION`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        if (options?.updateIndexes) {
+            sql += ' UPDATE INDEXES';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Add a partition to an existing partitioned table (Oracle)
+     * @param tableName - Name of the partitioned table
+     * @param partitionName - Name for the new partition
+     * @param partitionSpec - Partition specification
+     */
+    async addPartition(tableName, partitionName, partitionSpec) {
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD PARTITION ${this.escapeId(partitionName)}`;
+        if (partitionSpec.values) {
+            sql += ` VALUES ${partitionSpec.values}`;
+        }
+        else if (partitionSpec.forValues) {
+            sql += ` VALUES LESS THAN ${partitionSpec.forValues}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * List partitions for a table with details
+     */
+    async listPartitions(tableName) {
+        const sql = `
+      SELECT
+        PARTITION_NAME as partitionName,
+        PARTITION_POSITION as partitionPosition,
+        HIGH_VALUE as highValue,
+        PARTITION_TYPE as partitionType,
+        TABLESPACE_NAME as tablespaceName,
+        COMPRESSION as compression,
+        NUM_ROWS as numRows
+      FROM USER_TAB_PARTITIONS
+      WHERE TABLE_NAME = :tableName
+      ORDER BY PARTITION_POSITION
+    `;
+        const result = await this.query(sql, { replacements: { tableName: tableName.toUpperCase() }, raw: true });
+        return result.rows.map((row) => ({
+            partitionName: row.partitionName,
+            partitionPosition: row.partitionPosition,
+            highValue: row.highValue,
+            partitionType: row.partitionType,
+            tablespaceName: row.tablespaceName,
+            compression: row.compression,
+            numRows: row.numRows,
+        }));
+    }
+    /**
+     * Modify partition (move, compress)
+     */
+    async modifyPartition(tableName, partitionName, options) {
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} MODIFY PARTITION ${this.quoteIdentifier(partitionName)}`;
+        const actions = [];
+        if (options?.move && options?.tablespace) {
+            actions.push(`MOVE TABLESPACE ${options.tablespace}`);
+        }
+        if (options?.compress) {
+            actions.push('COMPRESS');
+        }
+        if (options?.storageParameters) {
+            const params = Object.entries(options.storageParameters)
+                .map(([key, value]) => `${key} = ${value}`)
+                .join(', ');
+            actions.push(`STORAGE (${params})`);
+        }
+        if (options?.updateIndexes) {
+            actions.push('UPDATE INDEXES');
+        }
+        if (actions.length > 0) {
+            sql += ' ' + actions.join(' ');
+        }
+        await this.query(sql);
+    }
+    // ==================== Foreign Data Wrapper Stubs ====================
+    // Oracle uses Data Guard for external data connections, not FDW
+    /**
+     * Create foreign data wrapper (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async createForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    /**
+     * Drop foreign data wrapper (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async dropForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    /**
+     * Create foreign server (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async createForeignServer(_serverName, _fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    /**
+     * Drop foreign server (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async dropForeignServer(_serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    /**
+     * Create foreign table (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async createForeignTable(_tableName, _columns, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    /**
+     * Create user mapping (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async createUserMapping(_serverName, _userName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    /**
+     * Drop user mapping (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    async dropUserMapping(_serverName, _userName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    async changeOwner(_newOwner, _tableName) {
+        throw new Error('changeOwner is not supported in Oracle');
+    }
+    async addConstraint(_tableName, _options) {
+        throw new Error('addConstraint is not supported in Oracle');
+    }
+    async removeConstraint(_tableName, _constraintName) {
+        throw new Error('removeConstraint is not supported in Oracle');
+    }
+    async createSecurityPolicy(_policyName, _tableName, _options) {
+        throw new Error('Security policies are not supported in Oracle');
+    }
+    async dropSecurityPolicy(_policyName, _tableName) {
+        throw new Error('Security policies are not supported in Oracle');
+    }
+    // ==================== View Operations ====================
+    /**
+     * Create a view
+     */
+    async createView(viewName, query, options) {
+        const sql = options?.replace
+            ? `CREATE OR REPLACE VIEW ${this.quoteIdentifier(viewName)} AS ${query}`
+            : `CREATE VIEW ${this.quoteIdentifier(viewName)} AS ${query}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a view
+     */
+    async dropView(viewName, options) {
+        const sql = options?.ifExists
+            ? `DROP VIEW ${this.quoteIdentifier(viewName)}`
+            : `DROP VIEW ${this.quoteIdentifier(viewName)} CASCADE`;
+        await this.query(sql);
+    }
+    /**
+     * Show all views
+     */
+    async showViews() {
+        const result = await this.query(`SELECT VIEW_NAME FROM USER_VIEWS ORDER BY VIEW_NAME`);
+        return result.rows.map((row) => row.VIEW_NAME);
+    }
+    // ==================== Materialized View Operations ====================
+    /**
+     * Create a materialized view
+     * Oracle syntax:
+     * CREATE MATERIALIZED VIEW mv_name
+     * BUILD [IMMEDIATE | DEFERRED]
+     * REFRESH [FAST | COMPLETE | FORCE]
+     * ON [COMMIT | DEMAND]
+     * AS query
+     */
+    async createMaterializedView(options) {
+        const viewNameWithSchema = options.schema
+            ? `${this.quoteIdentifier(options.schema)}.${this.quoteIdentifier(options.name)}`
+            : this.quoteIdentifier(options.name);
+        let sql = 'CREATE MATERIALIZED VIEW';
+        // Note: Oracle doesn't support OR REPLACE or IF NOT EXISTS for materialized views
+        // We need to handle these differently
+        if (options.replace) {
+            // Check if exists and drop first
+            const exists = await this.hasMaterializedView(options.name, options.schema);
+            if (exists) {
+                await this.dropMaterializedView(options.name, { schema: options.schema });
+            }
+        }
+        sql += ` ${viewNameWithSchema}`;
+        // BUILD clause
+        if (options.build) {
+            sql += ` BUILD ${options.build}`;
+        }
+        else {
+            sql += ' BUILD IMMEDIATE'; // Default for Oracle
+        }
+        sql += ` AS ${options.query}`;
+        // REFRESH clause
+        if (options.refresh) {
+            sql += ` REFRESH ${options.refresh}`;
+        }
+        else {
+            sql += ' REFRESH FORCE'; // Default for Oracle
+        }
+        // ON clause
+        if (options.on) {
+            sql += ` ON ${options.on}`;
+        }
+        else {
+            sql += ' ON DEMAND'; // Default for Oracle
+        }
+        await this.query(sql);
+        // Add comment if provided
+        if (options.comment) {
+            await this.commentMaterializedView(options.name, options.comment, options.schema);
+        }
+    }
+    /**
+     * Refresh a materialized view
+     * Oracle supports: FAST, COMPLETE, FORCE
+     * - FAST: Incremental refresh using materialized view logs
+     * - COMPLETE: Full refresh (recreates the entire view)
+     * - FORCE: Tries FAST, falls back to COMPLETE if not possible
+     */
+    async refreshMaterializedView(viewName, options) {
+        // Oracle has no `REFRESH MATERIALIZED VIEW` DDL/DML statement (that
+        // syntax is Postgres's) - materialized views are refreshed by calling
+        // the DBMS_MVIEW.REFRESH PL/SQL package, which takes the (schema-
+        // qualified, unquoted) view name as a plain string argument, not a SQL
+        // identifier.
+        const schema = options?.schema;
+        const viewNameWithSchema = schema ? `${schema}.${viewName}` : viewName;
+        let refreshType = 'FORCE'; // Default
+        // Handle both Oracle refresh method and PostgreSQL concurrently option
+        if (options?.refresh) {
+            refreshType = options.refresh;
+        }
+        else if (options?.concurrently) {
+            // CONCURRENTLY not supported in Oracle, use FORCE instead
+            refreshType = 'FORCE';
+        }
+        // DBMS_MVIEW.REFRESH's method parameter is a single-character code:
+        // 'C' = complete, 'F' = fast, '?' = force (let Oracle decide).
+        const methodCode = refreshType === 'COMPLETE' ? 'C' : refreshType === 'FAST' ? 'F' : '?';
+        const sql = `BEGIN DBMS_MVIEW.REFRESH(:1, :2); END;`;
+        await this.query(sql, { replacements: [viewNameWithSchema, methodCode] });
+    }
+    /**
+     * Drop a materialized view
+     */
+    async dropMaterializedView(viewName, options) {
+        const schema = options?.schema;
+        const viewNameWithSchema = schema
+            ? `${this.quoteIdentifier(schema)}.${this.quoteIdentifier(viewName)}`
+            : this.quoteIdentifier(viewName);
+        let sql = `DROP MATERIALIZED VIEW`;
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${viewNameWithSchema}`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Show all materialized views
+     */
+    async showMaterializedViews() {
+        const result = await this.query(`SELECT MVIEW_NAME FROM USER_MVIEWS ORDER BY MVIEW_NAME`);
+        return result.rows.map((row) => row.MVIEW_NAME);
+    }
+    /**
+     * Check if a materialized view exists
+     * @param viewName - Name of the materialized view
+     * @param schema - Optional schema name
+     * @returns True if the materialized view exists
+     */
+    async hasMaterializedView(viewName, schema) {
+        let sql = `SELECT 1 FROM USER_MVIEWS WHERE MVIEW_NAME = ${this.escape(viewName)}`;
+        if (schema) {
+            sql += ` AND OWNER = ${this.escape(schema.toUpperCase())}`;
+        }
+        const result = await this.query(sql, { raw: true });
+        return result.rows?.length > 0;
+    }
+    /**
+     * Add comment to materialized view
+     */
+    async commentMaterializedView(viewName, comment, schema) {
+        const viewNameWithSchema = schema
+            ? `${this.quoteIdentifier(schema)}.${this.quoteIdentifier(viewName)}`
+            : this.quoteIdentifier(viewName);
+        const sql = `COMMENT ON MATERIALIZED VIEW ${viewNameWithSchema} IS ${this.escapeString(comment)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a materialized view log on a master table.
+     *
+     * FAST (incremental) refresh - as used by `refreshMaterializedView()` -
+     * requires a materialized view log on every master table referenced by the
+     * materialized view; without one, `DBMS_MVIEW.REFRESH(..., 'F')` fails with
+     * ORA-23413. This creates that log.
+     *
+     * Oracle syntax:
+     * ```sql
+     * CREATE MATERIALIZED VIEW LOG ON table_name
+     *   WITH [ROWID] [, PRIMARY KEY] [, SEQUENCE] [(col1, col2, ...)] [INCLUDING NEW VALUES]
+     * ```
+     */
+    async createMaterializedViewLog(tableName, options) {
+        const tableNameWithSchema = this.quoteTable(tableName, options?.schema);
+        let sql = `CREATE MATERIALIZED VIEW LOG ON ${tableNameWithSchema}`;
+        const withParts = [];
+        if (options?.withRowid) {
+            withParts.push('ROWID');
+        }
+        if (options?.withPrimaryKey) {
+            withParts.push('PRIMARY KEY');
+        }
+        if (options?.sequence) {
+            withParts.push('SEQUENCE');
+        }
+        // Oracle's own default (when neither ROWID nor PRIMARY KEY is
+        // requested) is PRIMARY KEY - mirror that here so the generated SQL is
+        // always explicit rather than relying on server-side defaulting. A bare
+        // filter-column list is not valid on its own (Oracle requires at least
+        // one of ROWID/PRIMARY KEY/SEQUENCE to precede it), so this also covers
+        // the case where only `columns` was passed.
+        if (withParts.length === 0) {
+            withParts.push('PRIMARY KEY');
+        }
+        sql += ` WITH ${withParts.join(', ')}`;
+        if (options?.columns && options.columns.length > 0) {
+            const columnList = options.columns.map((c) => this.quoteIdentifier(c)).join(', ');
+            sql += ` (${columnList})`;
+        }
+        // INCLUDING NEW VALUES defaults to true: required for fast refresh of
+        // materialized views containing aggregate functions, and harmless
+        // otherwise.
+        sql += options?.includingNewValues === false ? ' EXCLUDING NEW VALUES' : ' INCLUDING NEW VALUES';
+        await this.query(sql);
+    }
+    /**
+     * Drop a materialized view log from a master table.
+     * Oracle syntax: `DROP MATERIALIZED VIEW LOG ON table_name`
+     * (Oracle has no `IF EXISTS` variant for this statement.)
+     */
+    async dropMaterializedViewLog(tableName, options) {
+        const tableNameWithSchema = this.quoteTable(tableName, options?.schema);
+        const sql = `DROP MATERIALIZED VIEW LOG ON ${tableNameWithSchema}`;
+        await this.query(sql);
+    }
+    // ==================== Column Operations ====================
+    /**
+     * Add a column
+     */
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD ${this.buildColumnDefinition(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Remove a column
+     */
+    async removeColumn(tableName, columnName) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} DROP COLUMN ${this.quoteIdentifier(columnName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Change a column
+     */
+    async changeColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} MODIFY ${this.buildColumnDefinition(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Describe a table
+     */
+    async describeTable(tableName) {
+        const result = await this.query(`SELECT COLUMN_NAME, DATA_TYPE, DATA_LENGTH, DATA_PRECISION, DATA_SCALE, NULLABLE, DATA_DEFAULT, COLUMN_ID
+       FROM USER_TAB_COLUMNS
+       WHERE TABLE_NAME = UPPER('${tableName}')
+       ORDER BY COLUMN_ID`);
+        const description = {};
+        for (const row of result.rows) {
+            description[row.COLUMN_NAME.toLowerCase()] = {
+                type: row.DATA_TYPE,
+                allowNull: row.NULLABLE === 'Y',
+                defaultValue: row.DATA_DEFAULT,
+                primaryKey: false,
+                autoIncrement: false,
+            };
+        }
+        // Check for primary keys
+        const pkResult = await this.query(`SELECT COLUMN_NAME FROM USER_CONS_COLUMNS
+       WHERE TABLE_NAME = UPPER('${tableName}')
+       AND CONSTRAINT_NAME IN (
+         SELECT CONSTRAINT_NAME FROM USER_CONSTRAINTS
+         WHERE CONSTRAINT_TYPE = 'P'
+       )`);
+        for (const row of pkResult.rows) {
+            const colName = row.COLUMN_NAME.toLowerCase();
+            if (description[colName]) {
+                description[colName].primaryKey = true;
+            }
+        }
+        return description;
+    }
+    /**
+     * Rename a table
+     */
+    async renameTable(oldName, newName) {
+        const sql = `ALTER TABLE ${this.quoteTable(oldName)} RENAME TO ${this.quoteIdentifier(newName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Show all tables
+     */
+    async showTables() {
+        const result = await this.query(`SELECT TABLE_NAME FROM USER_TABLES ORDER BY TABLE_NAME`);
+        return result.rows.map((row) => row.TABLE_NAME);
+    }
+    /**
+     * Get table status (Oracle implementation)
+     */
+    async getTableStatus(tableName) {
+        const sql = tableName
+            ? `SELECT TABLE_NAME, TABLE_TYPE FROM USER_TABLES WHERE TABLE_NAME = UPPER(:tableName)`
+            : `SELECT TABLE_NAME, TABLE_TYPE FROM USER_TABLES`;
+        const result = tableName
+            ? await this.query(sql, { bindings: { tableName } })
+            : await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Get table create statement (Oracle implementation)
+     */
+    async getCreateTable(tableName) {
+        const sql = `SELECT DBMS_METADATA.GET_DDL('TABLE', UPPER(:tableName)) AS CreateStatement FROM DUAL`;
+        const result = await this.query(sql, { bindings: { tableName } });
+        return result.rows[0]?.CreateStatement || '';
+    }
+    /**
+     * Check if a table has partitions (Oracle implementation)
+     */
+    async hasPartition(tableName) {
+        const sql = `
+      SELECT 1 FROM USER_TAB_PARTITIONS
+      WHERE TABLE_NAME = UPPER(:tableName) AND ROWNUM = 1
+    `;
+        const result = await this.query(sql, { bindings: { tableName } });
+        return result.rows.length > 0;
+    }
+    /**
+     * Show constraints for a table
+     */
+    async showConstraints(tableName) {
+        const sql = `
+      SELECT
+        c.constraint_name AS name,
+        c.table_name AS tableName,
+        c.constraint_type AS type,
+        cc.column_name AS columnName
+      FROM user_constraints c
+      LEFT JOIN user_cons_columns cc
+        ON c.constraint_name = cc.constraint_name
+      WHERE c.table_name = '${tableName.toUpperCase()}'
+      ORDER BY c.constraint_name
+    `;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Show indexes for a table
+     */
+    async showIndexes(tableName) {
+        const sql = `
+      SELECT
+        i.index_name AS name,
+        i.table_name AS tableName,
+        i.uniqueness AS uniqueness,
+        ic.column_name AS columnName,
+        ic.column_position AS columnPosition
+      FROM user_indexes i
+      LEFT JOIN user_ind_columns ic
+        ON i.index_name = ic.index_name
+      WHERE i.table_name = '${tableName.toUpperCase()}'
+      ORDER BY i.index_name, ic.column_position
+    `;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    // ==================== Index Operations ====================
+    /**
+     * Add an index
+     */
+    async addIndex(tableName, indexName, fields, options) {
+        const sql = this.buildCreateIndexSql(tableName, indexName, fields, options);
+        await this.query(sql);
+    }
+    /**
+     * Build CREATE INDEX SQL
+     */
+    buildCreateIndexSql(tableName, indexName, fields, options) {
+        const fieldsArr = fields || [];
+        const fieldsSql = fieldsArr.map((f) => this.quoteIdentifier(f)).join(', ');
+        let sql = `CREATE`;
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        if (options?.type) {
+            sql += ` ${options.type.toUpperCase()}`;
+        }
+        sql += ` INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql})`;
+        if (options?.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        return sql;
+    }
+    /**
+     * Remove an index
+     */
+    async removeIndex(tableName, indexName) {
+        const sql = `DROP INDEX ${this.quoteIdentifier(indexName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create an index with full options
+     */
+    async createIndex(tableName, indexDef) {
+        const sql = this.buildCreateIndexSql(tableName, indexDef.name, indexDef.fields, {
+            unique: indexDef.unique,
+            type: indexDef.type,
+            using: indexDef.using,
+            where: indexDef.where,
+        });
+        await this.query(sql);
+    }
+    /**
+     * Drop an index
+     */
+    async dropIndex(tableName, indexName, _options) {
+        const sql = `DROP INDEX ${this.quoteIdentifier(indexName)}`;
+        await this.query(sql);
+    }
+    // ==================== Constraint Operations ====================
+    /**
+     * Create a constraint
+     */
+    async createConstraint(tableName, constraintDef) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD ${this.buildConstraintDefinition(constraintDef)}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a constraint
+     */
+    async dropConstraint(tableName, constraintName, options) {
+        const sql = options?.ifExists
+            ? `ALTER TABLE ${this.quoteTable(tableName)} DROP CONSTRAINT ${this.quoteIdentifier(constraintName)}`
+            : `ALTER TABLE ${this.quoteTable(tableName)} DROP CONSTRAINT ${this.quoteIdentifier(constraintName)} CASCADE`;
+        await this.query(sql);
+    }
+    /**
+     * Start a transaction
+     */
+    async startTransaction(options) {
+        const connection = await this.getConnection();
+        if (options?.isolationLevel) {
+            const level = options.isolationLevel.toUpperCase().trim();
+            if (level === 'READ ONLY') {
+                await connection.execute('SET TRANSACTION READ ONLY');
+            }
+            else if (OracleDialect.SUPPORTED_ISOLATION_LEVELS.has(level)) {
+                await connection.execute(`SET TRANSACTION ISOLATION LEVEL ${level}`);
+            }
+            else {
+                throw new errors_1.DatabaseError(`Oracle does not support isolation level '${options.isolationLevel}'. ` +
+                    `Oracle only supports READ COMMITTED and SERIALIZABLE (plus READ ONLY ` +
+                    `transactions), not the ANSI READ UNCOMMITTED/REPEATABLE READ levels.`);
+            }
+        }
+        return new OracleTransaction(connection, options);
+    }
+    /**
+     * Commit a transaction
+     */
+    // ==================== Savepoint Methods ====================
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name) {
+        const savepointName = name || `sp_${Date.now()}`;
+        return `SAVEPOINT ${savepointName}`;
+    }
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name) {
+        return `RELEASE SAVEPOINT ${name}`;
+    }
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TO SAVEPOINT ${name}`;
+    }
+    /**
+     * Commit a transaction
+     */
+    async commitTransaction(transaction) {
+        const oracleTx = transaction;
+        if (oracleTx.connection) {
+            await oracleTx.connection.commit();
+            await oracleTx.connection.close();
+            oracleTx.finished = true;
+        }
+    }
+    /**
+     * Rollback a transaction
+     */
+    async rollbackTransaction(transaction) {
+        const oracleTx = transaction;
+        if (oracleTx.connection) {
+            await oracleTx.connection.rollback();
+            await oracleTx.connection.close();
+            oracleTx.finished = true;
+        }
+    }
+    // ==================== Data Type Mapping ====================
+    /**
+     * Get SQL for a data type
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            return this.mapDataType(dataType);
+        }
+        const dt = dataType;
+        return this.mapDataType(dataType.key, dt);
+    }
+    /**
+     * Map ORM data type to Oracle data type
+     *
+     * `attrs` carries the optional `length`/`precision`/`scale` fields present
+     * on types like `DataTypeString` and `DataTypeNumber`/`DataTypeDecimal`
+     * (see `src/types/index.ts`) so that, e.g., `STRING(4000)` correctly emits
+     * `VARCHAR2(4000)` and `DECIMAL(18,4)` emits `NUMBER(18,4)` instead of
+     * silently falling back to the default sizes.
+     */
+    mapDataType(typeKey, attrs) {
+        const key = typeKey.toUpperCase();
+        const length = attrs?.length;
+        const precision = attrs?.precision;
+        const scale = attrs?.scale;
+        switch (key) {
+            case 'STRING':
+                return `VARCHAR2(${length ?? 255})`;
+            case 'CHAR':
+                return `CHAR(${length ?? 1})`;
+            case 'TINYTEXT':
+                return `VARCHAR2(${length ?? 255})`;
+            case 'NUMBER':
+            case 'DECIMAL':
+            case 'NUMERIC':
+                if (precision !== undefined && scale !== undefined) {
+                    return `NUMBER(${precision},${scale})`;
+                }
+                if (precision !== undefined) {
+                    return `NUMBER(${precision})`;
+                }
+                return 'NUMBER';
+            case 'INTEGER':
+                return `NUMBER(${length ?? 10})`;
+            case 'BIGINT':
+                return `NUMBER(${length ?? 19})`;
+            case 'BINARY':
+                return `RAW(${length ?? 255})`;
+            case 'VARBINARY':
+                return `RAW(${length ?? 2000})`;
+            case 'NVARCHAR2':
+                return `NVARCHAR2(${length ?? 255})`;
+            case 'NCHAR':
+                return `NCHAR(${length ?? 1})`;
+            case 'RAW':
+                return `RAW(${length ?? 255})`;
+            default:
+                break;
+        }
+        const typeMap = {
+            // Text types
+            TEXT: 'CLOB',
+            MEDIUMTEXT: 'CLOB',
+            LONGTEXT: 'CLOB',
+            // Number types
+            FLOAT: 'FLOAT',
+            DOUBLE: 'FLOAT',
+            // Boolean
+            BOOLEAN: 'NUMBER(1)',
+            // Oracle doesn't have native boolean, use NUMBER(1)
+            // Date types
+            DATE: 'DATE',
+            DATETIME: 'TIMESTAMP',
+            TIMESTAMP: 'TIMESTAMP',
+            DATEONLY: 'DATE',
+            TIME: 'VARCHAR2(8)',
+            // Blob types
+            BLOB: 'BLOB',
+            BIT: 'RAW(1)',
+            // JSON
+            JSON: 'CLOB',
+            JSONB: 'BLOB',
+            // UUID
+            UUID: 'RAW(16)',
+            // Geometry
+            GEOMETRY: 'SDO_GEOMETRY',
+            // Oracle-specific types
+            CLOB: 'CLOB',
+            NCLOB: 'NCLOB',
+            BFILE: 'BFILE',
+            LONG_RAW: 'LONG RAW',
+            XMLTYPE: 'XMLTYPE',
+        };
+        return typeMap[key] || 'VARCHAR2(255)';
+    }
+    // ==================== Query Builders ====================
+    /**
+     * Build WHERE clause
+     */
+    buildWhereClause(where, options) {
+        const values = [];
+        const sqlParts = [];
+        if (!where || Object.keys(where).length === 0) {
+            return { sql: '', values };
+        }
+        for (const [key, value] of Object.entries(where)) {
+            if (key === 'and' || key === 'or') {
+                const conditions = value.map((cond) => {
+                    const result = this.buildWhereClause(cond, options);
+                    values.push(...result.values);
+                    return result.sql;
+                });
+                sqlParts.push(`(${conditions.join(` ${key.toUpperCase()} `)})`);
+            }
+            else if (key.startsWith('$')) {
+                // Handle operators like $like, $in, etc.
+                const result = this.buildOperatorWhere(key, value, options);
+                if (result) {
+                    values.push(...result.values);
+                    sqlParts.push(result.sql);
+                }
+            }
+            else {
+                // Simple key = value
+                if (value === null) {
+                    sqlParts.push(`${this.quoteIdentifier(key)} IS NULL`);
+                }
+                else if (Array.isArray(value)) {
+                    sqlParts.push(`${this.quoteIdentifier(key)} IN (${value.map(() => '?').join(', ')})`);
+                    values.push(...value);
+                }
+                else {
+                    sqlParts.push(`${this.quoteIdentifier(key)} = ?`);
+                    values.push(value);
+                }
+            }
+        }
+        return {
+            sql: sqlParts.length > 0 ? sqlParts.join(' AND ') : '',
+            values,
+        };
+    }
+    /**
+     * Build operator WHERE clause
+     */
+    buildOperatorWhere(key, value, _options) {
+        const values = [];
+        switch (key) {
+            case '$like':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} LIKE ?`,
+                    values: [Object.values(value)[0]],
+                };
+            case '$notLike':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} NOT LIKE ?`,
+                    values: [Object.values(value)[0]],
+                };
+            case '$in':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} IN (?)`,
+                    values: [Object.values(value)[0]],
+                };
+            case '$notIn':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} NOT IN (?)`,
+                    values: [Object.values(value)[0]],
+                };
+            case '$between': {
+                const betweenValues = Object.values(value)[0];
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} BETWEEN ? AND ?`,
+                    values: [betweenValues[0], betweenValues[1]],
+                };
+            }
+            case '$notBetween': {
+                const betweenValues = Object.values(value)[0];
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} NOT BETWEEN ? AND ?`,
+                    values: [betweenValues[0], betweenValues[1]],
+                };
+            }
+            case '$gt':
+            case '$gte':
+            case '$lt':
+            case '$lte':
+            case '$eq':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} ${key.slice(1)} ?`,
+                    values: [Object.values(value)[0]],
+                };
+            case '$isNull':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} IS NULL`,
+                    values: [],
+                };
+            case '$notNull':
+                return {
+                    sql: `${this.quoteIdentifier(Object.keys(value)[0])} IS NOT NULL`,
+                    values: [],
+                };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Build ORDER BY clause
+     */
+    buildOrderClause(order, _options) {
+        if (!order || (Array.isArray(order) && order.length === 0)) {
+            return '';
+        }
+        const orderParts = Array.isArray(order)
+            ? order.map((o) => {
+                const field = Object.keys(o)[0];
+                const direction = Object.values(o)[0];
+                return `${this.quoteIdentifier(field)} ${direction === 'DESC' ? 'DESC' : 'ASC'}`;
+            })
+            : Object.entries(order).map(([field, direction]) => {
+                return `${this.quoteIdentifier(field)} ${direction === 'DESC' ? 'DESC' : 'ASC'}`;
+            });
+        return `ORDER BY ${orderParts.join(', ')}`;
+    }
+    /**
+     * Build a list of ORDER BY items (without the leading `ORDER BY` keyword),
+     * suitable for embedding inside `OVER (...)` / `WITHIN GROUP (...)` clauses.
+     */
+    buildOrderByItems(order) {
+        return this.buildOrderClause(order).replace(/^ORDER BY /, '');
+    }
+    /**
+     * Build an Oracle analytic/window function expression, e.g.
+     * `ROW_NUMBER() OVER (PARTITION BY "dept" ORDER BY "salary" DESC)`.
+     */
+    buildWindowFunction(options) {
+        const args = (options.args || [])
+            .map((a) => (typeof a === 'number' ? a : this.quoteIdentifier(a)))
+            .join(', ');
+        const overParts = [];
+        if (options.partitionBy) {
+            const partitions = Array.isArray(options.partitionBy)
+                ? options.partitionBy
+                : [options.partitionBy];
+            overParts.push(`PARTITION BY ${partitions.map((p) => this.quoteIdentifier(p)).join(', ')}`);
+        }
+        if (options.orderBy) {
+            overParts.push(`ORDER BY ${this.buildOrderByItems(options.orderBy)}`);
+        }
+        if (options.frame) {
+            const frame = options.frame;
+            overParts.push(frame.end
+                ? `${frame.type} BETWEEN ${frame.start} AND ${frame.end}`
+                : `${frame.type} ${frame.start}`);
+        }
+        const over = overParts.length > 0 ? overParts.join(' ') : '';
+        const sql = `${options.fn.toUpperCase()}(${args}) OVER (${over})`;
+        return options.as ? `${sql} AS ${this.quoteIdentifier(options.as)}` : sql;
+    }
+    /**
+     * Build a `WITH ... AS (...)` common table expression clause and prepend it
+     * to a main query. A CTE is made recursive simply by supplying
+     * `unionQuery` (Oracle has no `RECURSIVE` keyword - the self-reference
+     * inside the UNION ALL member is what makes it recursive).
+     */
+    buildCTE(ctes, mainQuery) {
+        const list = Array.isArray(ctes) ? ctes : [ctes];
+        const values = [];
+        const cteParts = list.map((cte) => {
+            const columns = cte.columns
+                ? ` (${cte.columns.map((c) => this.quoteIdentifier(c)).join(', ')})`
+                : '';
+            const body = cte.unionQuery ? `${cte.query} UNION ALL ${cte.unionQuery}` : cte.query;
+            if (cte.values) {
+                values.push(...cte.values);
+            }
+            return `${this.quoteIdentifier(cte.name)}${columns} AS (${body})`;
+        });
+        const sql = `WITH ${cteParts.join(', ')} ${mainQuery}`;
+        return { sql, values };
+    }
+    /**
+     * Build an Oracle hierarchical query using `START WITH ... CONNECT BY PRIOR`,
+     * the pre-recursive-CTE idiom Oracle has supported since 8i and still
+     * commonly used/expected in Oracle codebases.
+     */
+    buildConnectByQuery(options) {
+        const values = [];
+        const baseAttributes = options.attributes
+            ? options.attributes.map((a) => this.quoteIdentifier(a))
+            : ['*'];
+        if (options.includePseudoColumns) {
+            baseAttributes.push('LEVEL', 'CONNECT_BY_ISLEAF');
+        }
+        let sql = `SELECT ${baseAttributes.join(', ')} FROM ${this.quoteTable(options.tableName, options.schema)}`;
+        if (options.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        if (options.startWith) {
+            sql += ` START WITH ${options.startWith}`;
+        }
+        sql += ` CONNECT BY ${options.nocycle ? 'NOCYCLE ' : ''}${options.connectByPrior}`;
+        if (options.orderSiblingsBy) {
+            sql += ` ORDER SIBLINGS BY ${this.buildOrderByItems(options.orderSiblingsBy)}`;
+        }
+        return { sql, values };
+    }
+    /**
+     * Build LIMIT/OFFSET clause using ROWNUM
+     */
+    buildLimitOffset(limit, offset) {
+        // Oracle uses ROWNUM for pagination
+        let sql = '';
+        if (limit !== undefined && offset !== undefined) {
+            sql = `WHERE ROWNUM <= ${parseInt(limit, 10) + parseInt(offset, 10)}`;
+        }
+        else if (limit !== undefined) {
+            sql = `WHERE ROWNUM <= ${limit}`;
+        }
+        return sql;
+    }
+    /**
+     * Build INSERT query
+     */
+    buildInsertQuery(tableName, values, options) {
+        const fields = Object.keys(values);
+        const placeholders = fields.map((_, i) => `:${i + 1}`).join(', ');
+        const fieldNames = fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        let sql = `INSERT INTO ${this.quoteTable(tableName, options?.schema)} (${fieldNames}) VALUES (${placeholders})`;
+        const bindValues = Object.values(values);
+        if (options?.returning) {
+            // Oracle has no `?` placeholder support at all - every bind, including
+            // the OUT bind(s) used by `RETURNING ... INTO`, must be a positional
+            // `:n` bind that continues numbering after the INSERT's own `:1..:n`
+            // binds, and a corresponding placeholder value must be appended to the
+            // values/binds array so the bind count sent to the driver matches the
+            // bind count in the SQL text.
+            let nextBindIndex = fields.length + 1;
+            // node-oracledb needs an explicit bind descriptor (direction + type) to
+            // recognize a positional bind as an OUT bind rather than an IN value;
+            // a bare `null` would be sent as an IN bind of unknown type.
+            const outBind = () => ({
+                type: oracledb_1.default.STRING,
+                dir: oracledb_1.default.BIND_OUT,
+                maxSize: 4000,
+            });
+            if (options.returning === true) {
+                sql += ` RETURNING ROWID INTO :${nextBindIndex}`;
+                bindValues.push(outBind());
+            }
+            else {
+                const returningFields = options.returning.map((f) => this.quoteIdentifier(f)).join(', ');
+                const intoBinds = options.returning.map(() => `:${nextBindIndex++}`).join(', ');
+                sql += ` RETURNING ${returningFields} INTO ${intoBinds}`;
+                for (let i = 0; i < options.returning.length; i++) {
+                    bindValues.push(outBind());
+                }
+            }
+        }
+        return { sql, values: bindValues };
+    }
+    /**
+     * Build UPDATE query
+     */
+    buildUpdateQuery(tableName, values, where, options) {
+        const setClauses = Object.keys(values).map((key, i) => `${this.quoteIdentifier(key)} = :${i + 1}`);
+        const setSql = setClauses.join(', ');
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setSql}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options?.limit) {
+            // Oracle requires subquery for UPDATE with LIMIT
+            sql = `UPDATE (${sql} WHERE ROWNUM <= ${options.limit}) SET ${setSql}`;
+        }
+        const bindValues = [...Object.values(values), ...whereClause.values];
+        return { sql, values: bindValues };
+    }
+    /**
+     * Build DELETE query
+     */
+    buildDeleteQuery(tableName, where, options) {
+        let sql = `DELETE FROM ${this.quoteTable(tableName)}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options?.limit) {
+            // Oracle requires subquery for DELETE with LIMIT
+            sql = `DELETE FROM (${sql} WHERE ROWNUM <= ${options.limit})`;
+        }
+        return { sql, values: whereClause.values };
+    }
+    /**
+     * Build SELECT query
+     */
+    buildSelectQuery(options) {
+        const values = [];
+        // SELECT clause
+        let sql = 'SELECT ';
+        if (options.distinct) {
+            sql += 'DISTINCT ';
+        }
+        if (options.attributes) {
+            if (Array.isArray(options.attributes)) {
+                sql += options.attributes.map((a) => this.quoteIdentifier(a)).join(', ');
+            }
+            else {
+                const include = options.attributes.include
+                    ?.map((a) => this.quoteIdentifier(a))
+                    .join(', ');
+                const exclude = options.attributes.exclude
+                    ?.map((a) => this.quoteIdentifier(a))
+                    .join(', ');
+                if (include)
+                    sql += include;
+                else
+                    sql += '*';
+                if (exclude)
+                    sql = sql.replace('*', `* EXCEPT (${exclude})`);
+            }
+        }
+        else {
+            sql += '*';
+        }
+        // FROM clause
+        sql += ` FROM ${this.quoteTable(options.tableName, options.schema)}`;
+        // JOIN clause (if any)
+        if (options.include) {
+            for (const include of options.include) {
+                const joinType = include.join || 'JOIN';
+                // Use the model name or tableName from the include options
+                const tableName = include.table ||
+                    (typeof include.model === 'object' && 'tableName' in include.model
+                        ? include.model.tableName
+                        : String(include.model));
+                const schema = include.schema;
+                const as = include.as;
+                sql += ` ${joinType} ${this.quoteTable(tableName, schema)}`;
+                if (include.on) {
+                    const onConditions = Object.entries(include.on).map(([key, value]) => `${this.quoteIdentifier(key)} = ${this.quoteIdentifier(value)}`);
+                    sql += ` ON (${onConditions.join(' AND ')})`;
+                }
+                if (as) {
+                    sql += ` ${this.quoteIdentifier(as)}`;
+                }
+            }
+        }
+        // WHERE clause
+        if (options.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        // GROUP BY clause
+        if (options.group) {
+            const groupBy = Array.isArray(options.group)
+                ? options.group.map((g) => this.quoteIdentifier(g)).join(', ')
+                : this.quoteIdentifier(options.group);
+            sql += ` GROUP BY ${groupBy}`;
+        }
+        // HAVING clause
+        if (options.having) {
+            const havingClause = this.buildWhereClause(options.having);
+            if (havingClause.sql) {
+                sql += ` HAVING ${havingClause.sql}`;
+                values.push(...havingClause.values);
+            }
+        }
+        // ORDER BY clause
+        if (options.order) {
+            sql += ` ${this.buildOrderClause(options.order)}`;
+        }
+        // LIMIT/OFFSET using ROWNUM (Oracle specific)
+        if (options.limit !== undefined || options.offset !== undefined) {
+            const limit = options.limit ? parseInt(options.limit, 10) : 0;
+            const offset = options.offset ? parseInt(options.offset, 10) : 0;
+            // Wrap the query in a subquery to apply ROWNUM
+            sql = `SELECT * FROM (${sql}) WHERE ROWNUM > ${offset}`;
+            if (limit > 0) {
+                sql += ` AND ROWNUM <= ${limit + offset}`;
+            }
+        }
+        // FOR UPDATE (locking)
+        if (options.lock) {
+            sql += ' FOR UPDATE';
+            if (options.lock === 'SHARE') {
+                sql += ' NOWAIT';
+            }
+        }
+        return { sql, values };
+    }
+    /**
+     * Build a general-purpose Oracle `MERGE INTO ... USING ... ON (...)` statement.
+     * Supports composite (multi-column) match keys, conditional
+     * `WHEN [NOT] MATCHED` predicates, and `WHEN MATCHED ... THEN DELETE`.
+     */
+    buildMergeQuery(options) {
+        const target = options.targetAlias
+            ? `${this.quoteTable(options.targetTable, options.targetSchema)} ${this.quoteIdentifier(options.targetAlias)}`
+            : this.quoteTable(options.targetTable, options.targetSchema);
+        const targetRef = options.targetAlias
+            ? this.quoteIdentifier(options.targetAlias)
+            : this.quoteTable(options.targetTable, options.targetSchema);
+        const usingClause = options.usingAlias
+            ? `${options.using} ${this.quoteIdentifier(options.usingAlias)}`
+            : options.using;
+        const usingRef = options.usingAlias ? this.quoteIdentifier(options.usingAlias) : options.using;
+        // ANDing every match column together (rather than only the first one) is
+        // what correctly supports composite conflict/join keys.
+        const onCondition = options.onCondition ||
+            options.on
+                .map((col) => `${targetRef}.${this.quoteIdentifier(col)} = ${usingRef}.${this.quoteIdentifier(col)}`)
+                .join(' AND ');
+        let sql = `MERGE INTO ${target} USING ${usingClause} ON (${onCondition})`;
+        if (options.whenMatchedUpdate && options.whenMatchedUpdate.length > 0) {
+            const setClause = options.whenMatchedUpdate
+                .map((col) => `${targetRef}.${this.quoteIdentifier(col)} = ${usingRef}.${this.quoteIdentifier(col)}`)
+                .join(', ');
+            sql += ` WHEN MATCHED THEN UPDATE SET ${setClause}`;
+            if (options.whenMatchedCondition) {
+                sql += ` WHERE ${options.whenMatchedCondition}`;
+            }
+            if (options.whenMatchedDelete) {
+                sql +=
+                    typeof options.whenMatchedDelete === 'string'
+                        ? ` DELETE WHERE ${options.whenMatchedDelete}`
+                        : ' DELETE';
+            }
+        }
+        if (options.whenNotMatchedInsert && options.whenNotMatchedInsert.length > 0) {
+            const insertCols = options.whenNotMatchedInsert
+                .map((c) => this.quoteIdentifier(c))
+                .join(', ');
+            const insertVals = options.whenNotMatchedInsert
+                .map((c) => `${usingRef}.${this.quoteIdentifier(c)}`)
+                .join(', ');
+            sql += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals})`;
+            if (options.whenNotMatchedCondition) {
+                sql += ` WHERE ${options.whenNotMatchedCondition}`;
+            }
+        }
+        return { sql, values: options.values || [] };
+    }
+    /**
+     * Build UPSERT query (MERGE for Oracle)
+     */
+    buildUpsertQuery(tableName, values, options) {
+        const fields = Object.keys(values);
+        const bindValues = Object.values(values);
+        // Every conflict field participates in the ON clause (ANDed together),
+        // correctly supporting composite conflict keys instead of only honoring
+        // conflictFields[0].
+        const conflictFields = options?.conflictFields && options.conflictFields.length > 0
+            ? options.conflictFields
+            : [fields[0]];
+        const updateFields = fields.filter((f) => !conflictFields.includes(f));
+        const selectList = fields.map((f, i) => `:${i + 1} AS ${this.quoteIdentifier(f)}`).join(', ');
+        const using = `(SELECT ${selectList} FROM DUAL)`;
+        const merged = this.buildMergeQuery({
+            targetTable: tableName,
+            using,
+            usingAlias: 'src',
+            on: conflictFields,
+            whenMatchedUpdate: updateFields.length > 0 ? updateFields : undefined,
+            whenNotMatchedInsert: fields,
+        });
+        return { sql: merged.sql, values: bindValues };
+    }
+    /**
+     * Build increment query
+     */
+    buildIncrementQuery(tableName, fields, where, options) {
+        const increment = options?.by || 1;
+        let fieldsToIncrement;
+        let incrementValues;
+        if (typeof fields === 'string') {
+            fieldsToIncrement = [fields];
+            incrementValues = { [fields]: increment };
+        }
+        else if (Array.isArray(fields)) {
+            fieldsToIncrement = fields;
+            incrementValues = fields.reduce((acc, f) => ({ ...acc, [f]: increment }), {});
+        }
+        else {
+            fieldsToIncrement = Object.keys(fields);
+            incrementValues = fields;
+        }
+        const setClauses = fieldsToIncrement.map((f) => `${this.quoteIdentifier(f)} = ${this.quoteIdentifier(f)} + ${incrementValues[f]}`);
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClauses.join(', ')}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        return { sql, values: whereClause.values };
+    }
+    /**
+     * Replace placeholders in SQL
+     */
+    replaceReplacements(sql, replacements) {
+        if (!replacements) {
+            return sql;
+        }
+        if (Array.isArray(replacements)) {
+            let result = sql;
+            for (const value of replacements) {
+                result = result.replace('?', this.escape(value));
+            }
+            return result;
+        }
+        let result = sql;
+        for (const [key, value] of Object.entries(replacements)) {
+            result = result.replace(new RegExp(`:${key}`, 'g'), this.escape(value));
+        }
+        return result;
+    }
+    // ==================== Extensions (Not Supported) ====================
+    async createExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by Oracle. This is a PostgreSQL-specific feature.');
+    }
+    async dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by Oracle. This is a PostgreSQL-specific feature.');
+    }
+    async getExtensions() {
+        throw new Error('Extensions are not supported by Oracle. This is a PostgreSQL-specific feature.');
+    }
+    async hasExtension(_extensionName) {
+        throw new Error('Extensions are not supported by Oracle. This is a PostgreSQL-specific feature.');
+    }
+    // ==================== Foreign Data Wrappers (Not Supported) ====================
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by Oracle. This is a PostgreSQL-specific feature. Consider using Oracle Database Links (CREATE DATABASE LINK) instead.');
+    }
+    // ==================== User Management ====================
+    /**
+     * Build a CREATE USER statement for Oracle.
+     *
+     * Oracle syntax: CREATE USER username IDENTIFIED BY password
+     */
+    buildCreateUserQuery(username, options = {}) {
+        let sql = 'CREATE USER';
+        sql += ` "${this.escapeStringValue(username)}"`;
+        if (options.password) {
+            sql += ` IDENTIFIED BY "${this.escapeStringValue(options.password)}"`;
+        }
+        // Oracle uses PROFILE for resource limits
+        if (options.maxConnections !== undefined) {
+            sql += ` LIMIT SESSIONS_PER_USER ${Number(options.maxConnections)}`;
+        }
+        if (options.maxQueriesPerHour !== undefined || options.maxUpdatesPerHour !== undefined) {
+            // Oracle uses PROFILE for these limits - simplified handling
+            sql += ' /* Resource limits require PROFILE configuration */';
+        }
+        // Account lock status
+        if (options.accountLocked === true) {
+            sql += ' ACCOUNT LOCK';
+        }
+        else if (options.accountLocked === false) {
+            sql += ' ACCOUNT UNLOCK';
+        }
+        // `CREATE USER IF NOT EXISTS` is 23c-only syntax (ORA-00922 on 19c/21c).
+        // Use a portable existence check instead: run the plain DDL wrapped in a
+        // PL/SQL block that silently ignores the "already exists" ORA codes.
+        if (options.ifNotExists) {
+            return this.wrapIgnoringOraErrors(sql, [
+                OracleDialect.ORA_NAME_ALREADY_USED,
+                OracleDialect.ORA_USER_ALREADY_EXISTS,
+            ]);
+        }
+        return sql;
+    }
+    /**
+     * Build an ALTER USER statement for Oracle.
+     *
+     * Oracle syntax: ALTER USER username IDENTIFIED BY password
+     */
+    buildAlterUserQuery(username, options) {
+        let sql = `ALTER USER "${this.escapeStringValue(username)}"`;
+        if (options.password) {
+            sql += ` IDENTIFIED BY "${this.escapeStringValue(options.password)}"`;
+        }
+        // Account lock/unlock
+        if (options.unlockAccount) {
+            sql += ' ACCOUNT UNLOCK';
+        }
+        else if (options.accountLocked === true) {
+            sql += ' ACCOUNT LOCK';
+        }
+        else if (options.accountLocked === false) {
+            sql += ' ACCOUNT UNLOCK';
+        }
+        // Password expiry (Oracle uses PASSWORD EXPIRE)
+        if (options.passwordExpirePolicy === 'DEFAULT') {
+            sql += ' PASSWORD EXPIRE DEFAULT';
+        }
+        else if (options.passwordExpirePolicy === 'NEVER') {
+            sql += ' PASSWORD EXPIRE NEVER';
+        }
+        else if (options.passwordExpirePolicy === 'INTERVAL') {
+            sql += ' PASSWORD EXPIRE INTERVAL';
+        }
+        else if (typeof options.passwordExpirePolicy === 'number') {
+            sql += ` PASSWORD EXPIRE INTERVAL ${options.passwordExpirePolicy} DAY`;
+        }
+        else if (options.resetExpiredPassword) {
+            sql += ' PASSWORD EXPIRE';
+        }
+        // Resource limits would require PROFILE changes
+        if (options.maxConnections !== undefined) {
+            sql += ` /* SESSIONS_PER_USER limit requires PROFILE configuration */`;
+        }
+        return sql;
+    }
+    /**
+     * Build a DROP USER statement for Oracle.
+     */
+    buildDropUserQuery(username, options = {}) {
+        let sql = 'DROP USER';
+        sql += ` "${this.escapeStringValue(username)}"`;
+        if (options.cascade) {
+            sql += ' CASCADE';
+        }
+        // `DROP USER IF EXISTS` is 23c-only syntax (ORA-00922 on 19c/21c). Use a
+        // portable existence check instead: run the plain DDL wrapped in a
+        // PL/SQL block that silently ignores ORA-01918 ("user does not exist").
+        if (options.ifExists) {
+            return this.wrapIgnoringOraErrors(sql, [OracleDialect.ORA_USER_DOES_NOT_EXIST]);
+        }
+        return sql;
+    }
+    /**
+     * Return a query that lists all Oracle users.
+     */
+    getUsersQuery() {
+        return `SELECT username AS "user",
+                   account_status AS "status",
+                   created AS "createTime",
+                   lock_date AS "lockDate"
+            FROM dba_users
+            ORDER BY username`;
+    }
+    /**
+     * Build a GRANT statement for Oracle.
+     *
+     * Oracle syntax: GRANT privilege ON object TO user
+     */
+    buildGrantQuery(options) {
+        const { scopeSql, columnList } = this.buildPrivilegeScope(options.on);
+        const privList = options.privileges.join(', ');
+        // For column-level grants, format as: SELECT (col1, col2) ON table TO user
+        let grantPriv;
+        if (columnList) {
+            grantPriv = `${privList} (${columnList})`;
+        }
+        else {
+            grantPriv = privList;
+        }
+        const recipients = (Array.isArray(options.to) ? options.to : [options.to])
+            .map((r) => `"${this.escapeStringValue(r)}"`)
+            .join(', ');
+        let sql = `GRANT ${grantPriv} ON ${scopeSql} TO ${recipients}`;
+        if (options.withGrantOption) {
+            sql += ' WITH GRANT OPTION';
+        }
+        return sql;
+    }
+    /**
+     * Build a REVOKE statement for Oracle.
+     *
+     * Oracle syntax: REVOKE privilege ON object FROM user
+     */
+    buildRevokeQuery(options) {
+        const { scopeSql, columnList } = this.buildPrivilegeScope(options.on);
+        const privList = options.privileges.join(', ');
+        let revokePriv;
+        if (columnList) {
+            revokePriv = `${privList} (${columnList})`;
+        }
+        else {
+            revokePriv = privList;
+        }
+        const targets = (Array.isArray(options.from) ? options.from : [options.from])
+            .map((r) => `"${this.escapeStringValue(r)}"`)
+            .join(', ');
+        let sql;
+        if (options.grantOptionFor) {
+            sql = `REVOKE GRANT OPTION FOR ${revokePriv} ON ${scopeSql} FROM ${targets}`;
+        }
+        else {
+            sql = `REVOKE ${revokePriv} ON ${scopeSql} FROM ${targets}`;
+        }
+        if (options.cascade) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+    /**
+     * Build a SHOW GRANTS query for Oracle.
+     * Queries USER_TAB_PRIVS for object grants.
+     */
+    buildShowGrantsQuery(username, _host) {
+        const escaped = this.escapeStringValue(username);
+        return [
+            `SELECT grantee, privilege, table_name, table_schema, grantable`,
+            `FROM user_tab_privs`,
+            `WHERE grantee = UPPER('${escaped}')`,
+            `UNION ALL`,
+            `SELECT grantee, privilege, column_name, table_name, grantable`,
+            `FROM user_col_privs`,
+            `WHERE grantee = UPPER('${escaped}')`,
+            `ORDER BY table_name, privilege;`,
+        ].join('\n');
+    }
+    /**
+     * Oracle does not require FLUSH PRIVILEGES - return a no-op.
+     */
+    buildFlushPrivilegesQuery() {
+        return '-- Oracle applies privileges automatically; FLUSH PRIVILEGES is not required\nSELECT 1 FROM DUAL';
+    }
+    /**
+     * Build a CREATE ROLE statement for Oracle.
+     */
+    buildCreateRoleQuery(roleName, options = {}) {
+        let sql = 'CREATE ROLE';
+        sql += ` "${this.escapeStringValue(roleName)}"`;
+        if (options.password) {
+            sql += ` NOT IDENTIFIED`;
+            // Oracle roles can be IDENTIFIED BY password or NOT IDENTIFIED
+            // For roles, typically NOT IDENTIFIED (managed at schema level)
+        }
+        // `CREATE ROLE IF NOT EXISTS` is 23c-only syntax (ORA-00922 on 19c/21c).
+        // Use a portable existence check instead: run the plain DDL wrapped in a
+        // PL/SQL block that silently ignores the "already exists" ORA codes.
+        if (options.ifNotExists) {
+            return this.wrapIgnoringOraErrors(sql, [
+                OracleDialect.ORA_NAME_ALREADY_USED,
+                OracleDialect.ORA_ROLE_ALREADY_EXISTS,
+            ]);
+        }
+        return sql;
+    }
+    /**
+     * Build a DROP ROLE statement for Oracle.
+     */
+    buildDropRoleQuery(roleName, options = {}) {
+        let sql = 'DROP ROLE';
+        sql += ` "${this.escapeStringValue(roleName)}"`;
+        // `DROP ROLE IF EXISTS` is 23c-only syntax (ORA-00922 on 19c/21c). Use a
+        // portable existence check instead: run the plain DDL wrapped in a
+        // PL/SQL block that silently ignores ORA-01919 ("role does not exist").
+        if (options.ifExists) {
+            return this.wrapIgnoringOraErrors(sql, [OracleDialect.ORA_ROLE_DOES_NOT_EXIST]);
+        }
+        return sql;
+    }
+    /**
+     * Build a GRANT ROLE statement for Oracle.
+     */
+    buildGrantRoleQuery(role, to, options = {}) {
+        const recipients = (Array.isArray(to) ? to : [to])
+            .map((r) => `"${this.escapeStringValue(r)}"`)
+            .join(', ');
+        let sql = `GRANT "${this.escapeStringValue(role)}" TO ${recipients}`;
+        if (options.withAdminOption) {
+            sql += ' WITH ADMIN OPTION';
+        }
+        return sql;
+    }
+    /**
+     * Build a REVOKE ROLE statement for Oracle.
+     */
+    buildRevokeRoleQuery(role, from, _options = {}) {
+        const targets = (Array.isArray(from) ? from : [from])
+            .map((r) => `"${this.escapeStringValue(r)}"`)
+            .join(', ');
+        return `REVOKE "${this.escapeStringValue(role)}" FROM ${targets}`;
+    }
+    /**
+     * Return a query that lists all Oracle roles.
+     */
+    getRolesQuery() {
+        return `SELECT role AS "role" FROM dba_roles ORDER BY role`;
+    }
+    /**
+     * Build Oracle privilege scope for GRANT/REVOKE.
+     */
+    buildPrivilegeScope(scope) {
+        switch (scope.level) {
+            case 'global':
+                return { scopeSql: 'DATABASE', columnList: null };
+            case 'database':
+                return { scopeSql: `"${this.escapeStringValue(scope.database)}".*`, columnList: null };
+            case 'table': {
+                const db = scope.database ? `"${this.escapeStringValue(scope.database)}".` : '';
+                return { scopeSql: `${db}"${this.escapeStringValue(scope.table)}"`, columnList: null };
+            }
+            case 'column': {
+                const db = scope.database ? `"${this.escapeStringValue(scope.database)}".` : '';
+                const cols = scope.columns.map((c) => `"${this.escapeStringValue(c)}"`).join(', ');
+                return {
+                    scopeSql: `${db}"${this.escapeStringValue(scope.table)}"`,
+                    columnList: cols,
+                };
+            }
+            case 'routine': {
+                const db = scope.database ? `"${this.escapeStringValue(scope.database)}".` : '';
+                const type = scope.routineType || 'PROCEDURE';
+                return {
+                    scopeSql: `${type} ${db}"${this.escapeStringValue(scope.routine)}"`,
+                    columnList: null,
+                };
+            }
+            default:
+                return { scopeSql: 'DATABASE', columnList: null };
+        }
+    }
+    /**
+     * Escape a string value for Oracle (quote with double quotes).
+     */
+    escapeStringValue(value) {
+        return value.replace(/"/g, '""');
+    }
+    // ==================== Sequences ====================
+    async createSequence(options) {
+        const schema = options.schema || this.config?.schema || 'SYSTEM';
+        const seqName = `${schema}.${this.escapeId(options.name)}`;
+        let sql = 'CREATE SEQUENCE';
+        if (options.replace) {
+            sql = 'CREATE OR REPLACE SEQUENCE';
+        }
+        else if (options.ifNotExists) {
+            // Check if exists first
+            const exists = await this.hasSequence(options.name, schema);
+            if (exists) {
+                return;
+            }
+        }
+        if (options.temporary) {
+            sql += ' TEMPORARY SEQUENCE';
+        }
+        sql += ` ${seqName}`;
+        if (options.startWith !== undefined)
+            sql += ` START WITH ${options.startWith}`;
+        if (options.incrementBy !== undefined)
+            sql += ` INCREMENT BY ${options.incrementBy}`;
+        if (options.minvalue !== undefined)
+            sql += ` MINVALUE ${options.minvalue}`;
+        if (options.maxvalue !== undefined)
+            sql += ` MAXVALUE ${options.maxvalue}`;
+        if (options.cycle)
+            sql += ' CYCLE';
+        if (options.cache !== undefined)
+            sql += ` CACHE ${options.cache}`;
+        if (options.order)
+            sql += ' ORDER';
+        if (options.nocache)
+            sql += ' NOCACHE';
+        await this.query(sql);
+    }
+    /**
+     * Drop a sequence.
+     *
+     * Like the other DDL paths in this dialect (tables, users, roles), Oracle's
+     * `DROP SEQUENCE ... IF EXISTS` syntax is 23c-only and raises ORA-00922
+     * against the 19c/21c versions this dialect targets. When `ifExists` is
+     * requested, wrap the plain DDL so that ORA-02289 ("sequence does not
+     * exist") is silently ignored instead (see {@link wrapIgnoringOraErrors}).
+     */
+    async dropSequence(sequenceName, options) {
+        const schema = options?.schema || this.config?.schema || 'SYSTEM';
+        const seqName = `${schema}.${this.escapeId(sequenceName)}`;
+        const plainSql = `DROP SEQUENCE ${seqName}`;
+        const sql = options?.ifExists
+            ? this.wrapIgnoringOraErrors(plainSql, [OracleDialect.ORA_SEQUENCE_DOES_NOT_EXIST])
+            : plainSql;
+        await this.query(sql);
+    }
+    async nextSequenceValue(sequenceName) {
+        const result = await this.query(`SELECT ${this.escapeId(sequenceName)}.NEXTVAL as value FROM DUAL`);
+        return result.rows[0]?.value;
+    }
+    async hasSequence(sequenceName, schema) {
+        const schemaName = schema || this.config?.schema || 'SYSTEM';
+        const result = await this.query(`SELECT SEQUENCE_NAME FROM ALL_SEQUENCES WHERE SEQUENCE_NAME = UPPER('${sequenceName}') AND SEQUENCE_OWNER = UPPER('${schemaName}')`);
+        return result.rows.length > 0;
+    }
+    /**
+     * List all sequences in the database (Oracle)
+     * @returns Array of sequence names
+     */
+    async listSequences() {
+        const schemaName = this.config?.schema || 'SYSTEM';
+        const sql = `SELECT SEQUENCE_NAME, SEQUENCE_OWNER FROM ALL_SEQUENCES WHERE SEQUENCE_OWNER = UPPER('${schemaName}') ORDER BY SEQUENCE_OWNER, SEQUENCE_NAME`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => `${row.SEQUENCE_OWNER}.${row.SEQUENCE_NAME}`);
+    }
+    // ==================== Stored Procedures ====================
+    async createStoredProcedure(options) {
+        const schema = options.schema || this.config?.schema || 'SYSTEM';
+        const procName = `${schema}.${this.escapeId(options.name)}`;
+        // Build parameter list
+        let paramList = '';
+        if (options.params && options.params.length > 0) {
+            paramList = options.params
+                .map((param) => {
+                const dir = param.mode === 'OUT' ? 'OUT' : param.mode === 'INOUT' ? 'IN OUT' : 'IN';
+                return `${this.escapeId(param.name)} ${dir} ${param.type}`;
+            })
+                .join(', ');
+        }
+        let sql;
+        if (options.returnType) {
+            // It's a function
+            sql = 'CREATE OR REPLACE FUNCTION';
+            if (options.replace) {
+                sql = 'CREATE OR REPLACE FUNCTION';
+            }
+            else if (options.ifNotExists) {
+                const exists = await this.hasStoredProcedure(options.name, schema);
+                if (exists) {
+                    return;
+                }
+            }
+            sql += ` ${procName}(${paramList}) RETURN ${options.returnType}`;
+        }
+        else {
+            // It's a procedure
+            sql = 'CREATE OR REPLACE PROCEDURE';
+            if (options.replace) {
+                sql = 'CREATE OR REPLACE PROCEDURE';
+            }
+            else if (options.ifNotExists) {
+                const exists = await this.hasStoredProcedure(options.name, schema);
+                if (exists) {
+                    return;
+                }
+            }
+            sql += ` ${procName}(${paramList})`;
+        }
+        // Add AS clause with body
+        sql += ` AS\n${options.body}`;
+        // Add comment if provided
+        if (options.comment) {
+            await this.commentProcedure(options.name, options.comment, schema);
+        }
+        await this.query(sql);
+    }
+    async dropStoredProcedure(procedureName, options) {
+        const schema = options?.schema || this.config?.schema || 'SYSTEM';
+        const procName = `${schema}.${this.escapeId(procedureName)}`;
+        let sql = 'DROP PROCEDURE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${procName}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     */
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    async executeStoredProcedure(options) {
+        const schema = options.schema || this.config?.schema || 'SYSTEM';
+        const procName = schema === 'SYSTEM'
+            ? this.escapeId(options.procedureName)
+            : `${schema}.${this.escapeId(options.procedureName)}`;
+        // Build parameter list
+        let paramList = '';
+        if (options.params) {
+            paramList = Object.entries(options.params)
+                .map(([key, value]) => {
+                if (typeof value === 'string') {
+                    return `'${value}'`;
+                }
+                return value;
+            })
+                .join(', ');
+        }
+        const sql = `BEGIN ${procName}(${paramList}); END;`;
+        return await this.query(sql, { raw: true });
+    }
+    async hasStoredProcedure(procedureName, schema) {
+        const schemaName = schema || this.config?.schema || 'SYSTEM';
+        const result = await this.query(`SELECT OBJECT_NAME FROM ALL_PROCEDURES WHERE OBJECT_NAME = UPPER('${procedureName}') AND OWNER = UPPER('${schemaName}')`);
+        return result.rows.length > 0;
+    }
+    async commentProcedure(procedureName, comment, schema) {
+        await this.query(`COMMENT ON PROCEDURE ${schema}.${this.escapeId(procedureName)} IS '${this.escape(comment)}'`);
+    }
+    // ==================== Triggers ====================
+    async createTrigger(options) {
+        const schema = options.schema || this.config?.schema || 'SYSTEM';
+        const triggerName = `${schema}.${this.escapeId(options.name)}`;
+        const tableName = `${schema}.${this.escapeId(options.tableName)}`;
+        // Build timing and events
+        const timing = options.timing === 'INSTEAD OF' ? 'INSTEAD OF' : options.timing;
+        const events = (options.events || []).join(' OR ');
+        let sql = 'CREATE TRIGGER';
+        if (options.replace) {
+            sql = 'CREATE OR REPLACE TRIGGER';
+        }
+        sql += ` ${triggerName} ${timing} ${events} ON ${tableName}`;
+        // Add FOR EACH ROW if specified
+        if (options.level === 'ROW') {
+            sql += ' FOR EACH ROW';
+        }
+        // Add WHEN clause if provided
+        if (options.when) {
+            sql += ` WHEN (${options.when})`;
+        }
+        // Add trigger body
+        sql += `\nBEGIN\n${options.body}\nEND;`;
+        await this.query(sql);
+    }
+    async dropTrigger(triggerName, tableName, options) {
+        const schema = options?.schema || this.config?.schema || 'SYSTEM';
+        const triggerFullName = `${schema}.${this.escapeId(triggerName)}`;
+        let sql = 'DROP TRIGGER';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${triggerFullName}`;
+        await this.query(sql);
+    }
+    async hasTrigger(triggerName, tableName, schema) {
+        const schemaName = schema || this.config?.schema || 'SYSTEM';
+        const result = await this.query(`SELECT TRIGGER_NAME FROM USER_TRIGGERS
+       WHERE TRIGGER_NAME = UPPER('${triggerName}')
+       AND TABLE_NAME = UPPER('${tableName}')`);
+        return result.rows.length > 0;
+    }
+    // ==================== RLS (Row-Level Security) ====================
+    /**
+     * Create a security policy (RLS)
+     */
+    async createPolicy(options) {
+        const tableName = options.schema
+            ? `${this.quoteIdentifier(options.schema)}.${this.quoteIdentifier(options.tableName)}`
+            : this.quoteTable(options.tableName);
+        let sql = `BEGIN
+  SYS.DBMS_RLS.ADD_POLICY(
+    object_schema => ${options.schema ? `'${options.schema}'` : 'USER'},
+    object_name => '${options.tableName}',
+    policy_name => '${options.name}',
+    function_schema => USER,
+    policy_function => '${options.name}_func',
+`;
+        if (options.roles && options.roles.length > 0) {
+            sql += `    sec_relevant_cols => '${options.roles.join(',')}',
+`;
+        }
+        if (options.withCheck) {
+            sql += `    update_check => TRUE,
+`;
+        }
+        sql += `  );
+END;`;
+        // First create the policy function
+        const funcName = `${options.name}_func`;
+        let funcSql = `
+CREATE OR REPLACE FUNCTION ${funcName}(schema_var VARCHAR2, table_var VARCHAR2)
+RETURN VARCHAR2
+AS
+  return_clause VARCHAR2(4000);
+BEGIN
+`;
+        if (options.using) {
+            funcSql += `  return_clause := '${options.using}';
+`;
+        }
+        else {
+            funcSql += `  return_clause := '1=1';
+`;
+        }
+        funcSql += `
+  RETURN return_clause;
+END;
+`;
+        await this.query(funcSql);
+        // Then add the policy using DBMS_RLS
+        const policySql = `
+BEGIN
+  SYS.DBMS_RLS.ADD_POLICY(
+    object_schema => ${options.schema ? `'${options.schema}'` : 'NULL'},
+    object_name => '${options.tableName}',
+    policy_name => '${options.name}',
+    policy_function => '${funcName}'
+  );
+END;
+`;
+        await this.query(policySql);
+    }
+    /**
+     * Drop a security policy
+     */
+    async dropPolicy(policyName, tableName, options) {
+        const schema = options?.schema || null;
+        const sql = `
+BEGIN
+  SYS.DBMS_RLS.DROP_POLICY(
+    object_schema => ${schema ? `'${schema}'` : 'NULL'},
+    object_name => '${tableName}',
+    policy_name => '${policyName}'
+  );
+END;
+`;
+        await this.query(sql);
+    }
+    /**
+     * Enable Row-Level Security on a table
+     */
+    async enableRLS(tableName, schema) {
+        const tableNameWithSchema = schema
+            ? `${this.quoteIdentifier(schema)}.${this.quoteIdentifier(tableName)}`
+            : this.quoteTable(tableName);
+        const sql = `ALTER TABLE ${tableNameWithSchema} ENABLE ROW LEVEL SECURITY`;
+        await this.query(sql);
+    }
+    /**
+     * Disable Row-Level Security on a table
+     */
+    async disableRLS(tableName, schema) {
+        const tableNameWithSchema = schema
+            ? `${this.quoteIdentifier(schema)}.${this.quoteIdentifier(tableName)}`
+            : this.quoteTable(tableName);
+        const sql = `ALTER TABLE ${tableNameWithSchema} DISABLE ROW LEVEL SECURITY`;
+        await this.query(sql);
+    }
+    /**
+     * Check if a policy exists
+     */
+    async hasPolicy(policyName, tableName) {
+        const result = await this.query(`SELECT POLICY_NAME FROM DBA_POLICIES
+       WHERE OBJECT_NAME = UPPER('${tableName}')
+       AND POLICY_NAME = UPPER('${policyName}')`);
+        return result.rows.length > 0;
+    }
+    // ==================== Comments (Not Fully Supported) ====================
+    /**
+     * Add comment to a table
+     */
+    async commentTable(tableName, comment) {
+        const sql = `COMMENT ON TABLE ${this.quoteTable(tableName)} IS ${this.escapeString(comment)}`;
+        await this.query(sql);
+    }
+    /**
+     * Add comment to a column
+     */
+    async commentColumn(tableName, columnName, comment) {
+        const sql = `COMMENT ON COLUMN ${this.quoteTable(tableName)}.${this.quoteIdentifier(columnName)} IS ${this.escapeString(comment)}`;
+        await this.query(sql);
+    }
+    // ==================== Advanced Indexes ====================
+    /**
+     * Create a partial index (index with WHERE clause)
+     */
+    async createPartialIndex(tableName, indexName, fields, where, options) {
+        const fieldsSql = fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        let sql = `CREATE`;
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        sql += ` INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql}) WHERE ${where}`;
+        if (options?.tablespace) {
+            sql += ` TABLESPACE ${options.tablespace}`;
+        }
+        if (options?.compress) {
+            sql += ` COMPRESS`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create an expression index (functional index)
+     */
+    async createExpressionIndex(tableName, indexName, expression, options) {
+        let sql = `CREATE`;
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        sql += ` INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTable(tableName)} (${expression})`;
+        if (options?.tablespace) {
+            sql += ` TABLESPACE ${options.tablespace}`;
+        }
+        if (options?.compress) {
+            sql += ` COMPRESS`;
+        }
+        await this.query(sql);
+    }
+    // ==================== Identity & Computed Columns ====================
+    /**
+     * Create an identity column (auto-increment)
+     */
+    async createIdentityColumn(tableName, columnName, options) {
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} MODIFY ${this.quoteIdentifier(columnName)} GENERATED ALWAYS AS IDENTITY`;
+        if (options) {
+            const optionsList = [];
+            if (options.startWith !== undefined) {
+                optionsList.push(`START WITH ${options.startWith}`);
+            }
+            if (options.incrementBy !== undefined) {
+                optionsList.push(`INCREMENT BY ${options.incrementBy}`);
+            }
+            if (options.minvalue !== undefined) {
+                optionsList.push(`MINVALUE ${options.minvalue}`);
+            }
+            if (options.maxvalue !== undefined) {
+                optionsList.push(`MAXVALUE ${options.maxvalue}`);
+            }
+            if (options.cycle) {
+                optionsList.push('CYCLE');
+            }
+            else {
+                optionsList.push('NO CYCLE');
+            }
+            if (optionsList.length > 0) {
+                sql += ` (${optionsList.join(', ')})`;
+            }
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create a computed (virtual) column
+     */
+    async createComputedColumn(tableName, columnName, expression, options) {
+        const persisted = options?.persisted === true ? 'STORED' : 'VIRTUAL';
+        const dataType = options?.type || 'VARCHAR2(4000)';
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD ${this.quoteIdentifier(columnName)} ${dataType} GENERATED ALWAYS AS (${expression}) ${persisted}`;
+        await this.query(sql);
+    }
+    /**
+     * Bulk insert records into a table
+     */
+    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 = [];
+            for (let i = 0; i < columns.length; i++) {
+                rowPlaceholders.push(`:${i + 1}`);
+                values.push(record[columns[i]]);
+            }
+            placeholders.push(`(${rowPlaceholders.join(', ')})`);
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES ${placeholders.join(', ')}`;
+        return this.query(sql, { replacements: values });
+    }
+    /**
+     * Add a foreign key to a table
+     */
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        const constraintName = options?.name || `${tableName}_${columnName}_fkey`;
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)}(${this.escapeId(referencedColumnName)})`;
+        const clauses = [];
+        if (options?.onDelete) {
+            clauses.push(`ON DELETE ${options.onDelete}`);
+        }
+        if (options?.onUpdate) {
+            clauses.push(`ON UPDATE ${options.onUpdate}`);
+        }
+        if (clauses.length > 0) {
+            sql += ' ' + clauses.join(' ');
+        }
+        await this.query(sql);
+    }
+    /**
+     * Rename a column
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} RENAME COLUMN ${this.escapeId(oldColumnName)} TO ${this.escapeId(newColumnName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a fulltext index (Oracle uses Oracle Text)
+     */
+    async createFulltextIndex(tableName, indexName, fields, options) {
+        // Unlike MySQL/Postgres/MSSQL FULLTEXT indexes, an Oracle Text
+        // `CTXSYS.CONTEXT` index is defined `ON table(single_column)` - it can
+        // only ever cover one column. There is no multi-column CONTEXT index
+        // syntax (a "column list" like a B-tree composite index does not exist
+        // for this INDEXTYPE); attempting to pass more than one column here
+        // would previously produce SQL that either errors at DDL time or (worse)
+        // silently indexes only the first field depending on driver behavior.
+        //
+        // We throw rather than silently fan out into N indexes under the same
+        // `indexName`, since the caller only supplied a single index name and
+        // Oracle index names must be unique - creating multiple indexes here
+        // would require inventing per-column suffixes the caller never asked
+        // for. Call this once per column instead, e.g.:
+        //   createFulltextIndex('articles', 'articles_title_ctx', ['title']);
+        //   createFulltextIndex('articles', 'articles_body_ctx', ['body']);
+        if (fields.length !== 1) {
+            throw new Error(`createFulltextIndex: Oracle Text (CTXSYS.CONTEXT) indexes are single-column only - ` +
+                `got ${fields.length} fields (${fields.join(', ')}). Call createFulltextIndex() once ` +
+                `per column with a distinct index name for each, e.g. ` +
+                `createFulltextIndex('${tableName}', '<index_name>', ['${fields[0] ?? 'column'}']).`);
+        }
+        const sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${this.escapeId(fields[0])}) INDEXTYPE IS CTXSYS.CONTEXT`;
+        await this.query(sql);
+    }
+    /**
+     * Create a spatial index (Oracle uses Spatial indexing)
+     */
+    async createSpatialIndex(tableName, indexName, fields, _options) {
+        const sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${fields.map((f) => this.escapeId(f)).join(', ')}) INDEXTYPE IS MDSYS.SPATIAL_INDEX`;
+        await this.query(sql);
+    }
+    // ==================== Spatial Functions ====================
+    /**
+     * ST_Distance - calculate distance between two geometries (Oracle)
+     */
+    stDistance(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `SDO_GEOM.SDO_DISTANCE(${geom1}, ${geom2}${sridStr})`;
+    }
+    /**
+     * ST_Within - check if geometry A is within geometry B (Oracle)
+     */
+    stWithin(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `SDO_GEOM.SDO_WITHIN_DISTANCE(${geom1}, ${geom2}, '${sridStr}') = 'TRUE'`;
+    }
+    /**
+     * ST_Contains - check if geometry A contains geometry B (Oracle)
+     */
+    stContains(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `SDO_GEOM.SDO_CONTAINS(${geom1}, ${geom2}${sridStr}) = 'TRUE'`;
+    }
+    /**
+     * ST_Intersects - check if geometries intersect (Oracle)
+     */
+    stIntersects(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `SDO_GEOM.SDO_INTERSECT(${geom1}, ${geom2}${sridStr}) = 'TRUE'`;
+    }
+    /**
+     * ST_DWithin - check if geometries are within a given distance (Oracle)
+     */
+    stDWithin(geom1, geom2, distance, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `SDO_GEOM.SDO_WITHIN_DISTANCE(${geom1}, ${geom2}, 'distance=${distance}${sridStr}') = 'TRUE'`;
+    }
+    /**
+     * ST_AsText - convert geometry to text representation (Oracle)
+     */
+    stAsText(geom) {
+        return `SDO_GEOM.SDO_GEOM_TOSQL(${geom})`;
+    }
+    /**
+     * ST_GeomFromText - create geometry from text (Oracle)
+     */
+    stGeomFromText(wkt, srid) {
+        return srid ? `SDO_GEOMETRY('${wkt}', ${srid})` : `SDO_GEOMETRY('${wkt}')`;
+    }
+    /**
+     * Build a JSON_TABLE expression to shred a JSON document/array into relational rows
+     * (Oracle 12c+). Useful to project a JSON array column into rows instead of a
+     * correlated subquery.
+     * Oracle: JSON_TABLE(expr, '$[*]' COLUMNS(name type PATH '$.path', ...)) alias
+     */
+    buildJsonTable(jsonExpression, rowPath, columns, alias) {
+        const columnDefs = columns
+            .map((col) => {
+            if (col.forOrdinality) {
+                return `${this.escapeId(col.name)} FOR ORDINALITY`;
+            }
+            return `${this.escapeId(col.name)} ${col.type} PATH '${col.path}'`;
+        })
+            .join(', ');
+        return `JSON_TABLE(${jsonExpression}, '${rowPath}' COLUMNS(${columnDefs})) ${this.escapeId(alias)}`;
+    }
+    // ==================== String Aggregation / Reporting ====================
+    /**
+     * Build a `LISTAGG(expr, delimiter) WITHIN GROUP (ORDER BY ...)` expression
+     * (Oracle 11gR2+), the standard idiom for collapsing grouped rows into a
+     * single delimited string.
+     */
+    listAgg(expr, delimiter = ',', orderBy, overflow) {
+        const orderByClause = orderBy ? this.buildOrderByItems(orderBy) : expr;
+        const escapedDelimiter = delimiter.replace(/'/g, "''");
+        const overflowClause = overflow ? ` ${overflow}` : '';
+        return `LISTAGG(${expr}, '${escapedDelimiter}'${overflowClause}) WITHIN GROUP (ORDER BY ${orderByClause})`;
+    }
+    /**
+     * Build an Oracle `PIVOT` query, rotating rows into columns (11g+).
+     */
+    buildPivotQuery(options) {
+        const aggregates = Array.isArray(options.aggregate) ? options.aggregate : [options.aggregate];
+        const aggregateSql = aggregates
+            .map((agg) => typeof agg === 'string'
+            ? agg
+            : `${agg.expr}${agg.as ? ` AS ${this.quoteIdentifier(agg.as)}` : ''}`)
+            .join(', ');
+        const pivotValues = options.pivotValues
+            .map((v) => {
+            if (typeof v === 'object') {
+                const literal = typeof v.value === 'number' ? v.value : `'${String(v.value).replace(/'/g, "''")}'`;
+                return v.as ? `${literal} AS ${this.quoteIdentifier(v.as)}` : `${literal}`;
+            }
+            const literal = typeof v === 'number' ? v : `'${String(v).replace(/'/g, "''")}'`;
+            return `${literal}`;
+        })
+            .join(', ');
+        const alias = options.alias ? ` ${this.quoteIdentifier(options.alias)}` : '';
+        return `${options.sourceQuery} PIVOT (${aggregateSql} FOR ${this.quoteIdentifier(options.pivotColumn)} IN (${pivotValues}))${alias}`;
+    }
+    /**
+     * Build an Oracle `UNPIVOT` query, rotating columns into rows (11g+).
+     */
+    buildUnpivotQuery(options) {
+        const inColumns = options.inColumns
+            .map((c) => typeof c === 'string'
+            ? this.quoteIdentifier(c)
+            : `${this.quoteIdentifier(c.column)}${c.as ? ` AS '${c.as.replace(/'/g, "''")}'` : ''}`)
+            .join(', ');
+        const includeNulls = options.includeNulls ? 'INCLUDE NULLS ' : '';
+        const alias = options.alias ? ` ${this.quoteIdentifier(options.alias)}` : '';
+        return `${options.sourceQuery} UNPIVOT ${includeNulls}(${this.quoteIdentifier(options.valueColumn)} FOR ${this.quoteIdentifier(options.forColumn)} IN (${inColumns}))${alias}`;
+    }
+}
+exports.OracleDialect = OracleDialect;
+/** ORA-00955: name is already used by an existing object. */
+OracleDialect.ORA_NAME_ALREADY_USED = 955;
+/** ORA-01920: user name conflicts with another user or role name. */
+OracleDialect.ORA_USER_ALREADY_EXISTS = 1920;
+/** ORA-01921: role name conflicts with another user or role name. */
+OracleDialect.ORA_ROLE_ALREADY_EXISTS = 1921;
+/** ORA-00942: table or view does not exist. */
+OracleDialect.ORA_TABLE_DOES_NOT_EXIST = 942;
+/** ORA-01918: user does not exist. */
+OracleDialect.ORA_USER_DOES_NOT_EXIST = 1918;
+/** ORA-01919: role does not exist. */
+OracleDialect.ORA_ROLE_DOES_NOT_EXIST = 1919;
+/** ORA-02289: sequence does not exist. */
+OracleDialect.ORA_SEQUENCE_DOES_NOT_EXIST = 2289;
+// ==================== Transaction Operations ====================
+/**
+ * Oracle only genuinely supports two isolation levels via
+ * `SET TRANSACTION ISOLATION LEVEL`: READ COMMITTED (the default) and
+ * SERIALIZABLE. It also supports `SET TRANSACTION READ ONLY`, which is not
+ * an isolation level but is sometimes requested through the same option.
+ * The ANSI four-level model (READ UNCOMMITTED, REPEATABLE READ) that other
+ * dialects in this codebase assume has no equivalent in Oracle's
+ * multiversion-concurrency-control engine, so rather than silently
+ * downgrading to a different (and misleadingly named) guarantee, we throw
+ * a clear error for anything Oracle can't actually provide.
+ */
+OracleDialect.SUPPORTED_ISOLATION_LEVELS = new Set(['READ COMMITTED', 'SERIALIZABLE']);
+/**
+ * Create Oracle dialect instance
+ */
+function createOracleDialect(options) {
+    return new OracleDialect(options || {});
+}
+exports.default = OracleDialect;