mythix-orm 1.8.3 → 1.11.0

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

@@ -1,11 +1,8 @@
 'use strict';
 
-const Nife                    = require('nife');
-const QueryEngine             = require('../query-engine/query-engine');
-const Literals                = require('./literals');
-const { Model: ModelBase }    = require('../model');
-const LiteralBase             = Literals.LiteralBase;
-const LITERAL_IS_DISTINCT_RE  = (/^DISTINCT[\s(]/i);
+const Nife        = require('nife');
+const Literals    = require('./literals');
+const LiteralBase = Literals.LiteralBase;
 
 /// The base query generator class.
 ///
@@ -32,14 +29,6 @@ class QueryGeneratorBase {
     return newObj;
   }
 
-  getOptionsCache(options, keyPath, initialValue) {
-    return Nife.get(options, `_cache.${keyPath}`, (typeof initialValue === 'function') ? initialValue() : initialValue);
-  }
-
-  setOptionsCache(options, keyPath, value) {
-    Nife.set(options, `_cache.${keyPath}`, value);
-  }
-
   escape(...args) {
     return this.connection.escape(...args);
   }
@@ -94,7 +83,7 @@ class QueryGeneratorBase {
     if (options && options.noProjectionAliases)
       return this.getEscapedColumnName(Model, field, options);
     else
-      return `${this.getEscapedColumnName(Model, field, options)} AS ${this.getEscapedFieldName(Model, field, options)}`;
+      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
@@ -121,504 +110,55 @@ class QueryGeneratorBase {
     return fields;
   }
 
-  // eslint-disable-next-line no-unused-vars
-  getAllModelsUsedInQuery(queryEngine, _options) {
-    let options               = _options || {};
-    let queryEngineContextID  = queryEngine._getTopContextID();
-    let cache                 = this.getOptionsCache(_options, `getAllModelsUsedInQuery.${queryEngineContextID}`);
-    if (cache)
-      return cache;
-
-    let Models  = new Map();
-    let query   = queryEngine._getRawQuery();
-
-    for (let i = 0, il = query.length; i < il; i++) {
-      let queryPart = query[i];
-
-      if (Object.prototype.hasOwnProperty.call(queryPart, 'operator') && queryPart.operator === 'MODEL') {
-        let Model = queryPart.Model;
-        Models.set(Model, Model);
-      } else if (Object.prototype.hasOwnProperty.call(queryPart, 'condition') && queryPart.condition === true) {
-        let operatorValue = queryPart.value;
-        if (!QueryEngine.isQuery(operatorValue))
-          continue;
-
-        let SubModels = this.getAllModelsUsedInQuery(operatorValue, options);
-        for (let j = 0, jl = SubModels.length; j < jl; j++) {
-          let Model = SubModels[j];
-          Models.set(Model, Model);
-        }
-      }
-    }
-
-    let allModels = Array.from(Models.values());
-
-    if (_options)
-      this.setOptionsCache(_options, `getAllModelsUsedInQuery.${queryEngineContextID}`, allModels);
-
-    return allModels;
-  }
-
-  getProjectionRequiredFields(queryEngine, options) {
-    let { order } = this.getOrderLimitOffset(queryEngine, options);
-    if (!order)
-      return new Map();
-
-    let orderFieldMap = new Map();
-    for (let i = 0, il = order.length; i < il; i++) {
-      let field = order[i];
-      if (!field)
-        continue;
-
-      if (LiteralBase.isLiteral(field)) {
-        let result          = field.toString(this.connection, options);
-        let projectionField;
-
-        if (typeof field.getField === 'function')
-          projectionField = field.getField(this.connection);
-        else
-          projectionField = this.parseFieldProjection(result, true);
-
-        if (projectionField === result) {
-          // not able to parse projection
-          continue;
-        }
-
-        field = projectionField;
-      }
-
-      let Field         = field.Field || field;
-      let Model         = Field.Model;
-      let modelName     = Model.getModelName();
-      let fullFieldName = `${modelName}:${Field.fieldName}`;
-
-      orderFieldMap.set(fullFieldName, {
-        projectedName:  this.getEscapedProjectionName(Model, Field, options),
-        Model:          Model,
-        modelName:      modelName,
-        Field:          Field,
-        fieldName:      Field.fieldName,
-        direction:      '+',
-        fullFieldName,
-      });
-    }
-
-    return orderFieldMap;
+  isFieldIdentifier(str) {
+    return (/^"[^"]+"."[^"]+"|"\w+:[\w.]+"/i).test(str);
   }
 
-  sortedProjectedFields(projectedFields, options) {
-    return projectedFields.sort((a, b) => {
-      // If either value is a distinct literal
-      // then make certain it comes first in
-      // the list of projected fields (required
-      // by some databases)
-      const distinctSortOrder = (a, b) => {
-        let x           = LiteralBase.isLiteral(a);
-        let y           = LiteralBase.isLiteral(b);
-        let xStr        = (x) ? a.toString(this.connection, options) : a;
-        let yStr        = (y) ? b.toString(this.connection, options) : b;
-        let xIsDistinct = (typeof xStr === 'string' && LITERAL_IS_DISTINCT_RE.test(xStr));
-        let yIsDistinct = (typeof yStr === 'string' && LITERAL_IS_DISTINCT_RE.test(yStr));
-
-        if (xIsDistinct || yIsDistinct) {
-          if (xIsDistinct === yIsDistinct)
-            return 0;
-
-          if (xIsDistinct && !yIsDistinct)
-            return -1;
-
-          if (yIsDistinct && !xIsDistinct)
-            return 1;
-        }
-
-        // Neither is a literal, so simply
-        // return and continue processing
-        if (!x && !y)
-          return;
-
-        // We know one of them must be a literal
-        // when a literal is encountered, the
-        // sort order is not modified
-        return 0;
-      };
-
-      let distinctOrder = distinctSortOrder(a, b);
-      if (distinctOrder != null)
-        return distinctOrder;
-
-      let x = (typeof a === 'string') ? a : `${a.modelName}:${a.fieldName}`;
-      let y = (typeof b === 'string') ? b : `${b.modelName}:${b.fieldName}`;
-
-      if (x === y)
-        return 0;
+  getQueryEngineOrder(queryEngine, _options) {
+    let options = _options || {};
+    let context = queryEngine.getOperationContext();
+    let order   = context.order;
 
-      return (x < y) ? -1 : 1;
-    });
+    return (order && order.size) ? order : this.connection.getDefaultOrder(context.rootModel, options);
   }
 
-  getProjectionFromQueryEngine(queryEngine, options) {
-    let queryEngineContextID  = queryEngine._getTopContextID();
-    let cache                 = this.getOptionsCache(options, `getProjectionFromQueryEngine.${queryEngineContextID}`);
-    if (cache)
-      return cache;
-
-    const shouldResetProjection = (fields) => {
-      if (fields.length === 0)
-        return false;
-
-      if (fields.indexOf('+') >= 0)
-        return false;
-
-      for (let i = 0, il = fields.length; i < il; i++) {
-        let field = fields[i];
-
-        if (LiteralBase.isLiteral(field))
-          return true;
-
-        if (ModelBase.isModelClass(field))
-          return true;
-
-        if (!Nife.instanceOf(field, 'string'))
-          true;
-
-        if (field === '-')
-          return true;
-
-        if (field === '*')
-          continue;
-
-        if (!(/^\s*[+-]/).test(field))
-          return true;
-      }
-
-      return false;
-    };
-
-    const collectProjectionValuesFromQuery = (RootModel, query) => {
-      let projections = [ RootModel ];
-
-      for (let i = 0, il = query.length; i < il; i++) {
-        let queryPart = query[i];
-
-        if (!Object.prototype.hasOwnProperty.call(queryPart, 'control'))
-          continue;
-
-        if (queryPart.control !== true)
-          continue;
-
-        if (queryPart.operator !== 'PROJECT')
-          continue;
-
-        let fields = queryPart.value;
-        if (shouldResetProjection(fields)) {
-          fields = Nife.arrayFlatten(fields);
-
-          let addIndex        = fields.indexOf('+');
-          let newProjections  = fields.slice();
-
-          if (addIndex >= 0)
-            newProjections[addIndex] = Nife.arrayFlatten(projections);
-
-          projections = newProjections;
-        } else {
-          projections = projections.concat(fields);
-        }
-      }
-
-      return Nife.uniq(Nife.arrayFlatten(projections));
-    };
-
-    const modelFieldsToProjection = (fieldSet, Model, removeFromProjection) => {
-      let modelName = Model.getModelName();
-
-      Model.iterateFields(({ field, fieldName }) => {
-        if (field.type.isVirtual())
-          return;
-
-        let fullFieldName = `${modelName}:${fieldName}`;
-
-        if (removeFromProjection) {
-          fieldSet.delete(fullFieldName);
-          return;
-        }
-
-        fieldSet.set(fullFieldName, {
-          projectedName:  this.getEscapedProjectionName(Model, field, options),
-          Model:          Model,
-          Field:          field,
-          direction:      '+',
-          fullFieldName,
-          fieldName,
-          modelName,
-        });
-      });
-    };
-
-    const addRequiredFieldsToProjection = (fieldSet) => {
-      let requiredProjectionFields = this.getProjectionRequiredFields(queryEngine, options);
-
-      for (let [ key, value ] of requiredProjectionFields) {
-        if (fieldSet.has(key))
-          continue;
-
-        fieldSet.set(key, value);
-      }
-
-      return fieldSet;
-    };
-
-    const finalizeProjection = (_projectedFields) => {
-      let projectedFields = _projectedFields;
-      let result;
-
-      let subQueryOperator = (options && options.subQueryOperator);
-      if (options && options.isSubQuery && !(subQueryOperator === 'EXISTS' || subQueryOperator === 'NOT EXISTS')) {
-        // If we are sub-selecting then only one
-        // field in the projection is allowed
-
-        result = Array.from(projectedFields.values());
-        if (result.length !== 1)
-          throw new Error(`${this.constructor.name}::getProjectionFromQueryEngine: Only one field is allowed in the projection of a sub-query.`);
-
-        let subQueryField = result[0];
-
-        if (LiteralBase.isLiteral(subQueryField))
-          result = [ subQueryField ];
-        else if (typeof subQueryField === 'string')
-          result = [ subQueryField ];
-        else
-          result = [ new Literals.DistinctLiteral(subQueryField.fullFieldName) ];
-      } else {
-        projectedFields = addRequiredFieldsToProjection(projectedFields);
-
-        // If distinct specifies a field, then
-        // make sure that field isn't specified twice
-        if (hasDistinct) {
-          let distinctFieldName = hasDistinct.getFullyQualifiedFieldName();
-          if (distinctFieldName)
-            projectedFields.delete(distinctFieldName);
-        }
-
-        result = Array.from(projectedFields.values());
-
-        // Convert projection fields to array and sort
-        result = this.sortedProjectedFields(result, options);
-
-        // Now prefix the projection fields with the distinct
-        // literal if one exists on the query
-        if (hasDistinct)
-          result = [ hasDistinct ].concat(result);
-      }
-
-      return result;
-    };
-
-    let rawQueryContext = queryEngine._getRawQueryContext();
-    let RootModel       = rawQueryContext.rootModel;
-    if (!RootModel)
-      throw new Error('QueryGeneratorBase::getProjectionFromQueryEngine: No root model found for query. Root model is required to generate a projection.');
-
-    let hasDistinct     = rawQueryContext.distinct;
-    let projections     = collectProjectionValuesFromQuery(RootModel, queryEngine._getRawQuery());
-    let projectedFields = new Map();
-    let allModels       = this.getAllModelsUsedInQuery(queryEngine, options);
-    let isAdding        = true;
-
-    // If projection is empty, then return
-    // the projection of the root model
-    if (Nife.isEmpty(projections)) {
-      modelFieldsToProjection(projectedFields, RootModel);
-      return finalizeProjection(projectedFields);
-    }
-
-    for (let i = 0, il = projections.length; i < il; i++) {
-      let projectionValue = projections[i];
-      if (!projectionValue)
-        continue;
-
-      if (projectionValue === '+') {
-        isAdding = true;
-        continue;
-      }
-
-      if (projectionValue === '-') {
-        isAdding = false;
-        continue;
-      }
-
-      if (projectionValue === '*') {
-        for (let i = 0, il = allModels.length; i < il; i++) {
-          let Model = allModels[i];
-          modelFieldsToProjection(projectedFields, Model);
-        }
-
-        continue;
-      }
-
-      if (LiteralBase.isLiteral(projectionValue)) {
-        // If we already have distinct specified on the query
-        // then skip any distinct values specified by the user
-        if (hasDistinct && Literals.DistinctLiteral.isLiteralType(projectionValue))
-          continue;
-
-        let key = projectionValue.toString(this.connection, options);
-        if (isAdding)
-          projectedFields.set(key, projectionValue);
-        else
-          projectedFields.delete(key);
-
-        continue;
-      }
-
-      if (ModelBase.isModelClass(projectionValue)) {
-        if (allModels.indexOf(projectionValue) >= 0)
-          modelFieldsToProjection(projectedFields, projectionValue, !isAdding);
-
-        continue;
-      }
-
-      let { fieldName, direction, hasDirection } = this.getFieldDirectionSpecifier(projectionValue);
-      if (!fieldName)
-        continue;
-
-      if (!hasDirection) {
-        direction = (isAdding) ? '+' : '-';
-        hasDirection = true;
-      }
-
-      let def = this.connection.parseQualifiedName(fieldName);
-      if (!def.modelName) {
-        if (Nife.isNotEmpty(def.fieldNames) && allModels.length > 1)
-          throw new Error(`QueryGeneratorBase::getProjectionFromQueryEngine: "${def.fieldNames[0]}" ambiguous. You must use a fully qualified field name for an ORDER clause. Example: "+Model:id".`);
-
-        def.modelName = RootModel.getModelName();
-      }
-
-      let ProjectionModel = this.connection.getModel(def.modelName);
-      if (!ProjectionModel) {
-        if (hasDirection && direction === '-') {
-          projectedFields.delete(projectionValue);
-          continue;
-        }
-
-        // Proceed blindly... as the user may be
-        // querying something we are unaware of
-        projectedFields.set(projectionValue, projectionValue);
-        continue;
-      }
-
-      if (allModels.indexOf(ProjectionModel) < 0)
-        continue;
-
-      if (!def.fieldNames.length) {
-        // If there are no field names, but we have a model name
-        // then let the projection generator generate all model
-        // fields
-
-        if (ProjectionModel) {
-          modelFieldsToProjection(projectedFields, ProjectionModel, (hasDirection && direction === '-'));
-          continue;
+  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);
         }
       }
-
-      let field     = this.connection.getField(def.fieldNames[0], def.modelName);
-      let modelName = (field) ? field.Model.getModelName() : ProjectionModel.getModelName();
-
-      if (!field) {
-        let projectionFieldName = def.fieldNames[0];
-        let fullFieldName       = `${modelName}:${projectionFieldName}`;
-
-        if (hasDirection && direction === '-') {
-          projectedFields.delete(fullFieldName);
-          continue;
-        }
-
-        // Proceed blindly... as the user may be
-        // querying something we are unaware of
-        projectedFields.set(fullFieldName, {
-          projectedName:  this.getEscapedProjectionName(ProjectionModel, fieldName, options),
-          Model:          ProjectionModel,
-          Field:          null,
-          fieldName:      projectionFieldName,
-          direction:      '+',
-          modelName,
-          fullFieldName,
-        });
-
-        continue;
-      }
-
-      let projectionFieldName = field.fieldName;
-      let fullFieldName       = `${modelName}:${projectionFieldName}`;
-
-      if (hasDirection && direction === '-') {
-        projectedFields.delete(fullFieldName);
-        continue;
-      }
-
-      projectedFields.set(fullFieldName, {
-        projectedName:  this.getEscapedProjectionName(field.Model, field, options),
-        Model:          field.Model,
-        Field:          field,
-        fieldName:      field.fieldName,
-        fullFieldName,
-        modelName,
-        direction,
-      });
     }
 
-    let result = finalizeProjection(projectedFields);
-
-    if (options)
-      this.setOptionsCache(options, `getProjectionFromQueryEngine.${queryEngineContextID}`, result);
-
-    return result;
-  }
-
-  isFieldIdentifier(str) {
-    return (/^"[^"]+"."[^"]+"|"\w+:[\w.]+"/i).test(str);
-  }
-
-  getProjectedFields(queryEngine, _options, asMap) {
-    let options             = _options || {};
-    let queryProjection     = this.getProjectionFromQueryEngine(queryEngine, options);
-    let allProjectionFields = new Map();
+    for (let [ fullyQualifiedName, projectedScope ] of queryProjection) {
+      let { value } = projectedScope;
 
-    for (let i = 0, il = queryProjection.length; i < il; i++) {
-      let projectionField = queryProjection[i];
-      if (!projectionField)
+      if (Nife.instanceOf(value, 'string')) {
+        // Raw string is treated as a literal
+        allProjectionFields.set(fullyQualifiedName, value);
         continue;
-
-      if (LiteralBase.isLiteral(projectionField)) {
-        let result = projectionField.toString(this.connection, options);
-        let fullFieldName;
-
-        if (typeof projectionField.getFullyQualifiedFieldName === 'function')
-          fullFieldName = projectionField.getFullyQualifiedFieldName();
-        else
-          fullFieldName = this.parseFieldProjection(result);
-
-        if (!fullFieldName)
-          fullFieldName = result;
-
-        if (fullFieldName && result)
-          allProjectionFields.set(fullFieldName, result);
-        else
-          allProjectionFields.set(result, result);
+      } else if (LiteralBase.isLiteral(value)) {
+        let result = value.toString(this.connection, options);
+        allProjectionFields.set(result || fullyQualifiedName, result || fullyQualifiedName);
 
         continue;
       }
 
-      if (projectionField.direction === '-')
+      if (allModelsUsedInQuery.indexOf(value.Model) < 0)
         continue;
 
-      if (Nife.instanceOf(projectionField, 'string')) {
-        allProjectionFields.set(projectionField, projectionField);
-        continue;
-      }
-
-      let projectedName = projectionField.projectedName;
-      allProjectionFields.set(projectionField.fullFieldName, projectedName);
+      let escapedFieldName = this.getEscapedProjectionName(value.Model, value, options);
+      allProjectionFields.set(`${value.Model.getModelName()}:${value.fieldName}`, escapedFieldName);
     }
 
     if (asMap === true)
@@ -705,90 +245,19 @@ class QueryGeneratorBase {
     };
   }
 
-  // eslint-disable-next-line no-unused-vars
-  getOrderLimitOffset(queryEngine, options) {
-    let queryEngineContextID  = queryEngine._getTopContextID();
-    let cache                 = this.getOptionsCache(options, `getOrderLimitOffset.${queryEngineContextID}`);
-    if (cache)
-      return cache;
-
-    let query     = queryEngine._getRawQuery();
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
-    let limit;
-    let offset;
-    let order;
-
-    for (let i = 0, il = query.length; i < il; i++) {
-      let queryPart = query[i];
-
-      if (!Object.prototype.hasOwnProperty.call(queryPart, 'control'))
-        continue;
-
-      if (queryPart.control !== true)
-        continue;
-
-      let queryOperator = queryPart.operator;
-
-      if (queryOperator === 'LIMIT')
-        limit = queryPart.value;
-      else if (queryOperator === 'OFFSET')
-        offset = queryPart.value;
-      else if (queryOperator === 'ORDER')
-        order = queryPart.value;
-    }
-
-    if (order === undefined) {
-      if (options && options.selectStatement === true)
-        order = this.connection.getDefaultOrder(rootModel, options);
-    }
-
-    if (Nife.isNotEmpty(order) && !LiteralBase.isLiteral(order)) {
-      let allModels = this.getAllModelsUsedInQuery(queryEngine, options);
-
-      order = order.map((_fieldName) => {
-        if (LiteralBase.isLiteral(_fieldName))
-          return _fieldName;
-
-        let { fieldName, direction } = this.getFieldDirectionSpecifier(_fieldName);
-        if (!fieldName)
-          return;
-
-        let def = this.connection.parseQualifiedName(fieldName);
-        if (!def.modelName) {
-          if (allModels.length > 1)
-            throw new Error(`QueryGeneratorBase::getOrderLimitOffset: "${fieldName}" ambiguous. You must use a fully qualified field name for an ORDER clause. Example: "+Model:id".`);
-
-          def.modelName = allModels[0].getModelName();
-        }
-
-        if (!def.fieldNames.length)
-          throw new Error(`QueryGeneratorBase::getOrderLimitOffset: No field names found for "${fieldName}".`);
-
-        let field = this.connection.getField(def.fieldNames[0], def.modelName);
-        if (!field)
-          throw new Error(`QueryGeneratorBase::getOrderLimitOffset: Unable to locate field "${def.modelName}"."${def.fieldNames[0]}".`);
-
-        return {
-          Model: field.Model,
-          Field: field,
-          direction,
-        };
-      });
-    }
-
-    let orderLimitOffset = { limit, order, offset };
-
-    if (options)
-      this.setOptionsCache(options, `getOrderLimitOffset.${queryEngineContextID}`, orderLimitOffset);
+  getQuerySliceFromQueryPart(queryPart) {
+    let operationStack = queryPart.operationStack;
+    let index     = operationStack.indexOf(queryPart);
 
-    return orderLimitOffset;
+    return operationStack.slice(index);
   }
 
-  getQuerySliceFromQueryPart(queryPart) {
-    let queryRoot = queryPart.queryRoot;
-    let index     = queryRoot.indexOf(queryPart);
+  _getLiteralAlias(literal, options) {
+    let as = (literal.options && literal.options.as) || (options && options.as);
+    if (Nife.isEmpty(as))
+      return '';
 
-    return queryRoot.slice(index);
+    return ` AS ${this.escapeID(as)}`;
   }
 
   _averageLiteralToString(literal, options) {
@@ -803,7 +272,7 @@ class QueryGeneratorBase {
     else
       escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
-    return `AVG(${escapedFieldName})`;
+    return `AVG(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
   }
 
   _countLiteralToString(literal, options) {
@@ -822,7 +291,7 @@ class QueryGeneratorBase {
       escapedFieldName = '*';
     }
 
-    return `COUNT(${escapedFieldName})`;
+    return `COUNT(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
   }
 
   _distinctLiteralToString(literal, options) {
@@ -830,10 +299,13 @@ class QueryGeneratorBase {
       return;
 
     let field = literal.getField(this.connection);
+    if (!field)
+      return 'DISTINCT';
+
     if (LiteralBase.isLiteral(field))
-      return `DISTINCT ${field.toString(this.connection, options)}`;
+      return `DISTINCT ON(${field.toString(this.connection, this.stackAssign(options, { noProjectionAliases: true }))})`;
 
-    return `DISTINCT ${this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, literal.options))}`;
+    return `DISTINCT ON(${this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options, { noProjectionAliases: true }))})`;
   }
 
   _fieldLiteralToString(literal, options) {
@@ -844,7 +316,7 @@ class QueryGeneratorBase {
     if (LiteralBase.isLiteral(field))
       return field.toString(this.connection, options);
 
-    return this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+    return this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, { noProjectionAliases: (options && !options.isProjection) }, literal.options));
   }
 
   _maxLiteralToString(literal, options) {
@@ -859,7 +331,7 @@ class QueryGeneratorBase {
     else
       escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
-    return `MAX(${escapedFieldName})`;
+    return `MAX(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
   }
 
   _minLiteralToString(literal, options) {
@@ -874,7 +346,7 @@ class QueryGeneratorBase {
     else
       escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
-    return `MIN(${escapedFieldName})`;
+    return `MIN(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
   }
 
   _sumLiteralToString(literal, options) {
@@ -889,7 +361,7 @@ class QueryGeneratorBase {
     else
       escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
-    return `SUM(${escapedFieldName})`;
+    return `SUM(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
   }
 
   // eslint-disable-next-line no-unused-vars