@mikro-orm/oracledb 7.1.0-dev.2 → 7.1.0-dev.21

package/OracleSchemaHelper.d.ts

@@ -2,6 +2,8 @@ import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSc
 /** Schema introspection helper for Oracle Database. */
 export declare class OracleSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: Record<string, string[]>;
+    private static readonly AUTO_NOT_NULL_RE;
+    private static readonly PARTIAL_INDEX_RE;
     getDatabaseExistsSQL(name: string): string;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getListTablesSQL(schemaName?: string): string;
@@ -35,6 +37,9 @@ export declare class OracleSchemaHelper extends SchemaHelper {
     createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    protected getIndexColumns(index: IndexDef): string;
+    /** Oracle has no native WHERE clause for indexes; the predicate is folded into CASE-WHEN columns. */
+    protected getIndexWhereClause(_index: IndexDef): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     dropForeignKey(tableName: string, constraintName: string): string;
     dropViewIfExists(name: string, schema?: string): string;

package/OracleSchemaHelper.js

@@ -7,6 +7,12 @@ export class OracleSchemaHelper extends SchemaHelper {
         systimestamp: ['current_timestamp'],
         sysdate: ['current_timestamp'],
     };
+    // `stripAutoNotNullFilter` unwraps balanced per-clause parens before calling `.exec`, so we
+    // only need to match the bare form here.
+    static AUTO_NOT_NULL_RE = /^"?([^"\s()]+)"?\s+is\s+not\s+null$/i;
+    // Greedy `(.+)` so nested CASE expressions inside the predicate don't trip the match on
+    // an inner `then <col> end`.
+    static PARTIAL_INDEX_RE = /^\s*\(?\s*case\s+when\s+(.+)\s+then\s+"?([^"\s)]+)"?\s+end\s*\)?\s*$/is;
     getDatabaseExistsSQL(name) {
         return `select 1 from all_users where username = ${this.platform.quoteValue(name)}`;
     }
@@ -210,16 +216,19 @@ export class OracleSchemaHelper extends SchemaHelper {
             if (isPrimary) {
                 continue;
             }
+            const partialMatch = typeof index.expression === 'string' ? OracleSchemaHelper.PARTIAL_INDEX_RE.exec(index.expression) : null;
             const indexDef = {
-                columnNames: [index.column_name],
+                columnNames: [partialMatch ? partialMatch[2] : index.column_name],
                 keyName: index.index_name,
                 unique: index.is_unique === 'YES',
-                primary: false, // We skip PK indexes above, so this is always false
+                primary: false,
                 constraint: isConstraintIndex || index.is_unique === 'YES',
             };
-            // Handle function-based indexes (expression indexes)
-            /* v8 ignore start: expression index branches */
-            if (index.expression) {
+            /* v8 ignore start: function-based (non-partial) index branches */
+            if (partialMatch) {
+                indexDef.where = partialMatch[1].trim();
+            }
+            else if (index.expression) {
                 indexDef.expression = index.expression;
             }
             else if (index.column_name?.match(/[(): ,"'`]/)) {
@@ -231,6 +240,17 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         for (const key of Object.keys(ret)) {
             ret[key] = await this.mapIndexes(ret[key]);
+            for (const idx of ret[key]) {
+                if (idx.where) {
+                    const stripped = this.stripAutoNotNullFilter(idx.where, idx.columnNames, OracleSchemaHelper.AUTO_NOT_NULL_RE);
+                    if (stripped === '') {
+                        delete idx.where;
+                    }
+                    else {
+                        idx.where = stripped;
+                    }
+                }
+            }
         }
         return ret;
     }
@@ -503,6 +523,16 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return super.getCreateIndexSQL(tableName, index);
     }
+    getIndexColumns(index) {
+        if (index.where) {
+            return this.emulatePartialIndexColumns(index);
+        }
+        return super.getIndexColumns(index);
+    }
+    /** Oracle has no native WHERE clause for indexes; the predicate is folded into CASE-WHEN columns. */
+    getIndexWhereClause(_index) {
+        return '';
+    }
     createIndex(index, table, createPrimary = false) {
         if (index.primary) {
             return '';
@@ -524,10 +554,21 @@ export class OracleSchemaHelper extends SchemaHelper {
         const quotedTableName = table.getQuotedName();
         if (index.unique) {
             const nullableCols = index.columnNames.filter(column => table.getColumn(column)?.nullable);
+            const autoNotNull = nullableCols.length
+                ? nullableCols.map(c => `${this.quote(c)} is not null`).join(' and ')
+                : '';
+            if (index.where) {
+                // Wrap the user predicate in parens before ANDing the auto-NOT-NULL guard — otherwise a
+                // disjunctive `a = 1 or b = 2` would rebind as `a = 1 or (b = 2 and <col> is not null)`.
+                const predicate = autoNotNull ? `(${index.where}) and ${autoNotNull}` : index.where;
+                return `create unique index ${this.quote(index.keyName)} on ${quotedTableName} (${index.columnNames
+                    .map(c => `case when ${predicate} then ${this.quote(c)} end`)
+                    .join(', ')})`;
+            }
             return `create unique index ${this.quote(index.keyName)} on ${quotedTableName} (${index.columnNames
                 .map(c => {
                 if (table.getColumn(c)?.nullable) {
-                    return `case when ${nullableCols.map(c => `${this.quote(c)} is not null`).join(' and ')} then ${this.quote(c)} end`;
+                    return `case when ${autoNotNull} then ${this.quote(c)} end`;
                 }
                 return this.quote(c);
             })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/oracledb",
-  "version": "7.1.0-dev.2",
+  "version": "7.1.0-dev.21",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite, MSSQL and Oracle databases.",
   "keywords": [
     "data-mapper",
@@ -42,15 +42,15 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.2",
+    "@mikro-orm/sql": "7.1.0-dev.21",
     "kysely": "0.28.16",
     "oracledb": "6.10.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.12"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.2"
+    "@mikro-orm/core": "7.1.0-dev.21"
   },
   "engines": {
     "node": ">= 22.17.0"