knex 2.3.0 → 2.4.1

package/lib/dialects/oracledb/schema/oracledb-columncompiler.js

@@ -1,55 +1,55 @@
-const ColumnCompiler_Oracle = require('../../oracle/schema/oracle-columncompiler');
-const { isObject } = require('../../../util/is');
-
-class ColumnCompiler_Oracledb extends ColumnCompiler_Oracle {
-  constructor() {
-    super(...arguments);
-    this.modifiers = ['defaultTo', 'nullable', 'comment'];
-    this._addCheckModifiers();
-  }
-
-  datetime(withoutTz) {
-    let useTz;
-    if (isObject(withoutTz)) {
-      ({ useTz } = withoutTz);
-    } else {
-      useTz = !withoutTz;
-    }
-    return useTz ? 'timestamp with local time zone' : 'timestamp';
-  }
-
-  timestamp(withoutTz) {
-    let useTz;
-    if (isObject(withoutTz)) {
-      ({ useTz } = withoutTz);
-    } else {
-      useTz = !withoutTz;
-    }
-    return useTz ? 'timestamp with local time zone' : 'timestamp';
-  }
-
-  checkRegex(regex, constraintName) {
-    return this._check(
-      `REGEXP_LIKE(${this.formatter.wrap(
-        this.getColumnName()
-      )},${this.client._escapeBinding(regex)})`,
-      constraintName
-    );
-  }
-
-  json() {
-    return `varchar2(4000) check (${this.formatter.columnize(
-      this.getColumnName()
-    )} is json)`;
-  }
-
-  jsonb() {
-    return this.json();
-  }
-}
-
-ColumnCompiler_Oracledb.prototype.time = 'timestamp with local time zone';
-ColumnCompiler_Oracledb.prototype.uuid = ({ useBinaryUuid = false } = {}) =>
-  useBinaryUuid ? 'raw(16)' : 'char(36)';
-
-module.exports = ColumnCompiler_Oracledb;
+const ColumnCompiler_Oracle = require('../../oracle/schema/oracle-columncompiler');
+const { isObject } = require('../../../util/is');
+
+class ColumnCompiler_Oracledb extends ColumnCompiler_Oracle {
+  constructor() {
+    super(...arguments);
+    this.modifiers = ['defaultTo', 'nullable', 'comment'];
+    this._addCheckModifiers();
+  }
+
+  datetime(withoutTz) {
+    let useTz;
+    if (isObject(withoutTz)) {
+      ({ useTz } = withoutTz);
+    } else {
+      useTz = !withoutTz;
+    }
+    return useTz ? 'timestamp with local time zone' : 'timestamp';
+  }
+
+  timestamp(withoutTz) {
+    let useTz;
+    if (isObject(withoutTz)) {
+      ({ useTz } = withoutTz);
+    } else {
+      useTz = !withoutTz;
+    }
+    return useTz ? 'timestamp with local time zone' : 'timestamp';
+  }
+
+  checkRegex(regex, constraintName) {
+    return this._check(
+      `REGEXP_LIKE(${this.formatter.wrap(
+        this.getColumnName()
+      )},${this.client._escapeBinding(regex)})`,
+      constraintName
+    );
+  }
+
+  json() {
+    return `varchar2(4000) check (${this.formatter.columnize(
+      this.getColumnName()
+    )} is json)`;
+  }
+
+  jsonb() {
+    return this.json();
+  }
+}
+
+ColumnCompiler_Oracledb.prototype.time = 'timestamp with local time zone';
+ColumnCompiler_Oracledb.prototype.uuid = ({ useBinaryUuid = false } = {}) =>
+  useBinaryUuid ? 'raw(16)' : 'char(36)';
+
+module.exports = ColumnCompiler_Oracledb;

package/lib/dialects/oracledb/schema/oracledb-tablecompiler.js

@@ -1,19 +1,19 @@
-const TableCompiler_Oracle = require('../../oracle/schema/oracle-tablecompiler');
-
-class TableCompiler_Oracledb extends TableCompiler_Oracle {
-  constructor(client, tableBuilder) {
-    super(client, tableBuilder);
-  }
-
-  _setNullableState(column, isNullable) {
-    const nullability = isNullable ? 'NULL' : 'NOT NULL';
-    const sql = `alter table ${this.tableName()} modify (${this.formatter.wrap(
-      column
-    )} ${nullability})`;
-    return this.pushQuery({
-      sql: sql,
-    });
-  }
-}
-
-module.exports = TableCompiler_Oracledb;
+const TableCompiler_Oracle = require('../../oracle/schema/oracle-tablecompiler');
+
+class TableCompiler_Oracledb extends TableCompiler_Oracle {
+  constructor(client, tableBuilder) {
+    super(client, tableBuilder);
+  }
+
+  _setNullableState(column, isNullable) {
+    const nullability = isNullable ? 'NULL' : 'NOT NULL';
+    const sql = `alter table ${this.tableName()} modify (${this.formatter.wrap(
+      column
+    )} ${nullability})`;
+    return this.pushQuery({
+      sql: sql,
+    });
+  }
+}
+
+module.exports = TableCompiler_Oracledb;

package/lib/dialects/oracledb/schema/oracledb-viewbuilder.js

@@ -1,13 +1,13 @@
-const ViewBuilder = require('../../../schema/viewbuilder.js');
-
-class ViewBuilder_Oracledb extends ViewBuilder {
-  constructor() {
-    super(...arguments);
-  }
-
-  checkOption() {
-    this._single.checkOption = 'default_option';
-  }
-}
-
-module.exports = ViewBuilder_Oracledb;
+const ViewBuilder = require('../../../schema/viewbuilder.js');
+
+class ViewBuilder_Oracledb extends ViewBuilder {
+  constructor() {
+    super(...arguments);
+  }
+
+  checkOption() {
+    this._single.checkOption = 'default_option';
+  }
+}
+
+module.exports = ViewBuilder_Oracledb;

package/lib/dialects/oracledb/schema/oracledb-viewcompiler.js

@@ -1,19 +1,19 @@
-/* eslint max-len: 0 */
-
-const ViewCompiler = require('../../../schema/viewcompiler.js');
-
-class ViewCompiler_Oracledb extends ViewCompiler {
-  constructor(client, viewCompiler) {
-    super(client, viewCompiler);
-  }
-
-  createOrReplace() {
-    this.createQuery(this.columns, this.selectQuery, false, true);
-  }
-
-  createMaterializedView() {
-    this.createQuery(this.columns, this.selectQuery, true);
-  }
-}
-
-module.exports = ViewCompiler_Oracledb;
+/* eslint max-len: 0 */
+
+const ViewCompiler = require('../../../schema/viewcompiler.js');
+
+class ViewCompiler_Oracledb extends ViewCompiler {
+  constructor(client, viewCompiler) {
+    super(client, viewCompiler);
+  }
+
+  createOrReplace() {
+    this.createQuery(this.columns, this.selectQuery, false, true);
+  }
+
+  createMaterializedView() {
+    this.createQuery(this.columns, this.selectQuery, true);
+  }
+}
+
+module.exports = ViewCompiler_Oracledb;

package/lib/dialects/oracledb/transaction.js

@@ -1,98 +1,98 @@
-const Transaction = require('../../execution/transaction');
-const { timeout, KnexTimeoutError } = require('../../util/timeout');
-const debugTx = require('debug')('knex:tx');
-
-// There's also a "read only", but that's not really an "isolationLevel"
-const supportedIsolationLevels = ['read committed', 'serializable'];
-// Remove this if you make it work and set it to true
-const isIsolationLevelEnabled = false;
-
-module.exports = class Oracle_Transaction extends Transaction {
-  // disable autocommit to allow correct behavior (default is true)
-  begin(conn) {
-    if (this.isolationLevel) {
-      if (isIsolationLevelEnabled) {
-        if (!supportedIsolationLevels.includes(this.isolationLevel)) {
-          this.client.logger.warn(
-            'Oracle only supports read committed and serializable transactions, ignoring the isolation level param'
-          );
-        } else {
-          // I tried this, but it didn't work
-          // Doc here: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SET-TRANSACTION.html
-          return this.query(conn, `SET TRANSACTION ${this.isolationLevel}`);
-        }
-      } else {
-        this.client.logger.warn(
-          'Transaction isolation is not currently supported for Oracle'
-        );
-      }
-    }
-    return Promise.resolve();
-  }
-
-  async commit(conn, value) {
-    this._completed = true;
-    try {
-      await conn.commitAsync();
-      this._resolver(value);
-    } catch (err) {
-      this._rejecter(err);
-    }
-  }
-
-  release(conn, value) {
-    return this._resolver(value);
-  }
-
-  rollback(conn, err) {
-    this._completed = true;
-    debugTx('%s: rolling back', this.txid);
-    return timeout(conn.rollbackAsync(), 5000)
-      .catch((e) => {
-        if (!(e instanceof KnexTimeoutError)) {
-          return Promise.reject(e);
-        }
-        this._rejecter(e);
-      })
-      .then(() => {
-        if (err === undefined) {
-          if (this.doNotRejectOnRollback) {
-            this._resolver();
-            return;
-          }
-          err = new Error(`Transaction rejected with non-error: ${err}`);
-        }
-        this._rejecter(err);
-      });
-  }
-
-  savepoint(conn) {
-    return this.query(conn, `SAVEPOINT ${this.txid}`);
-  }
-
-  async acquireConnection(config, cb) {
-    const configConnection = config && config.connection;
-
-    const connection =
-      configConnection || (await this.client.acquireConnection());
-    try {
-      connection.__knexTxId = this.txid;
-      connection.isTransaction = true;
-      return await cb(connection);
-    } finally {
-      debugTx('%s: releasing connection', this.txid);
-      connection.isTransaction = false;
-      try {
-        await connection.commitAsync();
-      } catch (err) {
-        this._rejecter(err);
-      } finally {
-        if (!configConnection) {
-          await this.client.releaseConnection(connection);
-        } else {
-          debugTx('%s: not releasing external connection', this.txid);
-        }
-      }
-    }
-  }
-};
+const Transaction = require('../../execution/transaction');
+const { timeout, KnexTimeoutError } = require('../../util/timeout');
+const debugTx = require('debug')('knex:tx');
+
+// There's also a "read only", but that's not really an "isolationLevel"
+const supportedIsolationLevels = ['read committed', 'serializable'];
+// Remove this if you make it work and set it to true
+const isIsolationLevelEnabled = false;
+
+module.exports = class Oracle_Transaction extends Transaction {
+  // disable autocommit to allow correct behavior (default is true)
+  begin(conn) {
+    if (this.isolationLevel) {
+      if (isIsolationLevelEnabled) {
+        if (!supportedIsolationLevels.includes(this.isolationLevel)) {
+          this.client.logger.warn(
+            'Oracle only supports read committed and serializable transactions, ignoring the isolation level param'
+          );
+        } else {
+          // I tried this, but it didn't work
+          // Doc here: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SET-TRANSACTION.html
+          return this.query(conn, `SET TRANSACTION ${this.isolationLevel}`);
+        }
+      } else {
+        this.client.logger.warn(
+          'Transaction isolation is not currently supported for Oracle'
+        );
+      }
+    }
+    return Promise.resolve();
+  }
+
+  async commit(conn, value) {
+    this._completed = true;
+    try {
+      await conn.commitAsync();
+      this._resolver(value);
+    } catch (err) {
+      this._rejecter(err);
+    }
+  }
+
+  release(conn, value) {
+    return this._resolver(value);
+  }
+
+  rollback(conn, err) {
+    this._completed = true;
+    debugTx('%s: rolling back', this.txid);
+    return timeout(conn.rollbackAsync(), 5000)
+      .catch((e) => {
+        if (!(e instanceof KnexTimeoutError)) {
+          return Promise.reject(e);
+        }
+        this._rejecter(e);
+      })
+      .then(() => {
+        if (err === undefined) {
+          if (this.doNotRejectOnRollback) {
+            this._resolver();
+            return;
+          }
+          err = new Error(`Transaction rejected with non-error: ${err}`);
+        }
+        this._rejecter(err);
+      });
+  }
+
+  savepoint(conn) {
+    return this.query(conn, `SAVEPOINT ${this.txid}`);
+  }
+
+  async acquireConnection(config, cb) {
+    const configConnection = config && config.connection;
+
+    const connection =
+      configConnection || (await this.client.acquireConnection());
+    try {
+      connection.__knexTxId = this.txid;
+      connection.isTransaction = true;
+      return await cb(connection);
+    } finally {
+      debugTx('%s: releasing connection', this.txid);
+      connection.isTransaction = false;
+      try {
+        await connection.commitAsync();
+      } catch (err) {
+        this._rejecter(err);
+      } finally {
+        if (!configConnection) {
+          await this.client.releaseConnection(connection);
+        } else {
+          debugTx('%s: not releasing external connection', this.txid);
+        }
+      }
+    }
+  }
+};