mythix-orm-sql-base 1.9.2 → 1.9.3

package/lib/sql-connection-base.js

@@ -661,18 +661,18 @@ class SQLConnectionBase extends ConnectionBase {
     queryEngine = await this.finalizeQuery('read', queryEngine, options);
     queryEngine = queryEngine.clone();
 
-    let queryContext  = queryEngine.getOperationContext();
-    let distinct      = queryContext.distinct;
-    if (distinct) {
-      let fullyQualifiedFieldName = distinct.getFullyQualifiedFieldName();
-
-      if (fullyQualifiedFieldName) {
-        let LiteralConstructor = literal.constructor;
-        literal = new LiteralConstructor(fullyQualifiedFieldName);
-
-        queryEngine = queryEngine.DISTINCT(false).PROJECT(literal);
-      }
-    }
+    // let queryContext  = queryEngine.getOperationContext();
+    // let distinct      = queryContext.distinct;
+    // if (distinct) {
+    //   let fullyQualifiedFieldName = distinct.getFullyQualifiedFieldName();
+
+    //   if (fullyQualifiedFieldName) {
+    //     let LiteralConstructor = literal.constructor;
+    //     literal = new LiteralConstructor(fullyQualifiedFieldName);
+
+    //     queryEngine = queryEngine.DISTINCT(false).PROJECT(literal);
+    //   }
+    // }
 
     let literalStr      = literal.toString(this);
     let queryGenerator  = this.getQueryGenerator();

package/lib/sql-query-generator-base.d.ts

@@ -1,4 +1,4 @@
-import { Field, FieldOrderInfo, JoinTableInfo, Model, ModelClass, PreparedModels, QueryEngine, QueryGeneratorBase } from 'mythix-orm';
+import { Field, Model, ModelClass, PreparedModels, QueryEngine, QueryGeneratorBase } from 'mythix-orm';
 import { LiteralBase } from 'mythix-orm/lib/connection/literals';
 import { GenericObject } from 'mythix-orm/lib/interfaces/common';
 import { Type } from 'mythix-orm/lib/types';
@@ -11,7 +11,61 @@ export declare interface QueryConditionContext {
   value: any;
 }
 
+export declare interface GetEscapedFieldNameOptions {
+  fieldNameOnly?: boolean;
+}
+
+export declare interface GetEscapedTableNameNameOptions {
+  tableNamePrefix?: string;
+}
+
+export declare interface GetEscapedColumnNameOptions extends GetEscapedTableNameNameOptions {
+  columnNamePrefix?: string
+  columnNameOnly?: boolean;
+}
+
+export declare interface GetEscapedProjectionNameOptions extends GetEscapedColumnNameOptions, GetEscapedFieldNameOptions {
+  noProjectionAliases?: boolean;
+}
+
+export declare interface GetEscapedModelFieldsOptions extends GetEscapedProjectionNameOptions {
+  asProjection?: boolean;
+  asColumn?: boolean;
+}
+
+export declare interface JoinTableInfo {
+  operator: string;
+  joinType: string | LiteralBase;
+  rootModelName: string;
+  joinModel: ModelClass;
+  joinModelName: string;
+  leftSideModel: ModelClass;
+  leftSideModelName: string;
+  leftQueryContext: GenericObject;
+  leftSideField: Field;
+  rightSideModel: ModelClass;
+  rightSideModelName: string;
+  rightQueryContext: GenericObject;
+  rightSideField: Field;
+}
+
 declare class SQLQueryGeneratorBase extends QueryGeneratorBase {
+  public getEscapedFieldName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedFieldNameOptions): string;
+  public getEscapedColumnName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedColumnNameOptions): string;
+  public getEscapedTableName(modelOrField: ModelClass | Field, options?: GetEscapedTableNameNameOptions): string;
+  public getEscapedProjectionName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedProjectionNameOptions): string;
+  public getEscapedModelFields(Model: ModelClass, options?: GetEscapedModelFieldsOptions): { [key: string]: string };
+  public isFieldIdentifier(value: string): boolean;
+  public getProjectedFields(queryEngine: QueryEngine, options?: GenericObject, asMap?: false | undefined): Array<string>;
+  public getProjectedFields(queryEngine: QueryEngine, options?: GenericObject, asMap?: true): Map<string, string>;
+
+  public getJoinTableInfoFromQueryContexts(
+    leftQueryContext: GenericObject,
+    rightQueryContext: GenericObject,
+    joinType: string | LiteralBase,
+    options?: GenericObject
+  ): JoinTableInfo;
+
   public prepareArrayValuesForSQL(array: Array<any>): Array<any>;
   public parseFieldProjection(value: string, getRawField: boolean): string | Field | undefined;
   public parseFieldProjectionToFieldMap(selectStatement: string): Map<string, Field | string>;

package/lib/sql-query-generator-base.js

@@ -15,6 +15,296 @@ const DefaultHelpers  = Types.DefaultHelpers;
 const LiteralBase     = Literals.LiteralBase;
 
 class SQLQueryGeneratorBase extends QueryGeneratorBase {
+  getEscapedFieldName(_Model, field, options) {
+    let isString  = Nife.instanceOf(field, 'string');
+    let fieldName = (isString) ? field : field.fieldName;
+    let Model     = _Model;
+
+    if (!Model && field && !isString)
+      Model = field.Model;
+
+    if (!Model || (options && options.fieldNameOnly === true))
+      return this.escapeID(fieldName);
+    else
+      return `"${field.Model.getModelName()}:${fieldName}"`;
+  }
+
+  getEscapedColumnName(_Model, field, options) {
+    let isString    = Nife.instanceOf(field, 'string');
+    let columnName  = (isString) ? field : (field.columnName || field.fieldName);
+    let Model       = _Model;
+
+    if (!Model && field && !isString)
+      Model = field.Model;
+
+    if (options && options.columnNamePrefix)
+      columnName = `${options.columnNamePrefix}${columnName}`;
+
+    if (!Model || (options && options.columnNameOnly === true))
+      return this.escapeID(columnName);
+    else
+      return `${this.getEscapedTableName(Model)}.${this.escapeID(columnName)}`;
+  }
+
+  getEscapedTableName(_modelOrField, options) {
+    let Model     = (_modelOrField.Model) ? _modelOrField.Model : _modelOrField;
+    let tableName = Model.getTableName(this.connection);
+
+    if (options && options.tableNamePrefix)
+      tableName = `${options.tableNamePrefix}${tableName}`;
+
+    return this.escapeID(tableName);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  getEscapedProjectionName(Model, field, options) {
+    if (options && options.noProjectionAliases)
+      return this.getEscapedColumnName(Model, field, options);
+    else
+      return `${this.getEscapedColumnName(Model, field, options)} AS ${(options && options.as) ? this.escapeID(options.as) : this.getEscapedFieldName(Model, field, options)}`;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  getEscapedModelFields(Model, options) {
+    let fields    = {};
+    let modelName = Model.getModelName();
+
+    Model.iterateFields(({ field, fieldName }) => {
+      if (field.type.isVirtual())
+        return;
+
+      let result;
+
+      if (options && options.asProjection)
+        result = this.getEscapedProjectionName(Model, field, options);
+      else if (options && options.asColumn)
+        result = this.getEscapedColumnName(Model, field, options);
+      else
+        result = this.getEscapedFieldName(Model, field, options);
+
+      fields[`${modelName}:${fieldName}`] = result;
+    }, (options && options.fields));
+
+    return fields;
+  }
+
+  isFieldIdentifier(str) {
+    return (/^"[^"]+"."[^"]+"|"\w+:[\w.]+"/i).test(str);
+  }
+
+  getQueryEngineOrder(queryEngine, _options) {
+    let options = _options || {};
+    let context = queryEngine.getOperationContext();
+    let order   = context.order;
+
+    return (order && order.size) ? order : this.connection.getDefaultOrder(context.rootModel, options);
+  }
+
+  getProjectedFields(queryEngine, _options, asMap) {
+    let options               = this.stackAssign(_options || {}, { isProjection: true });
+    let context               = queryEngine.getOperationContext();
+    let queryProjection       = new Map(context.projection);
+    let order                 = this.getQueryEngineOrder(queryEngine, options);
+    let allProjectionFields   = new Map();
+    let allModelsUsedInQuery  = queryEngine.getAllModelsUsedInQuery();
+
+    if (!options.isSubQuery && order && order.size) {
+      let contextOrderSupport = this.connection.isOrderSupportedInContext(options);
+      if (contextOrderSupport) {
+        for (let [ fullyQualifiedFieldName, orderScope ] of order) {
+          if (!queryProjection.has(fullyQualifiedFieldName))
+            queryProjection.set(fullyQualifiedFieldName, orderScope);
+        }
+      }
+    }
+
+    for (let [ fullyQualifiedName, projectedScope ] of queryProjection) {
+      let { value } = projectedScope;
+
+      if (Nife.instanceOf(value, 'string')) {
+        // Raw string is treated as a literal
+        allProjectionFields.set(fullyQualifiedName, value);
+        continue;
+      } else if (LiteralBase.isLiteral(value)) {
+        let result = value.toString(this.connection, options);
+        allProjectionFields.set(result || fullyQualifiedName, result || fullyQualifiedName);
+
+        continue;
+      }
+
+      if (allModelsUsedInQuery.indexOf(value.Model) < 0)
+        continue;
+
+      let escapedFieldName = this.getEscapedProjectionName(value.Model, value, options);
+      allProjectionFields.set(`${value.Model.getModelName()}:${value.fieldName}`, escapedFieldName);
+    }
+
+    if (asMap === true)
+      return allProjectionFields;
+    else
+      return Array.from(allProjectionFields.values());
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  getJoinTableInfoFromQueryContexts(leftQueryContext, rightQueryContext, joinType, options) {
+    let rootModel         = leftQueryContext.rootModel;
+    let rootModelName     = rootModel.getModelName();
+    let leftSideModel     = leftQueryContext.Model;
+    let leftSideModelName = leftQueryContext.modelName;
+    if (!leftSideModel)
+      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No model found for left-side of join statement.`);
+
+    let leftSideField = leftQueryContext.Field;
+    if (!leftSideField)
+      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No left-side field found to match on for table join statement.`);
+
+    let isNot               = leftQueryContext.not;
+    let operator            = (isNot) ? leftQueryContext.inverseOperator : leftQueryContext.operator;
+    let rightSideModel      = rightQueryContext.Model;
+    let rightSideModelName  = rightQueryContext.modelName;
+    if (!rightSideModel)
+      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No model found for right-side of join statement.`);
+
+    let rightSideField = rightQueryContext.Field;
+    if (!rightSideField)
+      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No right-side field found to match on for table join statement.`);
+
+    let swapJoinRelation    = (rightSideModelName === rootModelName);
+    let joinModel           = (swapJoinRelation) ? leftSideModel : rightSideModel;
+    let joinModelName       = (swapJoinRelation) ? leftSideModelName : rightSideModelName;
+
+    return {
+      operator,
+      joinType,
+      rootModelName,
+
+      joinModel,
+      joinModelName,
+
+      leftSideModel,
+      leftSideModelName,
+      leftQueryContext,
+      leftSideField,
+
+      rightSideModel,
+      rightSideModelName,
+      rightQueryContext,
+      rightSideField,
+    };
+  }
+
+  _getLiteralAlias(literal, options) {
+    let as = (literal.options && literal.options.as) || (options && options.as);
+    if (Nife.isEmpty(as))
+      return '';
+
+    return ` AS ${this.escapeID(as)}`;
+  }
+
+  _averageLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    let escapedFieldName;
+
+    if (LiteralBase.isLiteral(field))
+      escapedFieldName = field.toString(this.connection, options);
+    else
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+
+    return `AVG(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+  }
+
+  _countLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    let escapedFieldName;
+
+    if (field) {
+      if (LiteralBase.isLiteral(field))
+        escapedFieldName = field.toString(this.connection, options);
+      else
+        escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+    } else {
+      escapedFieldName = '*';
+    }
+
+    return `COUNT(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+  }
+
+  _distinctLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    if (!field)
+      return 'DISTINCT';
+
+    if (LiteralBase.isLiteral(field))
+      return `DISTINCT ON(${field.toString(this.connection, this.stackAssign(options, { noProjectionAliases: true }))})`;
+
+    return `DISTINCT ON(${this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options, { noProjectionAliases: true }))})`;
+  }
+
+  _fieldLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    if (LiteralBase.isLiteral(field))
+      return field.toString(this.connection, options);
+
+    return this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, { noProjectionAliases: (options && !options.isProjection) }, literal.options));
+  }
+
+  _maxLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    let escapedFieldName;
+
+    if (LiteralBase.isLiteral(field))
+      escapedFieldName = field.toString(this.connection, options);
+    else
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+
+    return `MAX(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+  }
+
+  _minLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    let escapedFieldName;
+
+    if (LiteralBase.isLiteral(field))
+      escapedFieldName = field.toString(this.connection, options);
+    else
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+
+    return `MIN(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+  }
+
+  _sumLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    let escapedFieldName;
+
+    if (LiteralBase.isLiteral(field))
+      escapedFieldName = field.toString(this.connection, options);
+    else
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+
+    return `SUM(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+  }
+
   prepareArrayValuesForSQL(array) {
     return this.connection.prepareArrayValuesForSQL(array);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm-sql-base",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "description": "SQL base support for Mythix ORM",
   "main": "lib/index",
   "type": "commonjs",
@@ -34,7 +34,7 @@
   },
   "homepage": "https://github.com/th317erd/mythix-orm-sql-base#readme",
   "peerDependencies": {
-    "mythix-orm": "^1.11.3"
+    "mythix-orm": "^1.11.4"
   },
   "dependencies": {
     "luxon": "^3.1.0",