ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,1222 @@
+/**
+ * Oracle dialect implementation for the TypeScript ORM
+ * Uses the oracledb driver for database connectivity
+ */
+import type { Connection } from 'oracledb';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, IndexDefinition, InsertOptions, UpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, DropSchemaOptions, ViewOptions, DropViewOptions, ConstraintDefinition, DropConstraintOptions, BuildOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, RetryOptions, CreatePartitionOptions, PartitionBound, PartitionListBound, PartitionHashBound, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, MaterializedViewLogOptions, StreamOptions } from '../../types';
+import { Readable } from 'stream';
+/**
+ * Oracle dialect options
+ */
+export interface OracleDialectOptions extends DialectOptions {
+    /** Oracle connection pool options */
+    pool?: {
+        max?: number;
+        min?: number;
+        increment?: number;
+        timeout?: number;
+    };
+    /** Connection retry options */
+    retry?: RetryOptions;
+    /** Whether to use thin mode (no Instant Client needed) */
+    thinMode?: boolean;
+    /** Default schema for operations */
+    schema?: string;
+}
+/**
+ * Options describing an Oracle analytic (window) function invocation, e.g.
+ * `ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC)`.
+ */
+export interface OracleWindowFunctionOptions {
+    /** Analytic/aggregate function name, e.g. 'ROW_NUMBER', 'RANK', 'LAG' */
+    fn: string;
+    /** Arguments passed to the function, e.g. LAG(salary, 1, 0) -> [column, offset, default] */
+    args?: (string | number)[];
+    /** PARTITION BY column(s) */
+    partitionBy?: string | string[];
+    /** ORDER BY within the window */
+    orderBy?: Order;
+    /** Optional windowing (frame) clause */
+    frame?: {
+        type: 'ROWS' | 'RANGE';
+        /** e.g. 'UNBOUNDED PRECEDING', 'CURRENT ROW', '3 PRECEDING' */
+        start: string;
+        /** e.g. 'CURRENT ROW', '3 FOLLOWING', 'UNBOUNDED FOLLOWING' */
+        end?: string;
+    };
+    /** Alias for the resulting column (AS alias) */
+    as?: string;
+}
+/**
+ * A single Common Table Expression definition for `WITH ... AS (...)`.
+ * Oracle does not use the `RECURSIVE` keyword (unlike Postgres/MySQL) -
+ * a CTE is recursive simply by referencing itself in `unionQuery`.
+ */
+export interface OracleCTEOptions {
+    /** CTE name */
+    name: string;
+    /** Optional explicit column list: WITH cte(col1, col2) AS (...) */
+    columns?: string[];
+    /** Anchor member query (or the full query body for non-recursive CTEs) */
+    query: string;
+    /** Recursive member query, combined with `query` via UNION ALL */
+    unionQuery?: string;
+    /** Bind values used by `query`/`unionQuery`, in order */
+    values?: any[];
+}
+/** Options for Oracle's hierarchical `CONNECT BY PRIOR` query syntax */
+export interface OracleConnectByOptions {
+    tableName: string;
+    schema?: string;
+    /** Columns to select; defaults to '*' */
+    attributes?: string[];
+    /** Root-row predicate, e.g. "manager_id IS NULL" */
+    startWith?: string;
+    /** Parent/child relationship, e.g. "manager_id = PRIOR employee_id" */
+    connectByPrior: string;
+    /** Emit NOCYCLE to tolerate cyclic data without erroring */
+    nocycle?: boolean;
+    /** Extra WHERE predicate applied to the base rows */
+    where?: WhereOptions;
+    /** ORDER SIBLINGS BY clause (preserves hierarchy while sorting siblings) */
+    orderSiblingsBy?: Order;
+    /** Include the pseudo-columns LEVEL and CONNECT_BY_ISLEAF in the SELECT list */
+    includePseudoColumns?: boolean;
+}
+/** General-purpose Oracle `MERGE INTO ... USING ... ON (...)` builder options */
+export interface OracleMergeOptions {
+    /** Target table to merge into */
+    targetTable: string;
+    targetSchema?: string;
+    /** Alias for the target table (defaults to none) */
+    targetAlias?: string;
+    /**
+     * Source of the merge: a table name, `DUAL`, or a parenthesized subquery
+     * string, e.g. `(SELECT :1 AS id, :2 AS name FROM DUAL)`.
+     */
+    using: string;
+    usingAlias?: string;
+    /**
+     * Match key(s). All columns are ANDed together in the ON clause, correctly
+     * supporting composite keys, e.g. ['tenant_id', 'id'] ->
+     * `target."tenant_id" = source."tenant_id" AND target."id" = source."id"`.
+     */
+    on: string[];
+    /** Raw override for the entire ON condition (takes precedence over `on`) */
+    onCondition?: string;
+    /** Columns to set in WHEN MATCHED THEN UPDATE SET col = source.col */
+    whenMatchedUpdate?: string[];
+    /** Optional AND condition appended to WHEN MATCHED */
+    whenMatchedCondition?: string;
+    /** WHEN MATCHED ... THEN DELETE, optionally gated by a condition */
+    whenMatchedDelete?: boolean | string;
+    /** Columns to insert in WHEN NOT MATCHED THEN INSERT (cols) VALUES (source.cols) */
+    whenNotMatchedInsert?: string[];
+    /** Optional AND condition appended to WHEN NOT MATCHED */
+    whenNotMatchedCondition?: string;
+    /** Bind values referenced by the `using` subquery, in placeholder order */
+    values?: any[];
+}
+/** Options for Oracle's `PIVOT` clause */
+export interface OraclePivotOptions {
+    /** Source table name or a parenthesized subquery */
+    sourceQuery: string;
+    /** Aggregate expression(s) applied per pivoted value, e.g. 'SUM(sales)' or with alias */
+    aggregate: string | {
+        expr: string;
+        as?: string;
+    } | (string | {
+        expr: string;
+        as?: string;
+    })[];
+    /** Column being pivoted */
+    pivotColumn: string;
+    /** Values to pivot into columns, optionally aliased */
+    pivotValues: (string | number | {
+        value: string | number;
+        as?: string;
+    })[];
+    /** Alias for the pivoted result set */
+    alias?: string;
+}
+/** Options for Oracle's `UNPIVOT` clause */
+export interface OracleUnpivotOptions {
+    /** Source table name or a parenthesized subquery */
+    sourceQuery: string;
+    /** Name of the generated value column */
+    valueColumn: string;
+    /** Name of the generated "for" column identifying which source column a row came from */
+    forColumn: string;
+    /** Source columns to unpivot, optionally aliased to a display value */
+    inColumns: (string | {
+        column: string;
+        as?: string;
+    })[];
+    /** Include rows whose value would otherwise be NULL */
+    includeNulls?: boolean;
+    /** Alias for the unpivoted result set */
+    alias?: string;
+}
+/**
+ * Options for creating an Oracle PL/SQL package (`CREATE PACKAGE`) and/or its
+ * body (`CREATE PACKAGE BODY`). Packages are Oracle's primary code-organization
+ * idiom — a namespaced group of procedures, functions, types, and package-level
+ * state — none of which standalone `CREATE PROCEDURE` can express.
+ */
+export interface OraclePackageOptions {
+    /** Package name */
+    name: string;
+    /** Schema the package lives in (defaults to the dialect's configured schema) */
+    schema?: string;
+    /** Package specification body (the declarations between `IS`/`AS` and `END`) */
+    spec?: string;
+    /** Package implementation body (the declarations between `IS`/`AS` and `END`) */
+    body?: string;
+    /** Emit `CREATE OR REPLACE` (default true) */
+    replace?: boolean;
+}
+/** Options describing an Oracle flashback (`AS OF`) point-in-time read. */
+export interface OracleFlashbackOptions {
+    /** Read the table as of this wall-clock timestamp (`AS OF TIMESTAMP ...`). */
+    timestamp?: string | Date;
+    /** Read the table as of this System Change Number (`AS OF SCN ...`). */
+    scn?: number | string;
+}
+/**
+ * Options for creating an Oracle external table (`ORGANIZATION EXTERNAL`), the
+ * native Oracle replacement for PostgreSQL-style foreign tables / FDW.
+ */
+export interface OracleExternalTableOptions {
+    /** Column definitions: name -> Oracle column type SQL (e.g. `VARCHAR2(100)`). */
+    columns: Record<string, string>;
+    /** Access driver type: ORACLE_LOADER (flat files) or ORACLE_DATAPUMP. */
+    type?: 'ORACLE_LOADER' | 'ORACLE_DATAPUMP';
+    /** Directory object the data files live in (`DEFAULT DIRECTORY dir`). */
+    directory: string;
+    /** Raw access-parameters block placed inside `ACCESS PARAMETERS (...)`. */
+    accessParameters?: string;
+    /** Data file name(s) referenced by `LOCATION (...)`. */
+    location: string | string[];
+    /** Emit `REJECT LIMIT UNLIMITED` (default) or a specific numeric reject limit. */
+    rejectLimit?: number | 'UNLIMITED';
+}
+/**
+ * Oracle dialect class that implements the Dialect interface
+ */
+export declare class OracleDialect implements Dialect {
+    readonly name = "oracle";
+    readonly library = "oracledb";
+    private pool;
+    private _isConnected;
+    private config;
+    private retryOptions;
+    constructor(config: OracleDialectOptions);
+    /**
+     * Execute a function with retry logic
+     */
+    private withRetry;
+    /**
+     * Escape a string for SQL (replace ' with '')
+     */
+    private escapeString;
+    /**
+     * Connect to the Oracle database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the Oracle database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current connection from pool
+     */
+    getConnection(): Promise<Connection>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * 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: string, options?: StreamOptions): Readable;
+    /**
+     * Execute a query
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value: any): string;
+    /**
+     * 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: unknown): string;
+    /**
+     * Quote an identifier with double quotes (Oracle standard)
+     */
+    quoteIdentifier(identifier: unknown): string;
+    /**
+     * Quote a table name with optional schema
+     */
+    quoteTable(tableName: string, schema?: string): string;
+    /**
+     * Get database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * `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.
+     */
+    private wrapIgnoringOraErrors;
+    /** ORA-00955: name is already used by an existing object. */
+    private static readonly ORA_NAME_ALREADY_USED;
+    /** ORA-01920: user name conflicts with another user or role name. */
+    private static readonly ORA_USER_ALREADY_EXISTS;
+    /** ORA-01921: role name conflicts with another user or role name. */
+    private static readonly ORA_ROLE_ALREADY_EXISTS;
+    /** ORA-00942: table or view does not exist. */
+    private static readonly ORA_TABLE_DOES_NOT_EXIST;
+    /** ORA-01918: user does not exist. */
+    private static readonly ORA_USER_DOES_NOT_EXIST;
+    /** ORA-01919: role does not exist. */
+    private static readonly ORA_ROLE_DOES_NOT_EXIST;
+    /** ORA-02289: sequence does not exist. */
+    private static readonly ORA_SEQUENCE_DOES_NOT_EXIST;
+    /**
+     * 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.
+     */
+    createSchema(schema: string): Promise<void>;
+    /**
+     * 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.
+     */
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    /**
+     * Show all schemas
+     */
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas (Oracle users)
+     */
+    listSchemas(): Promise<string[]>;
+    /**
+     * Create database SQL (Oracle uses tablespaces)
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        tablespace?: string;
+    }): string;
+    /**
+     * Drop database SQL
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * Create a table
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Build column definition for Oracle
+     */
+    private buildColumnDefinition;
+    /**
+     * Build constraint definition
+     */
+    private buildConstraintDefinition;
+    /**
+     * Drop a table
+     */
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * Create partitioned table (Oracle supports RANGE, LIST, HASH, and INTERVAL partitioning)
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash' | 'interval' | 'reference';
+            /** Partition key column(s). Not used (and not required) for 'reference' partitioning. */
+            column?: string | string[];
+            interval?: string;
+            /**
+             * Name of the FK constraint (defined on this table) whose parent
+             * table's partitioning scheme should be inherited. Required when
+             * `type` is 'reference'.
+             * Oracle syntax: `PARTITION BY REFERENCE (constraint_name)`.
+             */
+            referenceConstraint?: string;
+        };
+        partitions?: {
+            name: string;
+            bound?: PartitionBound | PartitionListBound | PartitionHashBound;
+            tablespace?: string;
+            storageParameters?: Record<string, string | number>;
+            compression?: boolean;
+        }[];
+        subpartitionBy?: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+        subpartitions?: {
+            name: string;
+            bound?: PartitionBound | PartitionListBound | PartitionHashBound;
+            tablespace?: string;
+        }[];
+    }): Promise<void>;
+    /**
+     * Create partition
+     * Supports subpartitions in Oracle
+     */
+    createPartition(options: CreatePartitionOptions & {
+        subpartitionBy?: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+        subpartitions?: {
+            name: string;
+            bound?: PartitionBound | PartitionListBound | PartitionHashBound;
+            tablespace?: string;
+        }[];
+        tablespace?: string;
+        compression?: boolean;
+        storageParameters?: Record<string, string | number>;
+    }): Promise<void>;
+    /**
+     * "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.
+     */
+    attachPartition(options: AttachPartitionOptions & {
+        exchangeTable?: string;
+        includingIndexes?: boolean;
+        validation?: 'WITH VALIDATION' | 'WITHOUT VALIDATION';
+    }): Promise<void>;
+    /**
+     * "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.
+     */
+    detachPartition(options: DetachPartitionOptions & {
+        parentTable: string;
+        exchangeTable?: string;
+        includingIndexes?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop partition
+     * Enhanced with cascade option for Oracle
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+        updateIndexes?: boolean;
+    }): Promise<void>;
+    /**
+     * 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
+     */
+    addPartition(tableName: string, partitionName: string, partitionSpec: {
+        values?: string;
+        forValues?: string;
+    }): Promise<void>;
+    /**
+     * List partitions for a table with details
+     */
+    listPartitions(tableName: string): Promise<Array<{
+        partitionName: string;
+        partitionPosition: number;
+        highValue: string;
+        partitionType: string;
+        tablespaceName: string;
+        compression: string;
+        numRows: number;
+    }>>;
+    /**
+     * Modify partition (move, compress)
+     */
+    modifyPartition(tableName: string, partitionName: string, options?: {
+        move?: boolean;
+        compress?: boolean;
+        tablespace?: string;
+        storageParameters?: Record<string, string | number>;
+        updateIndexes?: boolean;
+    }): Promise<void>;
+    /**
+     * Create foreign data wrapper (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    createForeignDataWrapper(_fdwName: string, _options?: {
+        handler?: string;
+    }): Promise<void>;
+    /**
+     * Drop foreign data wrapper (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    dropForeignDataWrapper(_fdwName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create foreign server (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    createForeignServer(_serverName: string, _fdwName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop foreign server (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    dropForeignServer(_serverName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create foreign table (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    createForeignTable(_tableName: string, _columns: Record<string, any>, _options?: {
+        serverName: string;
+        schema?: string;
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create user mapping (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    createUserMapping(_serverName: string, _userName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop user mapping (stub)
+     * Oracle uses Data Guard instead of FDW
+     */
+    dropUserMapping(_serverName: string, _userName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    changeOwner(_newOwner: string, _tableName: string): Promise<void>;
+    addConstraint(_tableName: string, _options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(_tableName: string, _constraintName: string): Promise<void>;
+    createSecurityPolicy(_policyName: string, _tableName: string, _options?: {
+        predicate?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(_policyName: string, _tableName: string): Promise<void>;
+    /**
+     * Create a view
+     */
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    /**
+     * Drop a view
+     */
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    /**
+     * Show all views
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Create a materialized view
+     * Oracle syntax:
+     * CREATE MATERIALIZED VIEW mv_name
+     * BUILD [IMMEDIATE | DEFERRED]
+     * REFRESH [FAST | COMPLETE | FORCE]
+     * ON [COMMIT | DEMAND]
+     * AS query
+     */
+    createMaterializedView(options: MaterializedViewOptions): Promise<void>;
+    /**
+     * 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
+     */
+    refreshMaterializedView(viewName: string, options?: RefreshOptions): Promise<void>;
+    /**
+     * Drop a materialized view
+     */
+    dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions): Promise<void>;
+    /**
+     * Show all materialized views
+     */
+    showMaterializedViews(): Promise<string[]>;
+    /**
+     * 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
+     */
+    hasMaterializedView(viewName: string, schema?: string): Promise<boolean>;
+    /**
+     * Add comment to materialized view
+     */
+    private commentMaterializedView;
+    /**
+     * 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]
+     * ```
+     */
+    createMaterializedViewLog(tableName: string, options?: MaterializedViewLogOptions): Promise<void>;
+    /**
+     * 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.)
+     */
+    dropMaterializedViewLog(tableName: string, options?: Pick<MaterializedViewLogOptions, 'schema'>): Promise<void>;
+    /**
+     * Add a column
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Describe a table
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Rename a table
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Show all tables
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Get table status (Oracle implementation)
+     */
+    getTableStatus(tableName?: string): Promise<Record<string, any>[]>;
+    /**
+     * Get table create statement (Oracle implementation)
+     */
+    getCreateTable(tableName: string): Promise<string>;
+    /**
+     * Check if a table has partitions (Oracle implementation)
+     */
+    hasPartition(tableName: string): Promise<boolean>;
+    /**
+     * Show constraints for a table
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Show indexes for a table
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * Add an index
+     */
+    addIndex(tableName: string, indexName: string, fields: string[], options?: IndexOptions): Promise<void>;
+    /**
+     * Build CREATE INDEX SQL
+     */
+    private buildCreateIndexSql;
+    /**
+     * Remove an index
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Create an index with full options
+     */
+    createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    /**
+     * Drop an index
+     */
+    dropIndex(tableName: string, indexName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a constraint
+     */
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    /**
+     * Drop a constraint
+     */
+    dropConstraint(tableName: string, constraintName: string, options?: DropConstraintOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    private static readonly SUPPORTED_ISOLATION_LEVELS;
+    /**
+     * Start a transaction
+     */
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    /**
+     * Commit a transaction
+     */
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name: string): string;
+    /**
+     * Commit a transaction
+     */
+    commitTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Rollback a transaction
+     */
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Get SQL for a data type
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * 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.
+     */
+    private mapDataType;
+    /**
+     * Build WHERE clause
+     */
+    buildWhereClause(where: WhereOptions, options?: BuildOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build operator WHERE clause
+     */
+    private buildOperatorWhere;
+    /**
+     * Build ORDER BY clause
+     */
+    buildOrderClause(order: Order, _options?: BuildOptions): string;
+    /**
+     * Build a list of ORDER BY items (without the leading `ORDER BY` keyword),
+     * suitable for embedding inside `OVER (...)` / `WITHIN GROUP (...)` clauses.
+     */
+    private buildOrderByItems;
+    /**
+     * Build an Oracle analytic/window function expression, e.g.
+     * `ROW_NUMBER() OVER (PARTITION BY "dept" ORDER BY "salary" DESC)`.
+     */
+    buildWindowFunction(options: OracleWindowFunctionOptions): string;
+    /**
+     * 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: OracleCTEOptions | OracleCTEOptions[], mainQuery: string): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * 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: OracleConnectByOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build LIMIT/OFFSET clause using ROWNUM
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build INSERT query
+     */
+    buildInsertQuery(tableName: string, values: Record<string, any>, options?: InsertOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build UPDATE query
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, any>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build DELETE query
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build SELECT query
+     */
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * 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: OracleMergeOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build UPSERT query (MERGE for Oracle)
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build increment query
+     */
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Replace placeholders in SQL
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    createExtension(_extensionName: string, _options?: any): Promise<void>;
+    dropExtension(_extensionName: string, _options?: any): Promise<void>;
+    getExtensions(): Promise<any[]>;
+    hasExtension(_extensionName: string): Promise<boolean>;
+    buildCreateServerQuery(_name: string, _opts: any): string;
+    buildAlterServerQuery(_name: string, _opts: any): string;
+    buildDropServerQuery(_name: string, _opts?: any): string;
+    buildCreateUserMappingQuery(_opts: any): string;
+    buildAlterUserMappingQuery(_opts: any): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: any): string;
+    buildCreateForeignTableQuery(_tableName: string, _opts: any): string;
+    buildDropForeignTableQuery(_tableName: string, _opts?: any): string;
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: any): string;
+    getServersQuery(): string;
+    /**
+     * Build a CREATE USER statement for Oracle.
+     *
+     * Oracle syntax: CREATE USER username IDENTIFIED BY password
+     */
+    buildCreateUserQuery(username: string, options?: import('../../user-management').CreateUserOptions): string;
+    /**
+     * Build an ALTER USER statement for Oracle.
+     *
+     * Oracle syntax: ALTER USER username IDENTIFIED BY password
+     */
+    buildAlterUserQuery(username: string, options: import('../../user-management').AlterUserOptions): string;
+    /**
+     * Build a DROP USER statement for Oracle.
+     */
+    buildDropUserQuery(username: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Return a query that lists all Oracle users.
+     */
+    getUsersQuery(): string;
+    /**
+     * Build a GRANT statement for Oracle.
+     *
+     * Oracle syntax: GRANT privilege ON object TO user
+     */
+    buildGrantQuery(options: import('../../user-management').GrantOptions): string;
+    /**
+     * Build a REVOKE statement for Oracle.
+     *
+     * Oracle syntax: REVOKE privilege ON object FROM user
+     */
+    buildRevokeQuery(options: import('../../user-management').RevokeOptions): string;
+    /**
+     * Build a SHOW GRANTS query for Oracle.
+     * Queries USER_TAB_PRIVS for object grants.
+     */
+    buildShowGrantsQuery(username: string, _host?: string): string;
+    /**
+     * Oracle does not require FLUSH PRIVILEGES - return a no-op.
+     */
+    buildFlushPrivilegesQuery(): string;
+    /**
+     * Build a CREATE ROLE statement for Oracle.
+     */
+    buildCreateRoleQuery(roleName: string, options?: import('../../user-management').RoleOptions): string;
+    /**
+     * Build a DROP ROLE statement for Oracle.
+     */
+    buildDropRoleQuery(roleName: string, options?: {
+        ifExists?: boolean;
+    }): string;
+    /**
+     * Build a GRANT ROLE statement for Oracle.
+     */
+    buildGrantRoleQuery(role: string, to: string | string[], options?: {
+        withAdminOption?: boolean;
+    }): string;
+    /**
+     * Build a REVOKE ROLE statement for Oracle.
+     */
+    buildRevokeRoleQuery(role: string, from: string | string[], _options?: {
+        cascade?: boolean;
+    }): string;
+    /**
+     * Return a query that lists all Oracle roles.
+     */
+    getRolesQuery(): string;
+    /**
+     * Build Oracle privilege scope for GRANT/REVOKE.
+     */
+    private buildPrivilegeScope;
+    /**
+     * Escape a string value for Oracle (quote with double quotes).
+     */
+    private escapeStringValue;
+    createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * 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}).
+     */
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    hasSequence(sequenceName: string, schema?: string): Promise<boolean>;
+    /**
+     * List all sequences in the database (Oracle)
+     * @returns Array of sequence names
+     */
+    listSequences(): Promise<string[]>;
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     */
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    private commentProcedure;
+    createTrigger(options: TriggerOptions): Promise<void>;
+    dropTrigger(triggerName: string, tableName: string, options?: DropTriggerOptions): Promise<void>;
+    hasTrigger(triggerName: string, tableName: string, schema?: string): Promise<boolean>;
+    /**
+     * Create a security policy (RLS)
+     */
+    createPolicy(options: PolicyOptions): Promise<void>;
+    /**
+     * Drop a security policy
+     */
+    dropPolicy(policyName: string, tableName: string, options?: DropPolicyOptions): Promise<void>;
+    /**
+     * Enable Row-Level Security on a table
+     */
+    enableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Disable Row-Level Security on a table
+     */
+    disableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Check if a policy exists
+     */
+    hasPolicy(policyName: string, tableName: string): Promise<boolean>;
+    /**
+     * Add comment to a table
+     */
+    commentTable(tableName: string, comment: string): Promise<void>;
+    /**
+     * Add comment to a column
+     */
+    commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+    /**
+     * Create a partial index (index with WHERE clause)
+     */
+    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an expression index (functional index)
+     */
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an identity column (auto-increment)
+     */
+    createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+        minvalue?: number;
+        maxvalue?: number;
+        cycle?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a computed (virtual) column
+     */
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * Bulk insert records into a table
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): Promise<QueryResult>;
+    /**
+     * Add a foreign key to a table
+     */
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: {
+        name?: string;
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+    }): Promise<void>;
+    /**
+     * Rename a column
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * Create a fulltext index (Oracle uses Oracle Text)
+     */
+    createFulltextIndex(tableName: string, indexName: string, fields: string[], options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Create a spatial index (Oracle uses Spatial indexing)
+     */
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], _options?: {
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * ST_Distance - calculate distance between two geometries (Oracle)
+     */
+    stDistance(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Within - check if geometry A is within geometry B (Oracle)
+     */
+    stWithin(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Contains - check if geometry A contains geometry B (Oracle)
+     */
+    stContains(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Intersects - check if geometries intersect (Oracle)
+     */
+    stIntersects(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_DWithin - check if geometries are within a given distance (Oracle)
+     */
+    stDWithin(geom1: string, geom2: string, distance: number, srid?: number): string;
+    /**
+     * ST_AsText - convert geometry to text representation (Oracle)
+     */
+    stAsText(geom: string): string;
+    /**
+     * ST_GeomFromText - create geometry from text (Oracle)
+     */
+    stGeomFromText(wkt: string, srid?: number): string;
+    /**
+     * 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: string, rowPath: string, columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, alias: string): string;
+    /**
+     * 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: string, delimiter?: string, orderBy?: Order, overflow?: string): string;
+    /**
+     * Build an Oracle `PIVOT` query, rotating rows into columns (11g+).
+     */
+    buildPivotQuery(options: OraclePivotOptions): string;
+    /**
+     * Build an Oracle `UNPIVOT` query, rotating columns into rows (11g+).
+     */
+    buildUnpivotQuery(options: OracleUnpivotOptions): string;
+    /**
+     * Convert a dot/bracket JSON path (e.g. `address.city` or `items[0].sku`) into
+     * an Oracle JSON path expression rooted at `$` (`$.address.city`,
+     * `$.items[0].sku`). A path already starting with `$` is passed through.
+     */
+    private toOracleJsonPath;
+    /**
+     * Build a scalar `JSON_VALUE(column, '$.path' RETURNING type)` accessor
+     * (Oracle 12c+), the standard way to extract a scalar out of a JSON column.
+     */
+    buildJsonValue(column: string, path: string, options?: {
+        returning?: string;
+        onError?: string;
+    }): string;
+    /**
+     * Build a `JSON_QUERY(column, '$.path')` accessor (Oracle 12c+) for extracting
+     * a JSON object/array fragment (rather than a scalar) out of a JSON column.
+     */
+    buildJsonQuery(column: string, path: string, options?: {
+        wrapper?: 'WITH WRAPPER' | 'WITHOUT WRAPPER' | 'WITH CONDITIONAL WRAPPER';
+    }): string;
+    /**
+     * Build a `JSON_EXISTS(column, '$.path')` predicate (Oracle 12c+) for use in a
+     * WHERE clause to test for the presence of a JSON path.
+     */
+    buildJsonExists(column: string, path: string): string;
+    /**
+     * Create an Oracle PL/SQL package specification and/or body. Emits
+     * `CREATE [OR REPLACE] PACKAGE name AS <spec> END;` and, when `body` is given,
+     * a following `CREATE [OR REPLACE] PACKAGE BODY name AS <body> END;`.
+     * At least one of `spec`/`body` must be provided.
+     */
+    createPackage(options: OraclePackageOptions): Promise<void>;
+    /**
+     * Drop an Oracle PL/SQL package. Pass `bodyOnly` to drop just the body and
+     * keep the specification.
+     */
+    dropPackage(packageName: string, options?: {
+        schema?: string;
+        bodyOnly?: boolean;
+    }): Promise<void>;
+    /**
+     * Build an Oracle flashback `AS OF` clause (`AS OF TIMESTAMP ...` or
+     * `AS OF SCN ...`) to append to a table reference for a point-in-time read.
+     * Returns an empty string when neither timestamp nor SCN is given.
+     */
+    buildFlashbackClause(options: OracleFlashbackOptions): string;
+    /**
+     * Build a flashback SELECT: `SELECT ... FROM table AS OF ... [WHERE ...]`,
+     * reading the table's rows as they existed at a past timestamp or SCN.
+     */
+    buildFlashbackQuery(tableName: string, flashback: OracleFlashbackOptions, options?: {
+        schema?: string;
+        attributes?: string[];
+        where?: WhereOptions;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Flashback a table to a past point in time (`FLASHBACK TABLE t TO TIMESTAMP/SCN ...`).
+     * Requires row movement enabled on the table.
+     */
+    flashbackTable(tableName: string, flashback: OracleFlashbackOptions): Promise<void>;
+    /**
+     * Restore a dropped table from the recycle bin
+     * (`FLASHBACK TABLE t TO BEFORE DROP [RENAME TO newName]`).
+     */
+    flashbackTableBeforeDrop(tableName: string, renameTo?: string): Promise<void>;
+    /**
+     * Create an Oracle external table (`ORGANIZATION EXTERNAL`) — the native
+     * Oracle mechanism for reading flat files / Data Pump dumps as a table, and
+     * the recommended replacement for the PostgreSQL-only foreign-table API that
+     * this dialect rejects.
+     */
+    createExternalTable(tableName: string, options: OracleExternalTableOptions): Promise<void>;
+    /**
+     * Build an Oracle Text `CONTAINS(column, 'query') > 0` predicate for use in a
+     * WHERE clause against a `CTXSYS.CONTEXT` index (see `createFulltextIndex`).
+     * `label` ties the predicate to a `SCORE(label)` projection.
+     */
+    buildContains(column: string, query: string, label?: number): string;
+    /**
+     * Build an Oracle Text `SCORE(label)` projection expression that reports the
+     * relevance score computed by a matching `CONTAINS(..., label)` predicate.
+     */
+    buildScore(label?: number): string;
+}
+/**
+ * Create Oracle dialect instance
+ */
+export declare function createOracleDialect(options?: OracleDialectOptions): OracleDialect;
+export default OracleDialect;