knex 2.5.0 → 3.0.0

package/lib/dialects/oracle/schema/internal/incrementUtils.js

@@ -1,20 +1,20 @@
-const Trigger = require('./trigger');
-
-// helper function for pushAdditional in increments() and bigincrements()
-function createAutoIncrementTriggerAndSequence(columnCompiler) {
-  // TODO Add warning that sequence etc is created
-  columnCompiler.pushAdditional(function () {
-    const tableName = this.tableCompiler.tableNameRaw;
-    const schemaName = this.tableCompiler.schemaNameRaw;
-    const createTriggerSQL = Trigger.createAutoIncrementTrigger(
-      this.client.logger,
-      tableName,
-      schemaName
-    );
-    this.pushQuery(createTriggerSQL);
-  });
-}
-
-module.exports = {
-  createAutoIncrementTriggerAndSequence,
-};
+const Trigger = require('./trigger');
+
+// helper function for pushAdditional in increments() and bigincrements()
+function createAutoIncrementTriggerAndSequence(columnCompiler) {
+  // TODO Add warning that sequence etc is created
+  columnCompiler.pushAdditional(function () {
+    const tableName = this.tableCompiler.tableNameRaw;
+    const schemaName = this.tableCompiler.schemaNameRaw;
+    const createTriggerSQL = Trigger.createAutoIncrementTrigger(
+      this.client.logger,
+      tableName,
+      schemaName
+    );
+    this.pushQuery(createTriggerSQL);
+  });
+}
+
+module.exports = {
+  createAutoIncrementTriggerAndSequence,
+};

package/lib/dialects/oracle/schema/internal/trigger.js

@@ -1,135 +1,135 @@
-const utils = require('../../utils');
-
-const trigger = {
-  renameColumnTrigger: function (logger, tableName, columnName, to) {
-    const triggerName = utils.generateCombinedName(
-      logger,
-      'autoinc_trg',
-      tableName
-    );
-    const sequenceName = utils.generateCombinedName(logger, 'seq', tableName);
-    return (
-      `DECLARE ` +
-      `PK_NAME VARCHAR(200); ` +
-      `IS_AUTOINC NUMBER := 0; ` +
-      `BEGIN` +
-      `  EXECUTE IMMEDIATE ('ALTER TABLE "${tableName}" RENAME COLUMN "${columnName}" TO "${to}"');` +
-      `  SELECT COUNT(*) INTO IS_AUTOINC from "USER_TRIGGERS" where trigger_name = '${triggerName}';` +
-      `  IF (IS_AUTOINC > 0) THEN` +
-      `    SELECT cols.column_name INTO PK_NAME` +
-      `    FROM all_constraints cons, all_cons_columns cols` +
-      `    WHERE cons.constraint_type = 'P'` +
-      `    AND cons.constraint_name = cols.constraint_name` +
-      `    AND cons.owner = cols.owner` +
-      `    AND cols.table_name = '${tableName}';` +
-      `    IF ('${to}' = PK_NAME) THEN` +
-      `      EXECUTE IMMEDIATE ('DROP TRIGGER "${triggerName}"');` +
-      `      EXECUTE IMMEDIATE ('create or replace trigger "${triggerName}"` +
-      `      BEFORE INSERT on "${tableName}" for each row` +
-      `        declare` +
-      `        checking number := 1;` +
-      `        begin` +
-      `          if (:new."${to}" is null) then` +
-      `            while checking >= 1 loop` +
-      `              select "${sequenceName}".nextval into :new."${to}" from dual;` +
-      `              select count("${to}") into checking from "${tableName}"` +
-      `              where "${to}" = :new."${to}";` +
-      `            end loop;` +
-      `          end if;` +
-      `        end;');` +
-      `    end if;` +
-      `  end if;` +
-      `END;`
-    );
-  },
-
-  createAutoIncrementTrigger: function (logger, tableName, schemaName) {
-    const tableQuoted = `"${tableName}"`;
-    const tableUnquoted = tableName;
-    const schemaQuoted = schemaName ? `"${schemaName}".` : '';
-    const constraintOwner = schemaName ? `'${schemaName}'` : 'cols.owner';
-    const triggerName = utils.generateCombinedName(
-      logger,
-      'autoinc_trg',
-      tableName
-    );
-    const sequenceNameUnquoted = utils.generateCombinedName(
-      logger,
-      'seq',
-      tableName
-    );
-    const sequenceNameQuoted = `"${sequenceNameUnquoted}"`;
-    return (
-      `DECLARE ` +
-      `PK_NAME VARCHAR(200); ` +
-      `BEGIN` +
-      `  EXECUTE IMMEDIATE ('CREATE SEQUENCE ${schemaQuoted}${sequenceNameQuoted}');` +
-      `  SELECT cols.column_name INTO PK_NAME` + // TODO : support autoincrement on table with multiple primary keys
-      `  FROM all_constraints cons, all_cons_columns cols` +
-      `  WHERE cons.constraint_type = 'P'` +
-      `  AND cons.constraint_name = cols.constraint_name` +
-      `  AND cons.owner = ${constraintOwner}` +
-      `  AND cols.table_name = '${tableUnquoted}';` +
-      `  execute immediate ('create or replace trigger ${schemaQuoted}"${triggerName}"` +
-      `  BEFORE INSERT on ${schemaQuoted}${tableQuoted}` +
-      `  for each row` +
-      `  declare` +
-      `  checking number := 1;` +
-      `  begin` +
-      `    if (:new."' || PK_NAME || '" is null) then` +
-      `      while checking >= 1 loop` +
-      `        select ${schemaQuoted}${sequenceNameQuoted}.nextval into :new."' || PK_NAME || '" from dual;` +
-      `        select count("' || PK_NAME || '") into checking from ${schemaQuoted}${tableQuoted}` +
-      `        where "' || PK_NAME || '" = :new."' || PK_NAME || '";` +
-      `      end loop;` +
-      `    end if;` +
-      `  end;'); ` +
-      `END;`
-    );
-  },
-
-  renameTableAndAutoIncrementTrigger: function (logger, tableName, to) {
-    const triggerName = utils.generateCombinedName(
-      logger,
-      'autoinc_trg',
-      tableName
-    );
-    const sequenceName = utils.generateCombinedName(logger, 'seq', tableName);
-    const toTriggerName = utils.generateCombinedName(logger, 'autoinc_trg', to);
-    const toSequenceName = utils.generateCombinedName(logger, 'seq', to);
-    return (
-      `DECLARE ` +
-      `PK_NAME VARCHAR(200); ` +
-      `IS_AUTOINC NUMBER := 0; ` +
-      `BEGIN` +
-      `  EXECUTE IMMEDIATE ('RENAME "${tableName}" TO "${to}"');` +
-      `  SELECT COUNT(*) INTO IS_AUTOINC from "USER_TRIGGERS" where trigger_name = '${triggerName}';` +
-      `  IF (IS_AUTOINC > 0) THEN` +
-      `    EXECUTE IMMEDIATE ('DROP TRIGGER "${triggerName}"');` +
-      `    EXECUTE IMMEDIATE ('RENAME "${sequenceName}" TO "${toSequenceName}"');` +
-      `    SELECT cols.column_name INTO PK_NAME` +
-      `    FROM all_constraints cons, all_cons_columns cols` +
-      `    WHERE cons.constraint_type = 'P'` +
-      `    AND cons.constraint_name = cols.constraint_name` +
-      `    AND cons.owner = cols.owner` +
-      `    AND cols.table_name = '${to}';` +
-      `    EXECUTE IMMEDIATE ('create or replace trigger "${toTriggerName}"` +
-      `    BEFORE INSERT on "${to}" for each row` +
-      `      declare` +
-      `      checking number := 1;` +
-      `      begin` +
-      `        if (:new."' || PK_NAME || '" is null) then` +
-      `          while checking >= 1 loop` +
-      `            select "${toSequenceName}".nextval into :new."' || PK_NAME || '" from dual;` +
-      `            select count("' || PK_NAME || '") into checking from "${to}"` +
-      `            where "' || PK_NAME || '" = :new."' || PK_NAME || '";` +
-      `          end loop;` +
-      `        end if;` +
-      `      end;');` +
-      `  end if;` +
-      `END;`
-    );
-  },
-};
-
-module.exports = trigger;
+const utils = require('../../utils');
+
+const trigger = {
+  renameColumnTrigger: function (logger, tableName, columnName, to) {
+    const triggerName = utils.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      tableName
+    );
+    const sequenceName = utils.generateCombinedName(logger, 'seq', tableName);
+    return (
+      `DECLARE ` +
+      `PK_NAME VARCHAR(200); ` +
+      `IS_AUTOINC NUMBER := 0; ` +
+      `BEGIN` +
+      `  EXECUTE IMMEDIATE ('ALTER TABLE "${tableName}" RENAME COLUMN "${columnName}" TO "${to}"');` +
+      `  SELECT COUNT(*) INTO IS_AUTOINC from "USER_TRIGGERS" where trigger_name = '${triggerName}';` +
+      `  IF (IS_AUTOINC > 0) THEN` +
+      `    SELECT cols.column_name INTO PK_NAME` +
+      `    FROM all_constraints cons, all_cons_columns cols` +
+      `    WHERE cons.constraint_type = 'P'` +
+      `    AND cons.constraint_name = cols.constraint_name` +
+      `    AND cons.owner = cols.owner` +
+      `    AND cols.table_name = '${tableName}';` +
+      `    IF ('${to}' = PK_NAME) THEN` +
+      `      EXECUTE IMMEDIATE ('DROP TRIGGER "${triggerName}"');` +
+      `      EXECUTE IMMEDIATE ('create or replace trigger "${triggerName}"` +
+      `      BEFORE INSERT on "${tableName}" for each row` +
+      `        declare` +
+      `        checking number := 1;` +
+      `        begin` +
+      `          if (:new."${to}" is null) then` +
+      `            while checking >= 1 loop` +
+      `              select "${sequenceName}".nextval into :new."${to}" from dual;` +
+      `              select count("${to}") into checking from "${tableName}"` +
+      `              where "${to}" = :new."${to}";` +
+      `            end loop;` +
+      `          end if;` +
+      `        end;');` +
+      `    end if;` +
+      `  end if;` +
+      `END;`
+    );
+  },
+
+  createAutoIncrementTrigger: function (logger, tableName, schemaName) {
+    const tableQuoted = `"${tableName}"`;
+    const tableUnquoted = tableName;
+    const schemaQuoted = schemaName ? `"${schemaName}".` : '';
+    const constraintOwner = schemaName ? `'${schemaName}'` : 'cols.owner';
+    const triggerName = utils.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      tableName
+    );
+    const sequenceNameUnquoted = utils.generateCombinedName(
+      logger,
+      'seq',
+      tableName
+    );
+    const sequenceNameQuoted = `"${sequenceNameUnquoted}"`;
+    return (
+      `DECLARE ` +
+      `PK_NAME VARCHAR(200); ` +
+      `BEGIN` +
+      `  EXECUTE IMMEDIATE ('CREATE SEQUENCE ${schemaQuoted}${sequenceNameQuoted}');` +
+      `  SELECT cols.column_name INTO PK_NAME` + // TODO : support autoincrement on table with multiple primary keys
+      `  FROM all_constraints cons, all_cons_columns cols` +
+      `  WHERE cons.constraint_type = 'P'` +
+      `  AND cons.constraint_name = cols.constraint_name` +
+      `  AND cons.owner = ${constraintOwner}` +
+      `  AND cols.table_name = '${tableUnquoted}';` +
+      `  execute immediate ('create or replace trigger ${schemaQuoted}"${triggerName}"` +
+      `  BEFORE INSERT on ${schemaQuoted}${tableQuoted}` +
+      `  for each row` +
+      `  declare` +
+      `  checking number := 1;` +
+      `  begin` +
+      `    if (:new."' || PK_NAME || '" is null) then` +
+      `      while checking >= 1 loop` +
+      `        select ${schemaQuoted}${sequenceNameQuoted}.nextval into :new."' || PK_NAME || '" from dual;` +
+      `        select count("' || PK_NAME || '") into checking from ${schemaQuoted}${tableQuoted}` +
+      `        where "' || PK_NAME || '" = :new."' || PK_NAME || '";` +
+      `      end loop;` +
+      `    end if;` +
+      `  end;'); ` +
+      `END;`
+    );
+  },
+
+  renameTableAndAutoIncrementTrigger: function (logger, tableName, to) {
+    const triggerName = utils.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      tableName
+    );
+    const sequenceName = utils.generateCombinedName(logger, 'seq', tableName);
+    const toTriggerName = utils.generateCombinedName(logger, 'autoinc_trg', to);
+    const toSequenceName = utils.generateCombinedName(logger, 'seq', to);
+    return (
+      `DECLARE ` +
+      `PK_NAME VARCHAR(200); ` +
+      `IS_AUTOINC NUMBER := 0; ` +
+      `BEGIN` +
+      `  EXECUTE IMMEDIATE ('RENAME "${tableName}" TO "${to}"');` +
+      `  SELECT COUNT(*) INTO IS_AUTOINC from "USER_TRIGGERS" where trigger_name = '${triggerName}';` +
+      `  IF (IS_AUTOINC > 0) THEN` +
+      `    EXECUTE IMMEDIATE ('DROP TRIGGER "${triggerName}"');` +
+      `    EXECUTE IMMEDIATE ('RENAME "${sequenceName}" TO "${toSequenceName}"');` +
+      `    SELECT cols.column_name INTO PK_NAME` +
+      `    FROM all_constraints cons, all_cons_columns cols` +
+      `    WHERE cons.constraint_type = 'P'` +
+      `    AND cons.constraint_name = cols.constraint_name` +
+      `    AND cons.owner = cols.owner` +
+      `    AND cols.table_name = '${to}';` +
+      `    EXECUTE IMMEDIATE ('create or replace trigger "${toTriggerName}"` +
+      `    BEFORE INSERT on "${to}" for each row` +
+      `      declare` +
+      `      checking number := 1;` +
+      `      begin` +
+      `        if (:new."' || PK_NAME || '" is null) then` +
+      `          while checking >= 1 loop` +
+      `            select "${toSequenceName}".nextval into :new."' || PK_NAME || '" from dual;` +
+      `            select count("' || PK_NAME || '") into checking from "${to}"` +
+      `            where "' || PK_NAME || '" = :new."' || PK_NAME || '";` +
+      `          end loop;` +
+      `        end if;` +
+      `      end;');` +
+      `  end if;` +
+      `END;`
+    );
+  },
+};
+
+module.exports = trigger;

package/lib/dialects/oracle/schema/oracle-columnbuilder.js

@@ -1,17 +1,17 @@
-const ColumnBuilder = require('../../../schema/columnbuilder');
-const toArray = require('lodash/toArray');
-
-class ColumnBuilder_Oracle extends ColumnBuilder {
-  constructor() {
-    super(...arguments);
-  }
-
-  // checkIn added to the builder to allow the column compiler to change the
-  // order via the modifiers ("check" must be after "default")
-  checkIn() {
-    this._modifiers.checkIn = toArray(arguments);
-    return this;
-  }
-}
-
-module.exports = ColumnBuilder_Oracle;
+const ColumnBuilder = require('../../../schema/columnbuilder');
+const toArray = require('lodash/toArray');
+
+class ColumnBuilder_Oracle extends ColumnBuilder {
+  constructor() {
+    super(...arguments);
+  }
+
+  // checkIn added to the builder to allow the column compiler to change the
+  // order via the modifiers ("check" must be after "default")
+  checkIn() {
+    this._modifiers.checkIn = toArray(arguments);
+    return this;
+  }
+}
+
+module.exports = ColumnBuilder_Oracle;

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

@@ -1,126 +1,126 @@
-const uniq = require('lodash/uniq');
-const Raw = require('../../../raw');
-const ColumnCompiler = require('../../../schema/columncompiler');
-const {
-  createAutoIncrementTriggerAndSequence,
-} = require('./internal/incrementUtils');
-const { toNumber } = require('../../../util/helpers');
-
-// Column Compiler
-// -------
-
-class ColumnCompiler_Oracle extends ColumnCompiler {
-  constructor() {
-    super(...arguments);
-    this.modifiers = ['defaultTo', 'checkIn', 'nullable', 'comment'];
-  }
-
-  increments(options = { primaryKey: true }) {
-    createAutoIncrementTriggerAndSequence(this);
-    return (
-      'integer not null' +
-      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
-    );
-  }
-
-  bigincrements(options = { primaryKey: true }) {
-    createAutoIncrementTriggerAndSequence(this);
-    return (
-      'number(20, 0) not null' +
-      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
-    );
-  }
-
-  floating(precision) {
-    const parsedPrecision = toNumber(precision, 0);
-    return `float${parsedPrecision ? `(${parsedPrecision})` : ''}`;
-  }
-
-  double(precision, scale) {
-    // if (!precision) return 'number'; // TODO: Check If default is ok
-    return `number(${toNumber(precision, 8)}, ${toNumber(scale, 2)})`;
-  }
-
-  decimal(precision, scale) {
-    if (precision === null) return 'decimal';
-    return `decimal(${toNumber(precision, 8)}, ${toNumber(scale, 2)})`;
-  }
-
-  integer(length) {
-    return length ? `number(${toNumber(length, 11)})` : 'integer';
-  }
-
-  enu(allowed) {
-    allowed = uniq(allowed);
-    const maxLength = (allowed || []).reduce(
-      (maxLength, name) => Math.max(maxLength, String(name).length),
-      1
-    );
-
-    // implicitly add the enum values as checked values
-    this.columnBuilder._modifiers.checkIn = [allowed];
-
-    return `varchar2(${maxLength})`;
-  }
-
-  datetime(without) {
-    return without ? 'timestamp' : 'timestamp with time zone';
-  }
-
-  timestamp(without) {
-    return without ? 'timestamp' : 'timestamp with time zone';
-  }
-
-  bool() {
-    // implicitly add the check for 0 and 1
-    this.columnBuilder._modifiers.checkIn = [[0, 1]];
-    return 'number(1, 0)';
-  }
-
-  varchar(length) {
-    return `varchar2(${toNumber(length, 255)})`;
-  }
-
-  // Modifiers
-  // ------
-
-  comment(comment) {
-    const columnName = this.args[0] || this.defaults('columnName');
-
-    this.pushAdditional(function () {
-      this.pushQuery(
-        `comment on column ${this.tableCompiler.tableName()}.` +
-          this.formatter.wrap(columnName) +
-          " is '" +
-          (comment || '') +
-          "'"
-      );
-    }, comment);
-  }
-
-  checkIn(value) {
-    // TODO: Maybe accept arguments also as array
-    // TODO: value(s) should be escaped properly
-    if (value === undefined) {
-      return '';
-    } else if (value instanceof Raw) {
-      value = value.toQuery();
-    } else if (Array.isArray(value)) {
-      value = value.map((v) => `'${v}'`).join(', ');
-    } else {
-      value = `'${value}'`;
-    }
-    return `check (${this.formatter.wrap(this.args[0])} in (${value}))`;
-  }
-}
-
-ColumnCompiler_Oracle.prototype.tinyint = 'smallint';
-ColumnCompiler_Oracle.prototype.smallint = 'smallint';
-ColumnCompiler_Oracle.prototype.mediumint = 'integer';
-ColumnCompiler_Oracle.prototype.biginteger = 'number(20, 0)';
-ColumnCompiler_Oracle.prototype.text = 'clob';
-ColumnCompiler_Oracle.prototype.time = 'timestamp with time zone';
-ColumnCompiler_Oracle.prototype.bit = 'clob';
-ColumnCompiler_Oracle.prototype.json = 'clob';
-
-module.exports = ColumnCompiler_Oracle;
+const uniq = require('lodash/uniq');
+const Raw = require('../../../raw');
+const ColumnCompiler = require('../../../schema/columncompiler');
+const {
+  createAutoIncrementTriggerAndSequence,
+} = require('./internal/incrementUtils');
+const { toNumber } = require('../../../util/helpers');
+
+// Column Compiler
+// -------
+
+class ColumnCompiler_Oracle extends ColumnCompiler {
+  constructor() {
+    super(...arguments);
+    this.modifiers = ['defaultTo', 'checkIn', 'nullable', 'comment'];
+  }
+
+  increments(options = { primaryKey: true }) {
+    createAutoIncrementTriggerAndSequence(this);
+    return (
+      'integer not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
+  }
+
+  bigincrements(options = { primaryKey: true }) {
+    createAutoIncrementTriggerAndSequence(this);
+    return (
+      'number(20, 0) not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
+  }
+
+  floating(precision) {
+    const parsedPrecision = toNumber(precision, 0);
+    return `float${parsedPrecision ? `(${parsedPrecision})` : ''}`;
+  }
+
+  double(precision, scale) {
+    // if (!precision) return 'number'; // TODO: Check If default is ok
+    return `number(${toNumber(precision, 8)}, ${toNumber(scale, 2)})`;
+  }
+
+  decimal(precision, scale) {
+    if (precision === null) return 'decimal';
+    return `decimal(${toNumber(precision, 8)}, ${toNumber(scale, 2)})`;
+  }
+
+  integer(length) {
+    return length ? `number(${toNumber(length, 11)})` : 'integer';
+  }
+
+  enu(allowed) {
+    allowed = uniq(allowed);
+    const maxLength = (allowed || []).reduce(
+      (maxLength, name) => Math.max(maxLength, String(name).length),
+      1
+    );
+
+    // implicitly add the enum values as checked values
+    this.columnBuilder._modifiers.checkIn = [allowed];
+
+    return `varchar2(${maxLength})`;
+  }
+
+  datetime(without) {
+    return without ? 'timestamp' : 'timestamp with time zone';
+  }
+
+  timestamp(without) {
+    return without ? 'timestamp' : 'timestamp with time zone';
+  }
+
+  bool() {
+    // implicitly add the check for 0 and 1
+    this.columnBuilder._modifiers.checkIn = [[0, 1]];
+    return 'number(1, 0)';
+  }
+
+  varchar(length) {
+    return `varchar2(${toNumber(length, 255)})`;
+  }
+
+  // Modifiers
+  // ------
+
+  comment(comment) {
+    const columnName = this.args[0] || this.defaults('columnName');
+
+    this.pushAdditional(function () {
+      this.pushQuery(
+        `comment on column ${this.tableCompiler.tableName()}.` +
+          this.formatter.wrap(columnName) +
+          " is '" +
+          (comment || '') +
+          "'"
+      );
+    }, comment);
+  }
+
+  checkIn(value) {
+    // TODO: Maybe accept arguments also as array
+    // TODO: value(s) should be escaped properly
+    if (value === undefined) {
+      return '';
+    } else if (value instanceof Raw) {
+      value = value.toQuery();
+    } else if (Array.isArray(value)) {
+      value = value.map((v) => `'${v}'`).join(', ');
+    } else {
+      value = `'${value}'`;
+    }
+    return `check (${this.formatter.wrap(this.args[0])} in (${value}))`;
+  }
+}
+
+ColumnCompiler_Oracle.prototype.tinyint = 'smallint';
+ColumnCompiler_Oracle.prototype.smallint = 'smallint';
+ColumnCompiler_Oracle.prototype.mediumint = 'integer';
+ColumnCompiler_Oracle.prototype.biginteger = 'number(20, 0)';
+ColumnCompiler_Oracle.prototype.text = 'clob';
+ColumnCompiler_Oracle.prototype.time = 'timestamp with time zone';
+ColumnCompiler_Oracle.prototype.bit = 'clob';
+ColumnCompiler_Oracle.prototype.json = 'clob';
+
+module.exports = ColumnCompiler_Oracle;