mythix-orm 1.5.5 → 1.5.6

package/lib/connection/connection-base.js

@@ -121,6 +121,23 @@ class ConnectionBase extends EventEmitter {
     return order.map((value) => ((value.indexOf(':') < 0) ? `${modelName}:${value}` : value));
   }
 
+  isLimitSupportedInContext(options) {
+    return true;
+  }
+
+  isOrderSupportedInContext(_options) {
+    let options = _options || {};
+    if (options.isSubQuery) {
+      let subQueryOperator = options.subQueryOperator;
+      if (subQueryOperator === 'EXISTS' || subQueryOperator === 'NOT EXISTS')
+        return true;
+
+      return 'PROJECTION_ONLY';
+    }
+
+    return true;
+  }
+
   _getFromModelCache(Model, key, defaultValue) {
     let cache = this._modelCache.get(Model);
     if (!cache)
@@ -324,6 +341,17 @@ class ConnectionBase extends EventEmitter {
     return queryGenerator._distinctLiteralToString(literal, options);
   }
 
+  _fieldLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let queryGenerator = this.getQueryGenerator();
+    if (!queryGenerator)
+      return;
+
+    return queryGenerator._fieldLiteralToString(literal, options);
+  }
+
   _maxLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
@@ -364,6 +392,8 @@ class ConnectionBase extends EventEmitter {
       return this._countLiteralToString(literal, options);
     else if (Literals.DistinctLiteral.isLiteralType(literal))
       return this._distinctLiteralToString(literal, options);
+    else if (Literals.FieldLiteral.isLiteralType(literal))
+      return this._fieldLiteralToString(literal, options);
     else if (Literals.MaxLiteral.isLiteralType(literal))
       return this._maxLiteralToString(literal, options);
     else if (Literals.MinLiteral.isLiteralType(literal))

package/lib/connection/literals/field-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class FieldLiteral extends LiteralFieldBase {
+  toString(connection, options) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this, options);
+  }
+}
+
+module.exports = FieldLiteral;

package/lib/connection/literals/index.js

@@ -1,23 +1,25 @@
 'use strict';
 
-const LiteralBase      = require('./literal-base');
-const LiteralFieldBase = require('./literal-field-base');
-const Literal          = require('./literal');
-const AverageLiteral   = require('./average-literal');
-const CountLiteral     = require('./count-literal');
-const MaxLiteral       = require('./max-literal');
-const MinLiteral       = require('./min-literal');
-const DistinctLiteral  = require('./distinct-literal');
-const SumLiteral       = require('./sum-literal');
+const AverageLiteral    = require('./average-literal');
+const CountLiteral      = require('./count-literal');
+const DistinctLiteral   = require('./distinct-literal');
+const FieldLiteral      = require('./field-literal');
+const Literal           = require('./literal');
+const LiteralBase       = require('./literal-base');
+const LiteralFieldBase  = require('./literal-field-base');
+const MaxLiteral        = require('./max-literal');
+const MinLiteral        = require('./min-literal');
+const SumLiteral        = require('./sum-literal');
 
 module.exports = {
-  LiteralBase,
-  LiteralFieldBase,
-  Literal,
   AverageLiteral,
   CountLiteral,
+  DistinctLiteral,
+  FieldLiteral,
+  Literal,
+  LiteralBase,
+  LiteralFieldBase,
   MaxLiteral,
   MinLiteral,
-  DistinctLiteral,
   SumLiteral,
 };

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

@@ -46,11 +46,6 @@ class QueryGeneratorBase {
     return this.connection.escapeID(...args);
   }
 
-  getTableNameFromQueryPart(queryPart) {
-    let Model = queryPart.Model;
-    return Model.getTableName(this.connection);
-  }
-
   getEscapedFieldName(_Model, field, options) {
     let isString  = Nife.instanceOf(field, 'string');
     let fieldName = (isString) ? field : field.fieldName;
@@ -73,10 +68,23 @@ class QueryGeneratorBase {
     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.escapeID(Model.getTableName(this.connection))}.${this.escapeID(columnName)}`;
+      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
@@ -361,7 +369,8 @@ class QueryGeneratorBase {
       let projectedFields = _projectedFields;
       let result;
 
-      if (options && options.isSubQuery) {
+      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
 
@@ -773,19 +782,6 @@ class QueryGeneratorBase {
     return orderLimitOffset;
   }
 
-  queryHasConditions(query) {
-    for (let i = 0, il = query.length; i < il; i++) {
-      let queryPart = query[i];
-      if (!Object.prototype.hasOwnProperty.call(queryPart, 'condition'))
-        continue;
-
-      if (queryPart.condition === true)
-        return true;
-    }
-
-    return false;
-  }
-
   getQuerySliceFromQueryPart(queryPart) {
     let queryRoot = queryPart.queryRoot;
     let index     = queryRoot.indexOf(queryPart);
@@ -838,6 +834,17 @@ class QueryGeneratorBase {
     return `DISTINCT ${this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, literal.options))}`;
   }
 
+  _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.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+  }
+
   _maxLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;

package/lib/query-engine/field-scope.js

@@ -13,6 +13,7 @@ function addOperatorToQuery(name, inverseName, value, extraOptions) {
     operator:         name,
     inverseOperator:  inverseName,
     value:            this._fetchOperatorValue(value),
+    hasCondition:     true,
   };
 
   if (extraOptions)

package/lib/query-engine/query-engine-base.js

@@ -256,6 +256,22 @@ class QueryEngineBase extends ProxyClass {
     return false;
   }
 
+  _queryHasConditions() {
+    let context = this._getRawQueryContext();
+    return context.hasCondition;
+  }
+
+  _queryHasJoins() {
+    let queryParts = this._getRawQuery();
+    for (let i = 0, il = queryParts.length; i < il; i++) {
+      let queryPart = queryParts[i];
+      if (QueryEngineBase.isQuery(queryPart.value) && !queryPart.value.hasCondition)
+        return true;
+    }
+
+    return false;
+  }
+
   _debugQuery() {
     let query = this._getRawQuery();
     for (let i = 0, il = query.length; i < il; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "description": "ORM for Mythix framework",
   "main": "lib/index.js",
   "type": "commonjs",