sequelize/lib/dialects/oracle/data-types.js

Sequelize is a promise-based Node.js ORM tool for Postgres, MySQL, MariaDB, SQLite, Microsoft SQL Server, Amazon Redshift and Snowflake’s Data Cloud. It features solid transaction support, relations, eager and lazy loading, read replication and more.

"use strict";
const moment = require("moment");
const momentTz = require("moment-timezone");
module.exports = (BaseTypes) => {
  const warn = BaseTypes.ABSTRACT.warn.bind(void 0, "https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-D424D23B-0933-425F-BC69-9C0E6724693C");
  BaseTypes.DATE.types.oracle = ["TIMESTAMP", "TIMESTAMP WITH LOCAL TIME ZONE"];
  BaseTypes.STRING.types.oracle = ["VARCHAR2", "NVARCHAR2"];
  BaseTypes.CHAR.types.oracle = ["CHAR", "RAW"];
  BaseTypes.TEXT.types.oracle = ["CLOB"];
  BaseTypes.TINYINT.types.oracle = ["NUMBER"];
  BaseTypes.SMALLINT.types.oracle = ["NUMBER"];
  BaseTypes.MEDIUMINT.types.oracle = ["NUMBER"];
  BaseTypes.INTEGER.types.oracle = ["INTEGER"];
  BaseTypes.BIGINT.types.oracle = ["NUMBER"];
  BaseTypes.FLOAT.types.oracle = ["BINARY_FLOAT"];
  BaseTypes.DATEONLY.types.oracle = ["DATE"];
  BaseTypes.BOOLEAN.types.oracle = ["CHAR(1)"];
  BaseTypes.BLOB.types.oracle = ["BLOB"];
  BaseTypes.DECIMAL.types.oracle = ["NUMBER"];
  BaseTypes.UUID.types.oracle = ["VARCHAR2"];
  BaseTypes.ENUM.types.oracle = ["VARCHAR2"];
  BaseTypes.REAL.types.oracle = ["BINARY_DOUBLE"];
  BaseTypes.DOUBLE.types.oracle = ["BINARY_DOUBLE"];
  BaseTypes.JSON.types.oracle = ["BLOB"];
  BaseTypes.GEOMETRY.types.oracle = false;
  class STRING extends BaseTypes.STRING {
    toSql() {
      if (this.length > 4e3 || this._binary && this._length > 2e3) {
        warn("Oracle supports length up to 32764 bytes or characters; Be sure that your administrator has extended the MAX_STRING_SIZE parameter. Check https://docs.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-7B72E154-677A-4342-A1EA-C74C1EA928E6");
      }
      if (!this._binary) {
        return `NVARCHAR2(${this._length})`;
      }
      return `RAW(${this._length})`;
    }
    _stringify(value, options) {
      if (this._binary) {
        return options.escape(value.toString("hex"));
      }
      return options.escape(value);
    }
    _getBindDef(oracledb) {
      if (this._binary) {
        return { type: oracledb.DB_TYPE_RAW, maxSize: this._length };
      }
      return { type: oracledb.DB_TYPE_VARCHAR, maxSize: this._length };
    }
    _bindParam(value, options) {
      return options.bindParam(value);
    }
  }
  STRING.prototype.escape = false;
  class BOOLEAN extends BaseTypes.BOOLEAN {
    toSql() {
      return "CHAR(1)";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_CHAR, maxSize: 1 };
    }
    _stringify(value) {
      return value === true ? "1" : value === false ? "0" : value;
    }
    _sanitize(value) {
      if (typeof value === "string") {
        return value === "1" || value === "true" ? true : value === "0" || value === "false" ? false : value;
      }
      return super._sanitize(value);
    }
  }
  class UUID extends BaseTypes.UUID {
    toSql() {
      return "VARCHAR2(36)";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_VARCHAR, maxSize: 36 };
    }
  }
  class NOW extends BaseTypes.NOW {
    toSql() {
      return "SYSDATE";
    }
    _stringify() {
      return "SYSDATE";
    }
  }
  class ENUM extends BaseTypes.ENUM {
    toSql() {
      return "VARCHAR2(512)";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_VARCHAR, maxSize: 512 };
    }
  }
  class TEXT extends BaseTypes.TEXT {
    toSql() {
      return "CLOB";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_CLOB };
    }
  }
  class CHAR extends BaseTypes.CHAR {
    toSql() {
      if (this._binary) {
        warn("Oracle CHAR.BINARY datatype is not of Fixed Length.");
        return `RAW(${this._length})`;
      }
      return super.toSql();
    }
    _getBindDef(oracledb) {
      if (this._binary) {
        return { type: oracledb.DB_TYPE_RAW, maxSize: this._length };
      }
      return { type: oracledb.DB_TYPE_CHAR, maxSize: this._length };
    }
    _bindParam(value, options) {
      return options.bindParam(value);
    }
  }
  class DATE extends BaseTypes.DATE {
    toSql() {
      return "TIMESTAMP WITH LOCAL TIME ZONE";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_TIMESTAMP_LTZ };
    }
    _stringify(date, options) {
      const format = "YYYY-MM-DD HH24:MI:SS.FFTZH:TZM";
      date = this._applyTimezone(date, options);
      const formatedDate = date.format("YYYY-MM-DD HH:mm:ss.SSS Z");
      return `TO_TIMESTAMP_TZ('${formatedDate}','${format}')`;
    }
    _applyTimezone(date, options) {
      if (options.timezone) {
        if (momentTz.tz.zone(options.timezone)) {
          date = momentTz(date).tz(options.timezone);
        } else {
          date = moment(date).utcOffset(options.timezone);
        }
      } else {
        date = momentTz(date);
      }
      return date;
    }
    static parse(value, options) {
      if (value === null) {
        return value;
      }
      if (options && moment.tz.zone(options.timezone)) {
        value = moment.tz(value.toString(), options.timezone).toDate();
      }
      return value;
    }
    _bindParam(value, options) {
      return options.bindParam(value);
    }
  }
  DATE.prototype.escape = false;
  class DECIMAL extends BaseTypes.DECIMAL {
    toSql() {
      let result = "";
      if (this._length) {
        result += `(${this._length}`;
        if (typeof this._decimals === "number") {
          result += `,${this._decimals}`;
        }
        result += ")";
      }
      if (!this._length && this._precision) {
        result += `(${this._precision}`;
        if (typeof this._scale === "number") {
          result += `,${this._scale}`;
        }
        result += ")";
      }
      return `NUMBER${result}`;
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
  }
  class TINYINT extends BaseTypes.TINYINT {
    toSql() {
      return "NUMBER(3)";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
  }
  class SMALLINT extends BaseTypes.SMALLINT {
    toSql() {
      if (this._length) {
        return `NUMBER(${this._length},0)`;
      }
      return "SMALLINT";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
  }
  class MEDIUMINT extends BaseTypes.MEDIUMINT {
    toSql() {
      return "NUMBER(8)";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
  }
  class BIGINT extends BaseTypes.BIGINT {
    constructor(length) {
      super(length);
      if (!(this instanceof BIGINT))
        return new BIGINT(length);
      BaseTypes.BIGINT.apply(this, arguments);
      if (this._length || this.options.length || this._unsigned || this._zerofill) {
        warn("Oracle does not support BIGINT with options");
        this._length = void 0;
        this.options.length = void 0;
        this._unsigned = void 0;
        this._zerofill = void 0;
      }
    }
    toSql() {
      return "NUMBER(19)";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
    _sanitize(value) {
      if (typeof value === "bigint" || typeof value === "number") {
        return value.toString();
      }
      return value;
    }
  }
  class NUMBER extends BaseTypes.NUMBER {
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
  }
  class INTEGER extends BaseTypes.INTEGER {
    toSql() {
      if (this._length) {
        return `NUMBER(${this._length},0)`;
      }
      return "INTEGER";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_NUMBER };
    }
  }
  class FLOAT extends BaseTypes.FLOAT {
    toSql() {
      return "BINARY_FLOAT";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_BINARY_FLOAT };
    }
  }
  class REAL extends BaseTypes.REAL {
    toSql() {
      return "BINARY_DOUBLE";
    }
    _stringify(value) {
      if (value === Number.POSITIVE_INFINITY) {
        return "inf";
      }
      if (value === Number.NEGATIVE_INFINITY) {
        return "-inf";
      }
      return value;
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_BINARY_DOUBLE };
    }
  }
  class BLOB extends BaseTypes.BLOB {
    _hexify(hex) {
      return `'${hex}'`;
    }
    toSql() {
      return "BLOB";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_BLOB };
    }
  }
  class JSONTYPE extends BaseTypes.JSON {
    toSql() {
      return "BLOB";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_BLOB };
    }
    _stringify(value, options) {
      return options.operation === "where" && typeof value === "string" ? value : JSON.stringify(value);
    }
    _bindParam(value, options) {
      return options.bindParam(Buffer.from(JSON.stringify(value)));
    }
  }
  class DOUBLE extends BaseTypes.DOUBLE {
    constructor(length, decimals) {
      super(length, decimals);
      if (!(this instanceof DOUBLE))
        return new BaseTypes.DOUBLE(length, decimals);
      BaseTypes.DOUBLE.apply(this, arguments);
      if (this._length || this._unsigned || this._zerofill) {
        warn("Oracle does not support DOUBLE with options.");
        this._length = void 0;
        this.options.length = void 0;
        this._unsigned = void 0;
        this._zerofill = void 0;
      }
      this.key = "DOUBLE PRECISION";
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_BINARY_DOUBLE };
    }
    toSql() {
      return "BINARY_DOUBLE";
    }
  }
  class DATEONLY extends BaseTypes.DATEONLY {
    parse(value) {
      return moment(value).format("YYYY-MM-DD");
    }
    _sanitize(value) {
      if (value) {
        return moment(value).format("YYYY-MM-DD");
      }
      return value;
    }
    _stringify(date, options) {
      if (date) {
        const format = "YYYY/MM/DD";
        return options.escape(`TO_DATE('${date}','${format}')`);
      }
      return options.escape(date);
    }
    _getBindDef(oracledb) {
      return { type: oracledb.DB_TYPE_DATE };
    }
    _bindParam(value, options) {
      if (typeof value === "string") {
        return options.bindParam(new Date(value));
      }
      return options.bindParam(value);
    }
  }
  DATEONLY.prototype.escape = false;
  return {
    BOOLEAN,
    "DOUBLE PRECISION": DOUBLE,
    DOUBLE,
    STRING,
    TINYINT,
    SMALLINT,
    MEDIUMINT,
    BIGINT,
    NUMBER,
    INTEGER,
    FLOAT,
    UUID,
    DATEONLY,
    DATE,
    NOW,
    BLOB,
    ENUM,
    TEXT,
    CHAR,
    JSON: JSONTYPE,
    REAL,
    DECIMAL
  };
};
//# sourceMappingURL=data-types.js.map