mythix-orm-sql-base 1.7.4 → 1.9.0

package/lib/sql-connection-base.d.ts

@@ -2,7 +2,7 @@ import { ConnectionBase, Field, ModelClass, QueryEngine, QueryResults, Model } f
 import { GenericObject } from 'mythix-orm/lib/interfaces/common';
 
 export declare interface ModelDataFromQueryResults {
-  [ key: string ]: Array<GenericObject>;
+  [key: string]: Array<GenericObject>;
 }
 
 declare class SQLConnectionBase extends ConnectionBase {
@@ -20,17 +20,19 @@ declare class SQLConnectionBase extends ConnectionBase {
 
   public enableForeignKeyConstraints(enable: boolean): Promise<void>;
 
-  buildModelsFromModelDataMap(
+  public buildModelsFromModelDataMap(
     queryEngine: QueryEngine,
     modelDataMap: ModelDataFromQueryResults,
     callback: (Model: ModelClass, model: Model) => Model,
   ): Array<Model>;
 
-  updateModelsFromResults(
+  public updateModelsFromResults(
     Model: ModelClass,
     storedModels: Array<Model>,
     results: QueryResults
   ): Array<Model>;
+
+  public getUpdateOrDeleteChangeCount(queryResult: any): number;
 }
 
 export default SQLConnectionBase;

package/lib/sql-connection-base.js

@@ -10,10 +10,14 @@ const {
   Model: ModelBase,
 } = require('mythix-orm');
 
+const SQLQueryGeneratorBase = require('./sql-query-generator-base');
+
 const SAVE_POINT_NAME_CHARS = [ 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' ];
 const MODEL_RELATIONS       = Symbol.for('_mythixModelRelations');
 
 class SQLConnectionBase extends ConnectionBase {
+  static DefaultQueryGenerator = SQLQueryGeneratorBase;
+
   prepareArrayValuesForSQL(_array) {
     let array = Nife.arrayFlatten(_array);
 
@@ -95,13 +99,16 @@ class SQLConnectionBase extends ConnectionBase {
       return true;
     };
 
-    let context         = queryEngine._getRawQueryContext();
+    let context         = queryEngine.getOperationContext();
     let fields          = this.findAllFieldsFromFieldProjectionMap(columns);
     let rootModelName   = context.rootModelName;
     let modelData       = {};
     let alreadyVisited  = {};
 
     let fieldInfo = fields.map((field) => {
+      if (Nife.instanceOf(field, 'string'))
+        return field;
+
       let Model       = field.Model;
       let modelName   = Model.getModelName();
       let pkFieldName = Model.getPrimaryKeyFieldName();
@@ -115,6 +122,9 @@ class SQLConnectionBase extends ConnectionBase {
     });
 
     let modelInfo = fieldInfo.reduce((obj, info) => {
+      if (Nife.instanceOf(info, 'string'))
+        return obj;
+
       obj[info.modelName] = info;
       return obj;
     }, {});
@@ -139,10 +149,24 @@ class SQLConnectionBase extends ConnectionBase {
 
       // Collect row
       for (let j = 0, jl = fieldInfo.length; j < jl; j++) {
-        let {
-          field,
-          modelName,
-        } = fieldInfo[j];
+        let thisFieldInfo = fieldInfo[j];
+        let fieldName;
+        let modelName;
+
+        if (Nife.instanceOf(thisFieldInfo, 'string')) {
+          let def = Utils.parseQualifiedName(thisFieldInfo);
+          if (!def.modelName)
+            continue;
+
+          if (Nife.isEmpty(def.fieldNames))
+            continue;
+
+          modelName = def.modelName;
+          fieldName = def.fieldNames[0];
+        } else {
+          modelName = thisFieldInfo.modelName;
+          fieldName = thisFieldInfo.field.fieldName;
+        }
 
         let dataContext = data[modelName];
         let remoteValue = row[j];
@@ -162,7 +186,7 @@ class SQLConnectionBase extends ConnectionBase {
           });
         }
 
-        dataContext[field.fieldName] = remoteValue;
+        dataContext[fieldName] = remoteValue;
       }
 
       let rootModel;
@@ -234,7 +258,7 @@ class SQLConnectionBase extends ConnectionBase {
     if (Nife.isEmpty(modelDataMap))
       return [];
 
-    let queryContext  = queryEngine._getRawQueryContext();
+    let queryContext  = queryEngine.getOperationContext();
     let rootModelName = queryContext.rootModelName;
     let RootModel     = queryContext.rootModel;
     if (!rootModelName || !RootModel)
@@ -304,6 +328,19 @@ class SQLConnectionBase extends ConnectionBase {
     return storedModels;
   }
 
+  getUpdateOrDeleteChangeCount(queryResult) {
+    if (!queryResult)
+      return 0;
+
+    if ('rows' in queryResult && Array.isArray(queryResult.rows))
+      return queryResult.rows.length;
+
+    if ('changes' in queryResult)
+      return queryResult.changes;
+
+    return 0;
+  }
+
   // --------------------------------------------- //
 
   async dropTable(Model, options) {
@@ -378,7 +415,7 @@ class SQLConnectionBase extends ConnectionBase {
     if (Nife.isEmpty(primaryKeyFieldName))
       throw new Error(`${this.constructor.name}::update: Model has no primary key field.`);
 
-    return await this.bulkModelOperation(
+    let result = await this.bulkModelOperation(
       Model,
       models,
       Object.assign({}, options || {}, { isUpdateOperation: true }),
@@ -398,6 +435,7 @@ class SQLConnectionBase extends ConnectionBase {
             throw new Error(`${this.constructor.name}::update: Model's primary key is empty. Models being updated must have a valid primary key.`);
 
           query = query[primaryKeyFieldName].EQ(pkFieldValue);
+          query = await this.finalizeQuery('update', query, options);
 
           let sqlStr = queryGenerator.generateUpdateStatement(Model, model, query, options);
           if (!sqlStr)
@@ -412,6 +450,8 @@ class SQLConnectionBase extends ConnectionBase {
         await this.runSaveHooks(Model, models, 'onAfterUpdate', 'onAfterSave', options);
       },
     );
+
+    return (Array.isArray(result)) ? result.length : 1;
   }
 
   async updateAll(_queryEngine, model, _options) {
@@ -419,17 +459,16 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new Error(`${this.constructor.name}::updateAll: Model class or query is required to update.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    let options = Object.assign({}, _options || {}, { isUpdateOperation: true });
+    queryEngine = await this.finalizeQuery('update', queryEngine, options);
+
+    let rootModel = queryEngine.getOperationContext().rootModel;
     if (!rootModel)
       throw new Error(`${this.constructor.name}::updateAll: Root model not found, and is required to update.`);
 
-    let options         = Object.assign({}, _options || {}, { isUpdateOperation: true });
     let queryGenerator  = this.getQueryGenerator();
     let sqlStr          = queryGenerator.generateUpdateStatement(rootModel, model, queryEngine, options);
-
-    // TODO: Use "RETURNING" to return pks of of updated rows
-
-    return await this.query(sqlStr, options);
+    return this.getUpdateOrDeleteChangeCount(await this.query(sqlStr, options));
   }
 
   async destroyModels(Model, _models, _options) {
@@ -439,23 +478,24 @@ class SQLConnectionBase extends ConnectionBase {
     let options = _options || {};
     if (_models == null) {
       if (options.truncate !== true)
-        return;
+        return 0;
 
+      let query           = await this.finalizeQuery('delete', Model.where(this).unscoped(), options);
       let queryGenerator  = this.getQueryGenerator();
-      let sqlStr          = queryGenerator.generateDeleteStatement(Model, Model.where(this).unscoped(), options);
+      let sqlStr          = queryGenerator.generateDeleteStatement(Model, query, options);
 
       return await this.query(sqlStr, options);
     }
 
     let models = Nife.toArray(_models).filter(Boolean);
     if (Nife.isEmpty(models))
-      return;
+      return 0;
 
     let primaryKeyFieldName = Model.getPrimaryKeyFieldName();
     if (Nife.isEmpty(primaryKeyFieldName))
       throw new Error(`${this.constructor.name}::destroyModels: Model has no primary key field. You must supply a query to delete models with no primary key.`);
 
-    return await this.bulkModelOperation(
+    let result = await this.bulkModelOperation(
       Model,
       models,
       Object.assign({}, options, { isDeleteOperation: true }),
@@ -478,13 +518,16 @@ class SQLConnectionBase extends ConnectionBase {
         if (Nife.isEmpty(pkIDs))
           return;
 
-        let sqlStr = queryGenerator.generateDeleteStatement(Model, Model.where(this).id.EQ(pkIDs));
+        let query   = await this.finalizeQuery('delete', Model.where(this).id.EQ(pkIDs), options);
+        let sqlStr = queryGenerator.generateDeleteStatement(Model, query);
         if (!sqlStr)
           return;
 
         await this.query(sqlStr, options);
       },
     );
+
+    return (Array.isArray(result)) ? result.length : 1;
   }
 
   async destroy(_queryEngineOrModel, modelsOrOptions, _options) {
@@ -503,14 +546,40 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new Error(`${this.constructor.name}::destroy: Model class or query is required to destroy.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    let options = modelsOrOptions || {};
+    queryEngine = await this.finalizeQuery('delete', queryEngine, options);
+
+    let rootModel = queryEngine.getOperationContext().rootModel;
     if (!rootModel)
       throw new Error(`${this.constructor.name}::destroy: Root model not found, and is required to destroy.`);
 
-    let options         = modelsOrOptions || {};
     let queryGenerator  = this.getQueryGenerator();
     let sqlStr          = queryGenerator.generateDeleteStatement(rootModel, queryEngine, options);
-    return await this.query(sqlStr, options);
+    return this.getUpdateOrDeleteChangeCount(await this.query(sqlStr, options));
+  }
+
+  queryResultRowsToRawData(result) {
+    if (!result)
+      return [];
+
+    let { columns, rows } = result;
+    if (Nife.isEmpty(columns) || Nife.isEmpty(rows))
+      return [];
+
+    let finalData = [];
+    for (let i = 0, il = rows.length; i < il; i++) {
+      let row   = rows[i];
+      let data  = {};
+
+      for (let j = 0, jl = columns.length; j < jl; j++) {
+        let column = columns[j];
+        data[column] = row[j];
+      }
+
+      finalData.push(data);
+    }
+
+    return finalData;
   }
 
   async *select(_queryEngine, _options) {
@@ -525,12 +594,27 @@ class SQLConnectionBase extends ConnectionBase {
         throw new TypeError(`${this.constructor.name}::select: First argument must be a model class or a query.`);
     }
 
-    let queryContext    = queryEngine._getRawQueryContext();
     let options         = _options || {};
-    let batchSize       = options.batchSize || 500;
-    let startIndex      = queryContext.offset || 0;
     let queryGenerator  = this.getQueryGenerator();
 
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
+
+    let queryContext  = queryEngine.getOperationContext();
+    let groupBy       = queryContext.groupBy;
+    if (groupBy && groupBy.size > 0) {
+      let sqlStatement  = queryGenerator.generateSelectStatement(queryEngine, options);
+      let result        = await this.query(sqlStatement, options);
+      let rows          = this.queryResultRowsToRawData(result);
+
+      for (let i = 0, il = rows.length; i < il; i++)
+        yield rows[i];
+
+      return;
+    }
+
+    let batchSize   = options.batchSize || 500;
+    let startIndex  = queryContext.offset || 0;
+
     while (true) {
       let query         = queryEngine.clone().LIMIT(batchSize).OFFSET(startIndex);
       let sqlStatement  = queryGenerator.generateSelectStatement(query, options);
@@ -574,9 +658,10 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new TypeError(`${this.constructor.name}::aggregate: First argument must be a model class or a query.`);
 
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
     queryEngine = queryEngine.clone();
 
-    let queryContext  = queryEngine._getRawQueryContext();
+    let queryContext  = queryEngine.getOperationContext();
     let distinct      = queryContext.distinct;
     if (distinct) {
       let fullyQualifiedFieldName = distinct.getFullyQualifiedFieldName();
@@ -611,7 +696,7 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new TypeError(`${this.constructor.name}::average: First argument must be a model class or a query.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    let rootModel = queryEngine.getOperationContext().rootModel;
     let field     = Utils.fieldToFullyQualifiedName(_field, rootModel);
 
     return await this.aggregate(queryEngine, new Literals.AverageLiteral(field), options);
@@ -622,7 +707,9 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new TypeError(`${this.constructor.name}::count: First argument must be a model class or a query.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
+
+    let rootModel = queryEngine.getOperationContext().rootModel;
     let field     = (_field) ? Utils.fieldToFullyQualifiedName(_field, rootModel) : null;
 
     return await this.aggregate(queryEngine, new Literals.CountLiteral(field), options);
@@ -633,7 +720,9 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new TypeError(`${this.constructor.name}::min: First argument must be a model class or a query.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
+
+    let rootModel = queryEngine.getOperationContext().rootModel;
     let field     = Utils.fieldToFullyQualifiedName(_field, rootModel);
 
     return await this.aggregate(queryEngine, new Literals.MinLiteral(field), options);
@@ -644,7 +733,9 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new TypeError(`${this.constructor.name}::max: First argument must be a model class or a query.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
+
+    let rootModel = queryEngine.getOperationContext().rootModel;
     let field     = Utils.fieldToFullyQualifiedName(_field, rootModel);
 
     return await this.aggregate(queryEngine, new Literals.MaxLiteral(field), options);
@@ -655,7 +746,9 @@ class SQLConnectionBase extends ConnectionBase {
     if (!queryEngine)
       throw new TypeError(`${this.constructor.name}::sum: First argument must be a model class or a query.`);
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
+
+    let rootModel = queryEngine.getOperationContext().rootModel;
     let field     = Utils.fieldToFullyQualifiedName(_field, rootModel);
 
     return await this.aggregate(queryEngine, new Literals.SumLiteral(field), options);
@@ -683,7 +776,9 @@ class SQLConnectionBase extends ConnectionBase {
         throw new TypeError(`${this.constructor.name}::pluck: First argument must be a model class or a query.`);
     }
 
-    let queryContext  = queryEngine._getRawQueryContext();
+    queryEngine = await this.finalizeQuery('read', queryEngine, options);
+
+    let queryContext  = queryEngine.getOperationContext();
     let rootModel     = queryContext.rootModel;
     let rootModelName = rootModel.getModelName();
 

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

@@ -70,10 +70,8 @@ declare class SQLQueryGeneratorBase extends QueryGeneratorBase {
   public sortJoinRelationOrder(joins: Map<string, Array<JoinTableInfo>>): Array<string>;
   public generateSelectQueryJoinTables(queryEngine: QueryEngine, options?: GenericObject): string;
   public generateSelectWhereConditions(queryEngine: QueryEngine, options?: GenericObject): string;
-  public generateOrderClause(
-    orders: LiteralBase | FieldOrderInfo | Array<LiteralBase | FieldOrderInfo>,
-    options?: GenericObject
-  ): string;
+  public generateOrderClause(queryEngine: QueryEngine, options?: GenericObject): string;
+  public generateGroupByClause(queryEngine: QueryEngine, options?: GenericObject): string;
 
   public generateLimitClause(limit: LiteralBase | number | string, options?: GenericObject): string;
   public generateOffsetClause(offset: LiteralBase | number | string, options?: GenericObject): string;
@@ -158,6 +156,7 @@ declare class SQLQueryGeneratorBase extends QueryGeneratorBase {
     options?: GenericObject,
   ): string;
 
+  public generateDeleteStatementReturningClause(Model: ModelClass, queryEngine: QueryEngine, pkField: Field | null, escapedColumnName: string | null, options: GenericObject): string;
   public generateDeleteStatement(Model: ModelClass, queryEngine: QueryEngine, options?: GenericObject): string;
   public generateTruncateTableStatement(Model: ModelClass, options?: GenericObject): string;
   public generateAlterTableStatement(Model: ModelClass, newModelAttributes, options?: GenericObject): string;

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

@@ -90,27 +90,25 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
         projectionFieldMap.set(fieldPart, fieldPart);
     }
 
-    let projectedFieldNames       = Array.from(projectionFieldMap.keys());
-    let sortedFieldNames          = this.sortedProjectedFields(projectedFieldNames);
-    let sortedProjectionFieldMap  = new Map();
-
-    for (let i = 0, il = sortedFieldNames.length; i < il; i++) {
-      let sortedFieldName = sortedFieldNames[i];
-      let value           = projectionFieldMap.get(sortedFieldName);
-
-      sortedProjectionFieldMap.set(sortedFieldName, value);
-    }
-
-    return sortedProjectionFieldMap;
+    return projectionFieldMap;
   }
 
   generateSelectQueryFieldProjection(queryEngine, options, asMap) {
     let projectedFields = this.getProjectedFields(queryEngine, options, asMap);
 
-    if (asMap === true)
+    if (asMap === true) {
       return projectedFields;
-    else
-      return Array.from(projectedFields.values()).join(',');
+    } else {
+      let projectedFieldList = Array.from(projectedFields.values()).join(',');
+
+      let distinct = queryEngine.getOperationContext().distinct;
+      if (distinct) {
+        let result = distinct.toString(this.connection, { isProjection: true });
+        return `${result} ${projectedFieldList}`;
+      }
+
+      return projectedFieldList;
+    }
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -120,23 +118,25 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     switch (operator) {
       case 'EQ':
-        if (!valueIsReference) {
-          if (value === null || value === true || value === false)
-            return 'IS';
-          else if (Array.isArray(value))
-            return 'IN';
-        }
+        if (valueIsReference)
+          return '=';
 
-        return '=';
+        if (value === null || value === true || value === false)
+          return 'IS';
+        else if (Array.isArray(value))
+          return 'IN';
+        else
+          return '=';
       case 'NEQ':
-        if (!valueIsReference) {
-          if (value === null || value === true || value === false)
-            return 'IS NOT';
-          else if (Array.isArray(value))
-            return 'NOT IN';
-        }
+        if (valueIsReference)
+          return '!=';
 
-        return '!=';
+        if (value === null || value === true || value === false)
+          return 'IS NOT';
+        else if (Array.isArray(value))
+          return 'NOT IN';
+        else
+          return '!=';
       case 'GT':
         return '>';
       case 'GTE':
@@ -181,6 +181,9 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     let isNot     = queryPart.not;
     let operator  = (isNot) ? queryPart.inverseOperator : queryPart.operator;
 
+    if (operator === 'EXISTS' || operator === 'NOT EXISTS')
+      return `${operator}(${this.generateSelectStatement(value.clone().PROJECT(new Literals.Literal('1')).LIMIT(1).OFFSET(0), this.stackAssign(options, { isSubQuery: true, subQueryOperator: operator }))})`;
+
     // If the value is an array, then handle the
     // special "IN" case for an array
     if (Array.isArray(value)) {
@@ -227,9 +230,12 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     let sqlOperator       = this.generateSelectQueryOperatorFromQueryEngineOperator(queryPart, operator, value, false, options);
 
     if (QueryEngine.isQuery(value)) {
-      if (!value._queryHasConditions())
+      if (!value.queryHasConditions())
         return '';
 
+      if (Object.prototype.hasOwnProperty.call(queryPart, 'subType') && (queryPart.subType === 'ANY' || queryPart.subType === 'ALL'))
+        return `${escapedColumnName} ${sqlOperator} ${queryPart.subType}(${this.generateSelectStatement(value, this.stackAssign(options, { isSubQuery: true, subQueryOperator: queryPart.subType }))})`;
+
       if (sqlOperator === '=')
         sqlOperator = 'IN';
       else if (sqlOperator === '!=')
@@ -339,7 +345,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       items.push(joinInfo);
     };
 
-    let query = queryEngine._getRawQuery();
+    let query = queryEngine.getOperationStack();
     let joins = new Map();
 
     for (let i = 0, il = query.length; i < il; i++) {
@@ -353,11 +359,11 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
       // If the query has a condition, then it is a sub-query
       // not a join
-      if (operatorValue._getRawQueryContext().condition)
+      if (operatorValue.getOperationContext().condition)
         continue;
 
       let joinType = this.generateSQLJoinTypeFromQueryEngineJoinType(queryPart.joinType, queryPart.joinOuter, options);
-      let joinInfo = this.getJoinTableInfoFromQueryContexts(queryPart, operatorValue._getRawQueryContext(), joinType, options);
+      let joinInfo = this.getJoinTableInfoFromQueryContexts(queryPart, operatorValue.getOperationContext(), joinType, options);
 
       addToJoins(joinInfo);
     }
@@ -391,7 +397,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       return '';
     };
 
-    let query     = queryEngine._getRawQuery();
+    let query     = queryEngine.getOperationStack();
     let sqlParts  = [];
     let hasValue  = false;
 
@@ -452,13 +458,15 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return sqlParts.join(' ');
   }
 
-  // eslint-disable-next-line no-unused-vars
-  generateOrderClause(_orders, _options) {
-    if (LiteralBase.isLiteral(_orders))
-      return _orders.toString(this.connection);
+  generateOrderClause(queryEngine, _options) {
+    if (!queryEngine)
+      return '';
 
-    let orders  = Nife.toArray(_orders).filter(Boolean);
-    if (Nife.isEmpty(orders))
+    if (typeof queryEngine.getOperationContext !== 'function')
+      return '';
+
+    let order = this.getQueryEngineOrder(queryEngine, _options);
+    if (!order || !order.size)
       return '';
 
     let options             = _options || {};
@@ -466,38 +474,44 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (contextOrderSupport === false)
       return '';
 
-    let orderByParts  = [];
-    for (let i = 0, il = orders.length; i < il; i++) {
-      let orderField = orders[i];
+    let allModelsUsedInQuery  = queryEngine.getAllModelsUsedInQuery();
+    let orderByParts          = [];
 
-      if (LiteralBase.isLiteral(orderField)) {
-        let fieldStr = orderField.toString(this.connection);
-        if (!options.projectionFields.has(fieldStr) && contextOrderSupport === 'PROJECTION_ONLY')
-          continue;
+    for (let [ fullyQualifiedFieldName, orderScope ] of order) {
+      let { value, direction } = orderScope;
 
-        orderByParts.push(fieldStr);
-        continue;
+      // Only allow fields that are in our projection
+      if (options.projectionFields && options.onlyProjectedFields !== false) {
+        if (!options.projectionFields.has(fullyQualifiedFieldName) && contextOrderSupport === 'PROJECTION_ONLY')
+          continue;
       }
 
-      // Only allow fields that are in our projection
-      if (options.projectionFields) {
-        let modelName   = orderField.Model.getModelName();
-        let fieldName   = orderField.Field.fieldName;
-        let fqFieldName = `${modelName}:${fieldName}`;
+      let finalResult;
+
+      if (Nife.instanceOf(value, 'string')) {
+        // Raw string is treated as a literal
+        finalResult = value;
+      } else if (LiteralBase.isLiteral(value)) {
+        finalResult = value.toString(this.connection, options);
 
-        if (!options.projectionFields.has(fqFieldName) && contextOrderSupport === 'PROJECTION_ONLY')
+        // fullyQualifiedFieldName is the stringified
+        // literal here.
+        if (options.projectionFields && !options.projectionFields.has(finalResult) && contextOrderSupport === 'PROJECTION_ONLY')
           continue;
+      } else {
+        if (allModelsUsedInQuery.indexOf(value.Model) < 0)
+          continue;
+
+        finalResult = this.getEscapedColumnName(value.Model, value.columnName, options);
       }
 
-      let escapedColumnName = this.getEscapedColumnName(orderField.Model, orderField.Field.columnName, options);
       let orderStr;
-
       if (options.reverseOrder !== true)
-        orderStr = (orderField.direction === '-') ? 'DESC' : 'ASC';
+        orderStr = (direction === '-') ? 'DESC' : 'ASC';
       else
-        orderStr = (orderField.direction === '-') ? 'ASC' : 'DESC';
+        orderStr = (direction === '-') ? 'ASC' : 'DESC';
 
-      orderByParts.push(`${escapedColumnName} ${orderStr}`);
+      orderByParts.push(`${finalResult} ${orderStr}`);
     }
 
     if (Nife.isEmpty(orderByParts))
@@ -506,6 +520,68 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return `ORDER BY ${orderByParts.join(',')}`;
   }
 
+  generateGroupByClause(queryEngine, _options) {
+    if (!queryEngine)
+      return '';
+
+    if (typeof queryEngine.getOperationContext !== 'function')
+      return '';
+
+    let groupBy = queryEngine.getOperationContext().groupBy;
+    if (!groupBy || !groupBy.size)
+      return '';
+
+    let options = _options || {};
+
+    let groupByParts  = [];
+    for (let groupByScope of groupBy.values()) {
+      let { value } = groupByScope;
+      let finalResult;
+
+      if (Nife.instanceOf(value, 'string')) {
+        // Raw string is treated as a literal
+        finalResult = value;
+      } else if (LiteralBase.isLiteral(value)) {
+        finalResult = value.toString(this.connection, options);
+      } else {
+        finalResult = this.getEscapedColumnName(value.Model, value.columnName, options);
+      }
+
+      groupByParts.push(finalResult);
+    }
+
+    if (Nife.isEmpty(groupByParts))
+      return '';
+
+    return `GROUP BY ${groupByParts.join(',')}`;
+  }
+
+  generateHavingClause(queryEngine, options) {
+    let where = this.generateSelectWhereConditions(queryEngine, options);
+    return (where) ? `HAVING (${where})` : '';
+  }
+
+  generateGroupByAndHavingClause(queryEngine, options) {
+    if (!queryEngine)
+      return '';
+
+    let sqlParts          = [];
+    let groupByStatement  = this.generateGroupByClause(queryEngine, options);
+    if (groupByStatement)
+      sqlParts.push(groupByStatement);
+    else
+      return '';
+
+    let having = queryEngine.getOperationContext().having;
+    if (having) {
+      let havingStatement = this.generateHavingClause(having, options);
+      if (havingStatement)
+        sqlParts.push(havingStatement);
+    }
+
+    return sqlParts.join(' ');
+  }
+
   // eslint-disable-next-line no-unused-vars
   generateLimitClause(limit, options) {
     if (LiteralBase.isLiteral(limit))
@@ -523,27 +599,31 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
   }
 
   generateSelectOrderLimitOffset(queryEngine, _options) {
+    if (!queryEngine)
+      return '';
+
     let options = _options || {};
+    let context = queryEngine.getOperationContext();
     let {
       order,
       limit,
       offset,
-    } = this.getOrderLimitOffset(queryEngine, options);
+    } = context;
+
     let sqlParts = [];
     let hasOrder = false;
+    let hasLimit = (Nife.instanceOf(limit, 'number') && isFinite(limit));
 
-    if (Nife.isNotEmpty(order)) {
-      if (this.connection.isOrderSupportedInContext(options)) {
-        let result = this.generateOrderClause(order, options);
-        if (result) {
-          hasOrder = true;
-          sqlParts.push(result);
-        }
+    if (options.orderClause !== false && !(options.orderClauseOnlyIfLimited === true && !hasLimit) && this.connection.isOrderSupportedInContext(options)) {
+      let result = this.generateOrderClause(queryEngine, options);
+      if (result) {
+        hasOrder = true;
+        sqlParts.push(result);
+      }
 
-        if (hasOrder && !(Nife.instanceOf(limit, 'number') && isFinite(limit)) && options && options.forceLimit) {
-          limit = options.forceLimit;
-          offset = 0;
-        }
+      if (hasOrder && !hasLimit && options && options.forceLimit) {
+        limit = options.forceLimit;
+        offset = 0;
       }
     }
 
@@ -578,6 +658,9 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (orderLimitOffset)
       sqlParts.push(orderLimitOffset);
 
+    if (options.separateWhereAndOrder)
+      return { where, orderLimitOffset };
+
     return sqlParts.join(' ');
   }
 
@@ -590,7 +673,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (options.includeRelations === true)
       queryEngine = queryEngine.clone().PROJECT('*');
 
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    let rootModel = queryEngine.getOperationContext().rootModel;
     if (!rootModel)
       throw new Error(`${this.constructor.name}::generateSelectStatement: No root model found.`);
 
@@ -600,11 +683,18 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     options.selectStatement = true;
 
     projectionFields = this.generateSelectQueryFieldProjection(queryEngine, options, true);
-    sqlParts.push(Array.from(projectionFields.values()).join(','));
+    sqlParts.push(this.generateSelectQueryFieldProjection(queryEngine, options));
 
     sqlParts.push(this.generateFromTableOrTableJoin(rootModel, undefined, options));
     sqlParts.push(this.generateSelectQueryJoinTables(queryEngine, options));
-    sqlParts.push(this.generateWhereAndOrderLimitOffset(queryEngine, this.stackAssign(options, { projectionFields })));
+    let { where, orderLimitOffset } = this.generateWhereAndOrderLimitOffset(queryEngine, this.stackAssign(options, { projectionFields, separateWhereAndOrder: true }));
+    if (where)
+      sqlParts.push(`WHERE ${where}`);
+
+    sqlParts.push(this.generateGroupByAndHavingClause(queryEngine, options));
+
+    if (orderLimitOffset)
+      sqlParts.push(orderLimitOffset);
 
     let sql = sqlParts.filter(Boolean).join(' ');
 
@@ -1092,7 +1182,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     let where;
     if (queryEngine) {
-      where = this.generateWhereAndOrderLimitOffset(queryEngine, options);
+      where = this.generateWhereAndOrderLimitOffset(queryEngine, this.stackAssign(options, { orderClauseOnlyIfLimited: true }));
       if (where) {
         if (options.newlines !== false)
           sqlParts.push('\n');
@@ -1122,6 +1212,13 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return sqlParts.join('');
   }
 
+  generateDeleteStatementReturningClause(Model, queryEngine, pkField, escapedColumnName, options) {
+    if (!escapedColumnName)
+      return '';
+
+    return `RETURNING ${escapedColumnName}`;
+  }
+
   generateDeleteStatement(Model, _queryEngine, _options) {
     let queryEngine = _queryEngine;
     let options     = _options;
@@ -1137,10 +1234,11 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       }
     }
 
-    let escapedTableName = this.getEscapedTableName(Model, options);
-    if (queryEngine && queryEngine._queryHasConditions()) {
-      if (queryEngine._queryHasJoins()) {
-        let pkField = Model.getPrimaryKeyField();
+    let escapedTableName  = this.getEscapedTableName(Model, options);
+    let pkField           = Model.getPrimaryKeyField();
+
+    if (queryEngine && queryEngine.queryHasConditions()) {
+      if (queryEngine.queryHasJoins()) {
         if (!pkField)
           throw new Error(`${this.constructor.name}::generateDeleteStatement: Can not delete using table joins on a table with no primary key field.`);
 
@@ -1150,22 +1248,34 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
           queryEngine
             .AND[Model.getModelName(this.connection)][pkField.fieldName]
               .EQ(new Literals.Literal(`${escapedTableNameAlias}.${escapedFieldAlias}`))
-            .PROJECT(new Literals.Literal('1')),
+            .PROJECT(new Literals.Literal('1'))
+            .LIMIT(1)
+            .OFFSET(0),
           this.stackAssign(
             options,
             {
-              isSubQuery:           true,
-              subQueryOperator:     'EXISTS',
-              noProjectionAliases:  true,
-              forceLimit:           4294967295,
+              isSubQuery:          true,
+              subQueryOperator:    'EXISTS',
+              noProjectionAliases: true,
+              forceLimit:          4294967295,
             },
           ),
         );
 
-        return `DELETE FROM ${escapedTableName} AS ${escapedTableNameAlias} WHERE EXISTS (${innerSelect})`;
+        let returningField  = `${escapedTableNameAlias}.${this.getEscapedColumnName(pkField.Model, pkField, this.stackAssign(options, { columnNameOnly: true }))}`;
+        let returningClause = this.generateDeleteStatementReturningClause(Model, queryEngine, pkField, returningField, options);
+
+        return `DELETE FROM ${escapedTableName} AS ${escapedTableNameAlias} WHERE EXISTS (${innerSelect})${(returningClause) ? ` ${returningClause}` : ''}`;
       } else {
-        let where = this.generateWhereAndOrderLimitOffset(queryEngine, { ...options, forceLimit: 4294967295 });
-        return `DELETE FROM ${escapedTableName}${(where) ? ` ${where}` : ''}`;
+        let returningField  = (pkField) ? this.getEscapedColumnName(pkField.Model, pkField, options) : '*';
+        let returningClause = this.generateDeleteStatementReturningClause(Model, queryEngine, pkField, returningField, options);
+
+        let {
+          where,
+          orderLimitOffset,
+        } = this.generateWhereAndOrderLimitOffset(queryEngine, { ...options, forceLimit: 4294967295, separateWhereAndOrder: true });
+
+        return `DELETE FROM ${escapedTableName}${(where) ? ` WHERE ${where}` : ''}${(returningClause) ? ` ${returningClause}` : ''}${(orderLimitOffset) ? ` ${orderLimitOffset}` : ''}`;
       }
     } else {
       return `DELETE FROM ${escapedTableName}`;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "mythix-orm-sql-base",
-  "version": "1.7.4",
+  "version": "1.9.0",
   "description": "SQL base support for Mythix ORM",
   "main": "lib/index",
   "type": "commonjs",
   "scripts": {
     "coverage": "clear ; node ./node_modules/.bin/nyc ./node_modules/.bin/jasmine",
     "test": "node ./node_modules/.bin/jasmine",
+    "test-fast": "node ./node_modules/.bin/jasmine --fail-fast",
     "test-debug": "node --inspect-brk ./node_modules/.bin/jasmine",
     "test-watch": "watch 'clear ; node ./node_modules/.bin/jasmine' . --wait=2 --interval=1"
   },
@@ -33,7 +34,7 @@
   },
   "homepage": "https://github.com/th317erd/mythix-orm-sql-base#readme",
   "peerDependencies": {
-    "mythix-orm": "^1.8.3"
+    "mythix-orm": "^1.11.0"
   },
   "dependencies": {
     "luxon": "^3.1.0",