feat(oracle): Vector datatype support

package.json

@@ -109,7 +109,7 @@
     "mysql2": "^2.3.3",
     "node-hook": "^1.0.0",
     "nyc": "^15.1.0",
-    "oracledb": "^5.5.0",
+    "oracledb": "6.6.0",
     "p-map": "^4.0.0",
     "p-props": "^4.0.0",
     "p-settle": "^4.1.1",

src/data-types.d.ts

@@ -614,5 +614,10 @@ export const CITEXT: AbstractDataTypeConstructor;
  */
 export const TSVECTOR: AbstractDataTypeConstructor;
 
+/**
+ * VECTOR. Only available in Oracle Database.
+ */
+export const VECTOR: AbstractDataTypeConstructor;
+
 // umzug compatibility
 export type DataTypeAbstract = AbstractDataTypeConstructor;

src/data-types.js

@@ -957,6 +957,22 @@ class TSVECTOR extends ABSTRACT {
   }
 }
 
+/**
+ * The VECTOR type stores vectors.
+ *
+ * Only available for Oracle Database >= 23ai
+ *
+ */
+class VECTOR extends ABSTRACT {
+  constructor(dimension, format) {
+    super();
+    const options = typeof dimension === 'object' && dimension || { dimension, format };
+    this.options = options;
+    this._format = options.format;
+    this._length = options.dimension;
+  }
+}
+
 /**
  * A convenience class holding commonly used data types. The data types are used when defining a new model using `Sequelize.define`, like this:
  * ```js
@@ -1041,7 +1057,8 @@ const DataTypes = module.exports = {
   INET,
   MACADDR,
   CITEXT,
-  TSVECTOR
+  TSVECTOR,
+  VECTOR
 };
 
 _.each(DataTypes, (dataType, name) => {

src/dialects/oracle/data-types.js

@@ -2,8 +2,10 @@
 
 'use strict';
 
+const util = require('util');
 const moment = require('moment');
 const momentTz = require('moment-timezone');
+const sequelizeErrors = require('../../errors');
 
 module.exports = BaseTypes => {
   const warn = BaseTypes.ABSTRACT.warn.bind(
@@ -30,6 +32,7 @@ module.exports = BaseTypes => {
   BaseTypes.REAL.types.oracle = ['BINARY_DOUBLE'];
   BaseTypes.DOUBLE.types.oracle = ['BINARY_DOUBLE'];
   BaseTypes.JSON.types.oracle = ['BLOB'];
+  BaseTypes.VECTOR.types.oracle = ['VECTOR'];
   BaseTypes.GEOMETRY.types.oracle = false;
 
   class STRING extends BaseTypes.STRING {
@@ -459,6 +462,38 @@ module.exports = BaseTypes => {
 
   DATEONLY.prototype.escape = false;
 
+  class VECTOR extends BaseTypes.VECTOR {
+    toSql() {
+      if (this._length && this._format) {
+        return `VECTOR(${this._length}, ${this._format.toUpperCase()})`;
+      }
+      if (this._length) {
+        return `VECTOR(${this._length}, *)`;
+      }
+
+      return 'VECTOR';
+    }
+
+    validate(value) {
+      // BYTES_PER_ELEMENT is static property only available in typedArrays. 
+      if (!value.constructor.BYTE_PER_ELEMENT || !Array.isArray(value)) {
+        throw new sequelizeErrors.ValidationError(util.format('%j is not a valid array', value));
+      }
+      return true;
+    }
+
+    _stringify(value, options) {
+      if (Array.isArray(value)) {
+        return Float64Array.from(value, val => val);
+      }
+      return value;
+    }
+
+    _getBindDef(oracledb) {
+      return { type: oracledb.DB_TYPE_VECTOR };
+    }
+  }
+
   return {
     BOOLEAN,
     'DOUBLE PRECISION': DOUBLE,
@@ -481,6 +516,7 @@ module.exports = BaseTypes => {
     CHAR,
     JSON: JSONTYPE,
     REAL,
-    DECIMAL
+    DECIMAL,
+    VECTOR
   };
 };

src/dialects/oracle/index.js

@@ -36,8 +36,9 @@ OracleDialect.prototype.supports = _.merge(_.cloneDeep(AbstractDialect.prototype
     collate: false,
     length: false,
     parser: false,
-    type: false,
-    using: false
+    type: true,
+    operator: false,
+    using: true
   },
   constraints: {
     restrict: false

src/dialects/oracle/query-generator.js

@@ -7,6 +7,7 @@ const DataTypes = require('../../data-types');
 const AbstractQueryGenerator = require('../abstract/query-generator');
 const _ = require('lodash');
 const util = require('util');
+const Model = require('../../model');
 const Transaction = require('../../transaction');
 
 /**
@@ -387,7 +388,114 @@ export class OracleQueryGenerator extends AbstractQueryGenerator {
     if (typeof tableName !== 'string' && attributes.name) {
       attributes.name = `${tableName.schema}.${attributes.name}`;
     }
-    return super.addIndexQuery(tableName, attributes, options, rawTablename);
+
+    options = options || {};
+
+    if (!Array.isArray(attributes)) {
+      options = attributes;
+      attributes = undefined;
+    } else {
+      options.fields = attributes;
+    }
+
+    options.prefix = options.prefix || rawTablename || tableName;
+    if (options.prefix && typeof options.prefix === 'string') {
+      options.prefix = options.prefix.replace(/\./g, '_');
+      options.prefix = options.prefix.replace(/("|')/g, '');
+    }
+
+    const fieldsSql = options.fields.map(field => {
+      if (field instanceof Utils.SequelizeMethod) {
+        return this.handleSequelizeMethod(field);
+      }
+      if (typeof field === 'string') {
+        field = {
+          name: field
+        };
+      }
+      let result = '';
+
+      if (field.attribute) {
+        field.name = field.attribute;
+      }
+
+      if (!field.name) {
+        throw new Error(`The following index field has no name: ${util.inspect(field)}`);
+      }
+
+      result += this.quoteIdentifier(field.name);
+
+      if (field.order) {
+        result += ` ${field.order}`;
+      }
+
+      return result;
+    });
+
+    if (!options.name) {
+      // Mostly for cases where addIndex is called directly by the user without an options object (for example in migrations)
+      // All calls that go through sequelize should already have a name
+      options = Utils.nameIndex(options, options.prefix);
+    }
+
+    options = Model._conformIndex(options);
+
+    if (typeof tableName === 'string') {
+      tableName = this.quoteIdentifiers(tableName);
+    } else {
+      tableName = this.quoteTable(tableName);
+    }
+
+    let ind = ['CREATE'];
+
+    if (options.type === 'VECTOR') {
+      let idxParameter = 'PARAMETERS (type ';
+      options.using = options.using || 'hnsw';
+      if (options.parameter) {
+        if (options.using === 'hnsw') {
+          idxParameter += 'hnsw';
+          if (options.parameter.neighbor) {
+            idxParameter += `, neighbor ${options.parameter.neighbor}`; 
+          }
+          if (options.parameter.efconstruction) {
+            idxParameter += `, efconstruction ${options.parameter.efconstruction}`;
+          }
+        } else {
+          idxParameter += 'ivf';
+          if (options.parameter.partitions) {
+            idxParameter += `, NEIGHBOR PARTITION ${options.parameter.partitions}`;
+          }
+          if (options.parameter.samplesPerPartition) {
+            idxParameter += `, SAMPLES_PER_PARTITION ${options.parameter.samplesPerPartition}`;
+          }
+          if (options.parameter.minVectors) {
+            idxParameter += `, MIN_VECORS_PER_PARTITIONS ${options.parameter.minVectors}`;
+          }
+        }
+        idxParameter += ')';
+      }
+      ind = ind.concat(
+        options.type, 'INDEX',
+        this.quoteIdentifiers(options.name),
+        `ON ${tableName}`,
+        `(${fieldsSql.join(', ')})`,
+        'ORAGANIZATION ',
+        options.using === 'hnsw' ? 'INMEMORY NEIGHBOR GRAPH ' : 'NEIGHBOR PARTITION GRAPH ',
+        options.distance ? `WITH DISTANCE ${options.distance}` : '',
+        options.accuracy ? `WITH TARGET ACCURACY ${options.accuracy}` : '',
+        options.parameter ? idxParameter : ''
+      );
+    } else {
+      ind = ind.concat(
+        options.unique ? 'UNIQUE' : '',
+        'INDEX',
+        this.quoteIdentifiers(options.name),
+        `ON ${tableName}`,
+        `(${fieldsSql.join(', ')})`
+      );
+    }
+
+    return _.compact(ind).join(' ');
   }
 
   addConstraintQuery(tableName, options) {
@@ -1137,6 +1245,35 @@ export class OracleQueryGenerator extends AbstractQueryGenerator {
         }
       }
     }
+    const vectorFunctions = [
+      'COSINE_DISTANCE',
+      'INNER_PRODUCT',
+      'L1_DISTANCE',
+      'L2_DISTANCE',
+      'VECTOR_DISTANCE'
+    ];
+    if (smth instanceof Utils.Fn && vectorFunctions.includes(smth.fn)) {
+      if (smth.args.length > 2) {
+        throw new Error('Too many arguments passed to similarity search function');
+      }
+
+      if (typeof smth.args[1] === 'string') {
+        if (!smth.args[1].startsWith('VECTOR')) {
+          throw new Error('Unexpected second argument');
+        }
+      } else if (!Array.isArray(smth.args[1])) {
+        throw new Error('Unexpected second argument');
+      }
+      // The first argument is expected to be column name
+      // The second argument is expected to be array.
+      smth.args[0] = this.quoteIdentifier(smth.args[0]);
+      if (Array.isArray(smth.args[1])) {
+        smth.args[1] = `VECTOR('[${smth.args[1]}]')`;
+      }
+      return `${smth.fn}(${
+        smth.args.join(', ')
+      })`;
+    }
     return super.handleSequelizeMethod(smth, tableName, factory, options, prepend);
   }
 

src/index.mjs

@@ -56,6 +56,7 @@ export const INET = Pkg.INET;
 export const MACADDR = Pkg.MACADDR;
 export const CITEXT = Pkg.CITEXT;
 export const TSVECTOR = Pkg.TSVECTOR;
+export const VECTOR = Pkg.VECTOR;
 
 // export * from './lib/model';
 export const Model = Pkg.Model;

src/sequelize.js

@@ -990,6 +990,81 @@ class Sequelize {
     return this.fn('RAND');
   }
 
+  /**
+   * Generates the cosineDistance clause for Vector Columns
+   * 
+   * @param {string} column 
+   * @param {Array} value 
+   * 
+   * @returns {Sequelize.fn}
+   */
+  cosineDistance(column, value) {
+    if (['oracle'].includes(this.getDialect())) {
+      return this.fn('COSINE_DISTANCE', column, value);
+    }
+    throw new Error(`cosineDistance for Dialect "${this.getDialect()}" is not implemented`);
+  }
+
+  /**
+   * Generates the innerProduct clause for Vector Columns
+   * 
+   * @param {string} column 
+   * @param {Array} value 
+   * 
+   * @returns {Sequelize.fn}
+   */
+  innerProduct(column, value) {
+    if (['oracle'].includes(this.getDialect())) {
+      return this.fn('INNER_PRODUCT', column, value);
+    }
+    throw new Error(`innerProduct for Dialect "${this.getDialect()}" is not implemented`);
+  }
+
+  /**
+   * Generates the l1Distance clause for Vector Columns
+   * 
+   * @param {string} column 
+   * @param {Array} value 
+   * 
+   * @returns {Sequelize.fn}
+   */
+  l1Distance(column, value) {
+    if (['oracle'].includes(this.getDialect())) {
+      return this.fn('L1_DISTANCE', column, value);
+    }
+    throw new Error(`l1Distance for Dialect "${this.getDialect()}" is not implemented`);
+  }
+
+  /**
+   * Generates the cl2Distance clause for Vector Columns
+   * 
+   * @param {string} column 
+   * @param {Array} value 
+   * 
+   * @returns {Sequelize.fn}
+   */
+  l2Distance(column, value) {
+    if (['oracle'].includes(this.getDialect())) {
+      return this.fn('L2_DISTANCE', column, value);
+    }
+    throw new Error(`l2Distance for Dialect "${this.getDialect()}" is not implemented`);
+  }
+
+  /**
+   * Generates the vectorDistance clause for Vector Columns
+   * 
+   * @param {string} column 
+   * @param {Array} value 
+   * 
+   * @returns {Sequelize.fn}
+   */
+  vectorDistance(column, value) {
+    if (['oracle'].includes(this.getDialect())) {
+      return this.fn('VECTOR_DISTANCE', column, value);
+    }
+    throw new Error(`vectorDistance for Dialect "${this.getDialect()}" is not implemented`);
+  }
+
   /**
    * Creates an object representing a database function. This can be used in search queries, both in where and order parts, and as default values in column definitions.
    * If you want to refer to columns in your function, you should use `sequelize.col`, so that the columns are properly interpreted as columns and not a strings.