@cubejs-backend/oracle-driver 1.6.64 → 1.6.65

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.6.65](https://github.com/cube-js/cube/compare/v1.6.64...v1.6.65) (2026-07-01)
+
+### Features
+
+- **oracle-driver:** Improvements & fixes, fix [#10834](https://github.com/cube-js/cube/issues/10834) ([#11174](https://github.com/cube-js/cube/issues/11174)) ([9da8e07](https://github.com/cube-js/cube/commit/9da8e076897071f204711456b92ff69150547d9c))
+
 ## [1.6.64](https://github.com/cube-js/cube/compare/v1.6.63...v1.6.64) (2026-06-25)
 
 **Note:** Version bump only for package @cubejs-backend/oracle-driver

package/driver/OracleDriver.js

@@ -7,11 +7,28 @@
 const {
   getEnv,
   assertDataSource,
+  Pool,
 } = require('@cubejs-backend/shared');
-const { BaseDriver, TableColumn } = require('@cubejs-backend/base-driver');
+const { BaseDriver, TableColumn, createPoolName } = require('@cubejs-backend/base-driver');
 const oracledb = require('oracledb');
 const { reduce } = require('ramda');
 
+// Maps Oracle `metaData.dbTypeName` strings to Cube generic types. NUMBER and the
+// TIMESTAMP* family are handled separately (scale-based / prefix match) below.
+const OracleTypeToGenericType = {
+  varchar2: 'text',
+  nvarchar2: 'text',
+  char: 'text',
+  nchar: 'text',
+  clob: 'text',
+  nclob: 'text',
+  long: 'text',
+  binary_float: 'float',
+  binary_double: 'double',
+  date: 'timestamp',
+  'number': 'decimal',
+};
+
 const sortByKeys = (unordered) => {
   const ordered = {};
 
@@ -43,20 +60,11 @@ const reduceCb = (result, i) => {
   return sortByKeys(result);
 };
 
-/**
- * Oracle driver class.
- */
 class OracleDriver extends BaseDriver {
-  /**
-   * Returns default concurrency value.
-   */
   static getDefaultConcurrency() {
     return 2;
   }
 
-  /**
-   * Class constructor.
-   */
   constructor(config = {}) {
     super({
       testConnectionTimeout: config.testConnectionTimeout,
@@ -72,20 +80,51 @@ class OracleDriver extends BaseDriver {
     this.db.partRows = 100000;
     this.db.maxRows = 100000;
     this.db.prefetchRows = 500;
+
+    const { maxPoolSize, pool, ...connectionConfig } = config;
+
     this.config = {
       user: getEnv('dbUser', { dataSource, preAggregations }),
       password: getEnv('dbPass', { dataSource, preAggregations }),
       db: getEnv('dbName', { dataSource, preAggregations }),
       host: getEnv('dbHost', { dataSource, preAggregations }),
       port: getEnv('dbPort', { dataSource, preAggregations }) || 1521,
-      poolMin: 0,
-      poolMax:
-        config.maxPoolSize ||
-        getEnv('dbMaxPoolSize', { dataSource, preAggregations }) ||
-        50,
-      ...config
+      ...connectionConfig,
     };
     this.config.connectionString = this.config.connectionString || `${this.config.host}:${this.config.port}/${this.config.db}`;
+
+    const poolName = createPoolName('oracle', dataSource, preAggregations);
+    this.pool = new Pool(poolName, {
+      create: async () => {
+        const connection = await this.db.getConnection(this.config);
+        await OracleDriver.initConnection(connection);
+
+        return connection;
+      },
+      validate: async (connection) => {
+        try {
+          await connection.ping();
+        } catch (e) {
+          this.databasePoolError(e);
+          return false;
+        }
+
+        return true;
+      },
+      destroy: (connection) => connection.close(),
+    }, {
+      min: 0,
+      max:
+        maxPoolSize ||
+        getEnv('dbMaxPoolSize', { dataSource, preAggregations }) ||
+        50,
+      evictionRunIntervalMillis: 10000,
+      softIdleTimeoutMillis: 30000,
+      idleTimeoutMillis: 30000,
+      testOnBorrow: true,
+      acquireTimeoutMillis: 20000,
+      ...pool,
+    });
   }
 
   async tablesSchema() {
@@ -110,12 +149,33 @@ class OracleDriver extends BaseDriver {
     return reduce(reduceCb, {}, data);
   }
 
-  async getConnectionFromPool() {
-    if (!this.pool) {
-      this.pool = await this.db.createPool(this.config);
-    }
+  /**
+   * Runs once per pooled session. Aligns the session NLS formats with the ISO-ish
+   * date strings Cube binds, so implicit string→DATE/TIMESTAMP conversions (e.g.
+   * the native planner's `CAST(? AS TIMESTAMP)` over a 'YYYY-MM-DD' filter bound)
+   * parse instead of failing with ORA-01843 under Oracle's default NLS. Explicit
+   * TO_DATE/TO_TIMESTAMP calls carry their own masks and are unaffected.
+   * @protected
+   */
+  static async initConnection(connection) {
+    await connection.execute(
+      "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD' NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD' NLS_TIMESTAMP_TZ_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF TZH:TZM'"
+    );
+  }
+
+  /**
+   * Acquires a connection from the pool, runs `fn`, and always releases the
+   * connection back to the pool (on both success and failure).
+   * @protected
+   */
+  async withConnection(fn) {
+    const connection = await this.pool.acquire();
 
-    return this.pool.getConnection()
+    try {
+      return await fn(connection);
+    } finally {
+      await this.pool.release(connection);
+    }
   }
 
   async testConnection() {
@@ -127,28 +187,84 @@ class OracleDriver extends BaseDriver {
       throw new Error('Oracle can not work with table names longer than 128 symbols. ' +
         `Consider using the 'sqlAlias' attribute in your cube definition for ${quotedTableName}.`);
     }
+
     return super.createTable(quotedTableName, columns);
   }
 
-  async query(query, values) {
-    const conn = await this.getConnectionFromPool();
+  static normalizeParams(query, values) {
+    if (!values || values.length === 0) {
+      return { sql: query, binds: {} };
+    }
 
-    try {
-      const res = await conn.execute(query, values || {});
+    const binds = {};
+    const valueToName = new Map();
+    let idx = 0;
+    let nextName = 0;
+
+    // `:"?"` must be matched as a whole before a lone `?`, so it appears first
+    // in the alternation; since it starts with `:`, its inner `?` is consumed
+    // as part of the match and never matched again on its own.
+    //
+    // Placeholders carrying the same value share a single named bind. This is
+    // semantically identical (the same value is bound) and keeps repeated
+    // expressions textually identical across clauses — required by Oracle, which
+    // otherwise rejects e.g. a CASE expression in both SELECT and GROUP BY when
+    // its param renders as two different bind names (ORA-00979).
+    const sql = query.replace(/:"\?"|\?/g, () => {
+      const value = values[idx];
+      idx += 1;
+      // A Map distinguishes values by SameValueZero, so 1 and '1' stay separate;
+      // the raw value works as the key without stringifying.
+      let name = valueToName.get(value);
+      if (name === undefined) {
+        name = `cb_param_${nextName}`;
+        nextName += 1;
+        valueToName.set(value, name);
+        binds[name] = value;
+      }
+      return `:${name}`;
+    });
+
+    return { sql, binds };
+  }
+
+  async query(query, values) {
+    return this.withConnection(async (conn) => {
+      const { sql, binds } = OracleDriver.normalizeParams(query, values);
+      const res = await conn.execute(sql, binds);
       return res && res.rows;
-    } catch (e) {
-      throw (e);
-    } finally {
-      try {
-        await conn.close();
-      } catch (e) {
-        throw e;
+    });
+  }
+
+  static metaDataToColumnTypes(metaData) {
+    return (metaData || []).map((column) => {
+      const dbTypeName = (column.dbTypeName || '').toLowerCase();
+      let type = 'text';
+
+      if (dbTypeName.startsWith('timestamp')) {
+        type = 'timestamp';
+      } else {
+        type = OracleTypeToGenericType[dbTypeName] || 'text';
       }
-    }
+
+      return { name: column.name, type };
+    });
+  }
+
+  async downloadQueryResults(query, values, _options) {
+    return this.withConnection(async (conn) => {
+      const { sql, binds } = OracleDriver.normalizeParams(query, values);
+      const res = await conn.execute(sql, binds);
+      return {
+        rows: (res && res.rows) || [],
+        types: OracleDriver.metaDataToColumnTypes(res && res.metaData),
+      };
+    });
   }
 
-  release() {
-    return this.pool && this.pool.close();
+  async release() {
+    await this.pool.drain();
+    await this.pool.clear();
   }
 
   readOnly() {
@@ -156,7 +272,8 @@ class OracleDriver extends BaseDriver {
   }
 
   wrapQueryWithLimit(query) {
-    query.query = `SELECT * FROM (${query.query}) AS t WHERE ROWNUM <= ${query.limit}`;
+    // Oracle forbids the `AS` keyword for table/subquery aliases.
+    query.query = `SELECT * FROM (${query.query}) t WHERE ROWNUM <= ${query.limit}`;
   }
 }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@cubejs-backend/oracle-driver",
   "description": "Cube.js oracle database driver",
   "author": "Cube Dev, Inc.",
-  "version": "1.6.64",
+  "version": "1.6.65",
   "repository": {
     "type": "git",
     "url": "https://github.com/cube-js/cube.git",
@@ -13,9 +13,13 @@
   },
   "main": "driver/OracleDriver.js",
   "dependencies": {
-    "@cubejs-backend/base-driver": "1.6.64",
+    "@cubejs-backend/base-driver": "1.6.65",
+    "@cubejs-backend/shared": "1.6.65",
     "ramda": "^0.27.0"
   },
+  "devDependencies": {
+    "@types/oracledb": "^6.2.3"
+  },
   "optionalDependencies": {
     "oracledb": "^6.2.0"
   },
@@ -26,5 +30,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8d76ec23f35cd64663e70952bedb89a1423daa21"
+  "gitHead": "64502a0ff14f50aa71f4577eac8fc2908419be87"
 }