mythix-orm 1.4.5 → 1.5.0

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

@@ -20,10 +20,12 @@ class QueryGeneratorBase {
     });
   }
 
-  stackAssign(obj, ...args) {
+  stackAssign(obj, ..._args) {
     let newObj = Object.create(obj || {});
+    let args = _args.filter(Boolean);
 
-    Object.assign(newObj, ...args);
+    if (args.length > 0)
+      Object.assign(newObj, ...args);
 
     return newObj;
   }
@@ -159,8 +161,14 @@ class QueryGeneratorBase {
         continue;
 
       if (LiteralBase.isLiteral(field)) {
-        let result          = field.toString(this.connection);
-        let projectionField = this.parseFieldProjection(result, true);
+        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;
@@ -188,7 +196,7 @@ class QueryGeneratorBase {
     return orderFieldMap;
   }
 
-  sortedProjectedFields(projectedFields) {
+  sortedProjectedFields(projectedFields, options) {
     return projectedFields.sort((a, b) => {
       // If either value is a distinct literal
       // then make certain it comes first in
@@ -197,8 +205,8 @@ class QueryGeneratorBase {
       const distinctSortOrder = (a, b) => {
         let x           = LiteralBase.isLiteral(a);
         let y           = LiteralBase.isLiteral(b);
-        let xStr        = (x) ? a.toString(this.connection) : a;
-        let yStr        = (y) ? b.toString(this.connection) : 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));
 
@@ -383,7 +391,7 @@ class QueryGeneratorBase {
         result = Array.from(projectedFields.values());
 
         // Convert projection fields to array and sort
-        result = this.sortedProjectedFields(result);
+        result = this.sortedProjectedFields(result, options);
 
         // Now prefix the projection fields with the distinct
         // literal if one exists on the query
@@ -442,7 +450,7 @@ class QueryGeneratorBase {
         if (hasDistinct && Literals.DistinctLiteral.isLiteralType(projectionValue))
           continue;
 
-        let key = projectionValue.toString(this.connection);
+        let key = projectionValue.toString(this.connection, options);
         if (isAdding)
           projectedFields.set(key, projectionValue);
         else
@@ -556,8 +564,13 @@ class QueryGeneratorBase {
     return result;
   }
 
+  isFieldIdentifier(str) {
+    return (/^"[^"]+"."[^"]+"|"\w+:[\w.]+"/i).test(str);
+  }
+
   getProjectedFields(queryEngine, _options, asMap) {
-    let queryProjection     = this.getProjectionFromQueryEngine(queryEngine, _options);
+    let options             = _options || {};
+    let queryProjection     = this.getProjectionFromQueryEngine(queryEngine, options);
     let allProjectionFields = new Map();
 
     for (let i = 0, il = queryProjection.length; i < il; i++) {
@@ -566,15 +579,20 @@ class QueryGeneratorBase {
         continue;
 
       if (LiteralBase.isLiteral(projectionField)) {
-        let result = projectionField.toString(this.connection);
-        let fullFieldName = this.parseFieldProjection(result);
+        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);
-
-        if (result && !this.isFieldProjection(result))
+        else
           allProjectionFields.set(result, result);
 
         continue;
@@ -708,6 +726,11 @@ class QueryGeneratorBase {
         order = queryPart.value;
     }
 
+    if (Nife.isEmpty(order)) {
+      if (options && options.selectStatement === true)
+        order = this.connection.getDefaultOrder(rootModel, options);
+    }
+
     if (Nife.isNotEmpty(order) && !LiteralBase.isLiteral(order)) {
       let allModels = this.getAllModelsUsedInQuery(queryEngine, options);
 
@@ -740,9 +763,6 @@ class QueryGeneratorBase {
           direction,
         };
       });
-    } else if (Nife.isEmpty(order)) {
-      if (options && options.selectStatement === true)
-        order = this.connection.getDefaultOrder(rootModel, options);
     }
 
     let orderLimitOffset = { limit, order, offset };
@@ -773,33 +793,33 @@ class QueryGeneratorBase {
     return queryRoot.slice(index);
   }
 
-  _averageLiteralToString(literal) {
+  _averageLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
 
-    let field = literal.definitionToField(this.connection, literal.definition);
+    let field = literal.getField(this.connection);
     let escapedFieldName;
 
     if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection);
+      escapedFieldName = field.toString(this.connection, options);
     else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, literal.options);
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
     return `AVG(${escapedFieldName})`;
   }
 
-  _countLiteralToString(literal) {
+  _countLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
 
-    let field = (literal.definition) ? literal.definitionToField(this.connection, literal.definition) : null;
+    let field = literal.getField(this.connection);
     let escapedFieldName;
 
     if (field) {
       if (LiteralBase.isLiteral(field))
-        escapedFieldName = field.toString(this.connection);
+        escapedFieldName = field.toString(this.connection, options);
       else
-        escapedFieldName = this.getEscapedColumnName(field.Model, field, literal.options);
+        escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
     } else {
       escapedFieldName = '*';
     }
@@ -807,58 +827,58 @@ class QueryGeneratorBase {
     return `COUNT(${escapedFieldName})`;
   }
 
-  _distinctLiteralToString(literal) {
+  _distinctLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
 
-    let field = literal.definitionToField(this.connection, literal.definition);
+    let field = literal.getField(this.connection);
     if (LiteralBase.isLiteral(field))
-      return `DISTINCT ${field.toString(this.connection)}`;
+      return `DISTINCT ${field.toString(this.connection, options)}`;
 
-    return `DISTINCT ${this.getEscapedProjectionName(field.Model, field, literal.options)}`;
+    return `DISTINCT ${this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, literal.options))}`;
   }
 
-  _maxLiteralToString(literal) {
+  _maxLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
 
-    let field = literal.definitionToField(this.connection, literal.definition);
+    let field = literal.getField(this.connection);
     let escapedFieldName;
 
     if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection);
+      escapedFieldName = field.toString(this.connection, options);
     else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, literal.options);
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
     return `MAX(${escapedFieldName})`;
   }
 
-  _minLiteralToString(literal) {
+  _minLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
 
-    let field = literal.definitionToField(this.connection, literal.definition);
+    let field = literal.getField(this.connection);
     let escapedFieldName;
 
     if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection);
+      escapedFieldName = field.toString(this.connection, options);
     else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, literal.options);
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
     return `MIN(${escapedFieldName})`;
   }
 
-  _sumLiteralToString(literal) {
+  _sumLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
 
-    let field = literal.definitionToField(this.connection, literal.definition);
+    let field = literal.getField(this.connection);
     let escapedFieldName;
 
     if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection);
+      escapedFieldName = field.toString(this.connection, options);
     else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, literal.options);
+      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
 
     return `SUM(${escapedFieldName})`;
   }