Initial commit

node_modules/knex/lib/dialects/oracle/schema/internal/incrementUtils.js

@@ -0,0 +1,22 @@
+const Trigger = require('./trigger');
+
+// helper function for pushAdditional in increments() and bigincrements()
+function createAutoIncrementTriggerAndSequence(columnCompiler) {
+  const trigger = new Trigger(columnCompiler.client.version);
+
+  // 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,
+};

node_modules/knex/lib/dialects/oracle/schema/internal/trigger.js

@@ -0,0 +1,155 @@
+const { NameHelper } = require('../../utils');
+
+class Trigger {
+  constructor(oracleVersion) {
+    this.nameHelper = new NameHelper(oracleVersion);
+  }
+
+  renameColumnTrigger(logger, tableName, columnName, to) {
+    const triggerName = this.nameHelper.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      tableName
+    );
+    const sequenceName = this.nameHelper.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(logger, tableName, schemaName) {
+    const tableQuoted = `"${tableName}"`;
+    const tableUnquoted = tableName;
+    const schemaQuoted = schemaName ? `"${schemaName}".` : '';
+    const constraintOwner = schemaName ? `'${schemaName}'` : 'cols.owner';
+    const triggerName = this.nameHelper.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      tableName
+    );
+    const sequenceNameUnquoted = this.nameHelper.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(logger, tableName, to) {
+    const triggerName = this.nameHelper.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      tableName
+    );
+    const sequenceName = this.nameHelper.generateCombinedName(
+      logger,
+      'seq',
+      tableName
+    );
+    const toTriggerName = this.nameHelper.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      to
+    );
+    const toSequenceName = this.nameHelper.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;

node_modules/knex/lib/dialects/oracle/schema/oracle-columnbuilder.js

@@ -0,0 +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;

node_modules/knex/lib/dialects/oracle/schema/oracle-columncompiler.js

@@ -0,0 +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;

node_modules/knex/lib/dialects/oracle/schema/oracle-compiler.js

@@ -0,0 +1,124 @@
+// Oracle Schema Compiler
+// -------
+const SchemaCompiler = require('../../../schema/compiler');
+const utils = require('../utils');
+const Trigger = require('./internal/trigger');
+
+class SchemaCompiler_Oracle extends SchemaCompiler {
+  constructor() {
+    super(...arguments);
+  }
+
+  // Rename a table on the schema.
+  renameTable(tableName, to) {
+    const trigger = new Trigger(this.client.version);
+    const renameTable = trigger.renameTableAndAutoIncrementTrigger(
+      this.client.logger,
+      tableName,
+      to
+    );
+    this.pushQuery(renameTable);
+  }
+
+  // Check whether a table exists on the query.
+  hasTable(tableName) {
+    this.pushQuery({
+      sql:
+        'select TABLE_NAME from USER_TABLES where TABLE_NAME = ' +
+        this.client.parameter(tableName, this.builder, this.bindingsHolder),
+      output(resp) {
+        return resp.length > 0;
+      },
+    });
+  }
+
+  // Check whether a column exists on the schema.
+  hasColumn(tableName, column) {
+    const sql =
+      `select COLUMN_NAME from ALL_TAB_COLUMNS ` +
+      `where TABLE_NAME = ${this.client.parameter(
+        tableName,
+        this.builder,
+        this.bindingsHolder
+      )} ` +
+      `and COLUMN_NAME = ${this.client.parameter(
+        column,
+        this.builder,
+        this.bindingsHolder
+      )}`;
+    this.pushQuery({ sql, output: (resp) => resp.length > 0 });
+  }
+
+  dropSequenceIfExists(sequenceName) {
+    const prefix = this.schema ? `"${this.schema}".` : '';
+    this.pushQuery(
+      utils.wrapSqlWithCatch(
+        `drop sequence ${prefix}${this.formatter.wrap(sequenceName)}`,
+        -2289
+      )
+    );
+  }
+
+  _dropRelatedSequenceIfExists(tableName) {
+    // removing the sequence that was possibly generated by increments() column
+    const nameHelper = new utils.NameHelper(this.client.version);
+    const sequenceName = nameHelper.generateCombinedName(
+      this.client.logger,
+      'seq',
+      tableName
+    );
+    this.dropSequenceIfExists(sequenceName);
+  }
+
+  dropTable(tableName) {
+    const prefix = this.schema ? `"${this.schema}".` : '';
+    this.pushQuery(`drop table ${prefix}${this.formatter.wrap(tableName)}`);
+
+    // removing the sequence that was possibly generated by increments() column
+    this._dropRelatedSequenceIfExists(tableName);
+  }
+
+  dropTableIfExists(tableName) {
+    this.dropObject(tableName, 'table');
+  }
+
+  dropViewIfExists(viewName) {
+    this.dropObject(viewName, 'view');
+  }
+
+  dropObject(objectName, type) {
+    const prefix = this.schema ? `"${this.schema}".` : '';
+    let errorCode = -942;
+    if (type === 'materialized view') {
+      // https://stackoverflow.com/a/1801453
+      errorCode = -12003;
+    }
+    this.pushQuery(
+      utils.wrapSqlWithCatch(
+        `drop ${type} ${prefix}${this.formatter.wrap(objectName)}`,
+        errorCode
+      )
+    );
+
+    // removing the sequence that was possibly generated by increments() column
+    this._dropRelatedSequenceIfExists(objectName);
+  }
+
+  refreshMaterializedView(viewName) {
+    return this.pushQuery({
+      sql: `BEGIN DBMS_MVIEW.REFRESH('${
+        this.schemaNameRaw ? this.schemaNameRaw + '.' : ''
+      }${viewName}'); END;`,
+    });
+  }
+
+  dropMaterializedView(viewName) {
+    this._dropView(viewName, false, true);
+  }
+
+  dropMaterializedViewIfExists(viewName) {
+    this.dropObject(viewName, 'materialized view');
+  }
+}
+
+module.exports = SchemaCompiler_Oracle;

node_modules/knex/lib/dialects/oracle/schema/oracle-tablecompiler.js

@@ -0,0 +1,197 @@
+/* eslint max-len:0 */
+
+const utils = require('../utils');
+const TableCompiler = require('../../../schema/tablecompiler');
+const helpers = require('../../../util/helpers');
+const Trigger = require('./internal/trigger');
+const { isObject } = require('../../../util/is');
+
+// Table Compiler
+// ------
+
+class TableCompiler_Oracle extends TableCompiler {
+  constructor() {
+    super(...arguments);
+  }
+
+  addColumns(columns, prefix) {
+    if (columns.sql.length > 0) {
+      prefix = prefix || this.addColumnsPrefix;
+
+      const columnSql = columns.sql;
+      const alter = this.lowerCase ? 'alter table ' : 'ALTER TABLE ';
+
+      let sql = `${alter}${this.tableName()} ${prefix}`;
+      if (columns.sql.length > 1) {
+        sql += `(${columnSql.join(', ')})`;
+      } else {
+        sql += columnSql.join(', ');
+      }
+
+      this.pushQuery({
+        sql,
+        bindings: columns.bindings,
+      });
+    }
+  }
+
+  // Compile a rename column command.
+  renameColumn(from, to) {
+    // Remove quotes around tableName
+    const tableName = this.tableName().slice(1, -1);
+    const trigger = new Trigger(this.client.version);
+    return this.pushQuery(
+      trigger.renameColumnTrigger(this.client.logger, tableName, from, to)
+    );
+  }
+
+  compileAdd(builder) {
+    const table = this.formatter.wrap(builder);
+    const columns = this.prefixArray('add column', this.getColumns(builder));
+    return this.pushQuery({
+      sql: `alter table ${table} ${columns.join(', ')}`,
+    });
+  }
+
+  // Adds the "create" query to the query sequence.
+  createQuery(columns, ifNot, like) {
+    const columnsSql =
+      like && this.tableNameLike()
+        ? ' as (select * from ' + this.tableNameLike() + ' where 0=1)'
+        : ' (' + columns.sql.join(', ') + this._addChecks() + ')';
+    const sql = `create table ${this.tableName()}${columnsSql}`;
+
+    this.pushQuery({
+      // catch "name is already used by an existing object" for workaround for "if not exists"
+      sql: ifNot ? utils.wrapSqlWithCatch(sql, -955) : sql,
+      bindings: columns.bindings,
+    });
+    if (this.single.comment) this.comment(this.single.comment);
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
+  }
+
+  // Compiles the comment on the table.
+  comment(comment) {
+    this.pushQuery(`comment on table ${this.tableName()} is '${comment}'`);
+  }
+
+  dropColumn() {
+    const columns = helpers.normalizeArr.apply(null, arguments);
+    this.pushQuery(
+      `alter table ${this.tableName()} drop (${this.formatter.columnize(
+        columns
+      )})`
+    );
+  }
+
+  _indexCommand(type, tableName, columns) {
+    const nameHelper = new utils.NameHelper(this.client.version);
+    return this.formatter.wrap(
+      nameHelper.generateCombinedName(
+        this.client.logger,
+        type,
+        tableName,
+        columns
+      )
+    );
+  }
+
+  primary(columns, constraintName) {
+    let deferrable;
+    if (isObject(constraintName)) {
+      ({ constraintName, deferrable } = constraintName);
+    }
+    deferrable = deferrable ? ` deferrable initially ${deferrable}` : '';
+    constraintName = constraintName
+      ? this.formatter.wrap(constraintName)
+      : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
+    const primaryCols = columns;
+    let incrementsCols = [];
+    if (this.grouped.columns) {
+      incrementsCols = this._getIncrementsColumnNames();
+      if (incrementsCols) {
+        incrementsCols.forEach((c) => {
+          if (!primaryCols.includes(c)) {
+            primaryCols.unshift(c);
+          }
+        });
+      }
+    }
+    this.pushQuery(
+      `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
+        primaryCols
+      )})${deferrable}`
+    );
+  }
+
+  dropPrimary(constraintName) {
+    constraintName = constraintName
+      ? this.formatter.wrap(constraintName)
+      : this.formatter.wrap(this.tableNameRaw + '_pkey');
+    this.pushQuery(
+      `alter table ${this.tableName()} drop constraint ${constraintName}`
+    );
+  }
+
+  index(columns, indexName) {
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('index', this.tableNameRaw, columns);
+    this.pushQuery(
+      `create index ${indexName} on ${this.tableName()}` +
+        ' (' +
+        this.formatter.columnize(columns) +
+        ')'
+    );
+  }
+
+  dropIndex(columns, indexName) {
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('index', this.tableNameRaw, columns);
+    this.pushQuery(`drop index ${indexName}`);
+  }
+
+  unique(columns, indexName) {
+    let deferrable;
+    if (isObject(indexName)) {
+      ({ indexName, deferrable } = indexName);
+    }
+    deferrable = deferrable ? ` deferrable initially ${deferrable}` : '';
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('unique', this.tableNameRaw, columns);
+    this.pushQuery(
+      `alter table ${this.tableName()} add constraint ${indexName}` +
+        ' unique (' +
+        this.formatter.columnize(columns) +
+        ')' +
+        deferrable
+    );
+  }
+
+  dropUnique(columns, indexName) {
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('unique', this.tableNameRaw, columns);
+    this.pushQuery(
+      `alter table ${this.tableName()} drop constraint ${indexName}`
+    );
+  }
+
+  dropForeign(columns, indexName) {
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('foreign', this.tableNameRaw, columns);
+    this.pushQuery(
+      `alter table ${this.tableName()} drop constraint ${indexName}`
+    );
+  }
+}
+
+TableCompiler_Oracle.prototype.addColumnsPrefix = 'add ';
+TableCompiler_Oracle.prototype.alterColumnsPrefix = 'modify ';
+
+module.exports = TableCompiler_Oracle;