mythix-orm-sql-base 1.4.4 → 1.4.5

package/lib/sql-connection-base.js

@@ -65,14 +65,6 @@ class SQLConnectionBase extends ConnectionBase {
     }
   }
 
-  databaseSupportsLimitInSubQuery() {
-    return false;
-  }
-
-  databaseSupportsOrderInSubQuery() {
-    return false;
-  }
-
   prepareArrayValuesForSQL(_array) {
     let array = Nife.arrayFlatten(_array);
 
@@ -869,6 +861,7 @@ class SQLConnectionBase extends ConnectionBase {
     return (count > 0);
   }
 
+  // eslint-disable-next-line no-unused-vars
   async enableForeignKeyConstraints(enable) {
     throw new Error(`${this.constructor.name}::enableForeignKeyConstraints: This operation is not supported for this connection type.`);
   }

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

@@ -222,12 +222,11 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       value = arrayValues;
     }
 
-    let escapedTableName  = this.escapeID(this.getTableNameFromQueryPart(queryPart));
-    let escapedColumnName = this.escapeID(field.columnName);
+    let escapedColumnName = this.getEscapedColumnName(field.Model, field, options);
     let sqlOperator       = this.generateSelectQueryOperatorFromQueryEngineOperator(queryPart, operator, value, false, options);
 
     if (QueryEngine.isQuery(value)) {
-      if (!this.queryHasConditions(value._getRawQuery()))
+      if (!value._queryHasConditions())
         return '';
 
       if (sqlOperator === '=')
@@ -235,7 +234,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       else if (sqlOperator === '!=')
         sqlOperator = 'NOT IN';
 
-      return `${escapedTableName}.${escapedColumnName} ${sqlOperator} (${this.generateSelectStatement(value, this.stackAssign(options, { isSubQuery: true }))})`;
+      return `${escapedColumnName} ${sqlOperator} (${this.generateSelectStatement(value, this.stackAssign(options, { isSubQuery: true, subQueryOperator: 'EXISTS' }))})`;
     }
 
     let context = { queryPart, field, sqlOperator, operator, value };
@@ -244,7 +243,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     let conditionPostfix = this.generateConditionPostfix(context);
 
-    return `${escapedTableName}.${escapedColumnName} ${sqlOperator} ${this.escape(field, value)}${(conditionPostfix) ? ` ${conditionPostfix}` : ''}`;
+    return `${escapedColumnName} ${sqlOperator} ${this.escape(field, value)}${(conditionPostfix) ? ` ${conditionPostfix}` : ''}`;
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -252,18 +251,16 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (!Model)
       throw new Error(`${this.constructor.name}::generateFromTableOrTableJoin: No valid model provided.`);
 
-    let escapedTableName = this.escapeID(Model.getTableName(this.connection));
+    let escapedTableName = this.getEscapedTableName(Model, options);
     return (joinType) ? `${joinType} ${escapedTableName}` : `FROM ${escapedTableName}`;
   }
 
   generateSelectJoinOnTableQueryCondition(leftQueryPart, rightQueryPart, leftField, rightField, operator, options) {
-    let leftSideEscapedTableName    = this.escapeID(this.getTableNameFromQueryPart(leftQueryPart));
-    let leftSideEscapedColumnName   = this.escapeID(leftField.columnName);
-    let rightSideEscapedTableName   = this.escapeID(this.getTableNameFromQueryPart(rightQueryPart));
-    let rightSideEscapedColumnName  = this.escapeID(rightField.columnName);
+    let leftSideEscapedColumnName   = this.getEscapedColumnName(leftField.Model, leftField, options);
+    let rightSideEscapedColumnName  = this.getEscapedColumnName(rightField.Model, rightField, options);
     let sqlOperator                 = this.generateSelectQueryOperatorFromQueryEngineOperator(leftQueryPart, operator, undefined, true, options);
 
-    return `${leftSideEscapedTableName}.${leftSideEscapedColumnName} ${sqlOperator} ${rightSideEscapedTableName}.${rightSideEscapedColumnName}`;
+    return `${leftSideEscapedColumnName} ${sqlOperator} ${rightSideEscapedColumnName}`;
   }
 
   generateJoinOnTableQueryConditions(joinInfos, options) {
@@ -450,11 +447,6 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return sqlParts.join(' ');
   }
 
-  // eslint-disable-next-line no-unused-vars
-  allowOrderFieldWhenNotProjected(orderField, options) {
-    return true;
-  }
-
   // eslint-disable-next-line no-unused-vars
   generateOrderClause(_orders, _options) {
     if (LiteralBase.isLiteral(_orders))
@@ -464,13 +456,21 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (Nife.isEmpty(orders))
       return '';
 
-    let options       = _options || {};
+    let options             = _options || {};
+    let contextOrderSupport = this.connection.isOrderSupportedInContext(options);
+    if (contextOrderSupport === false)
+      return '';
+
     let orderByParts  = [];
     for (let i = 0, il = orders.length; i < il; i++) {
       let orderField = orders[i];
 
       if (LiteralBase.isLiteral(orderField)) {
-        orderByParts.push(orderField.toString(this.connection));
+        let fieldStr = orderField.toString(this.connection);
+        if (!options.projectionFields.has(fieldStr) && contextOrderSupport === 'PROJECTION_ONLY')
+          continue;
+
+        orderByParts.push(fieldStr);
         continue;
       }
 
@@ -480,12 +480,11 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
         let fieldName   = orderField.Field.fieldName;
         let fqFieldName = `${modelName}:${fieldName}`;
 
-        if (!options.projectionFields.has(fqFieldName) && !this.allowOrderFieldWhenNotProjected(orderField, options))
+        if (!options.projectionFields.has(fqFieldName) && contextOrderSupport === 'PROJECTION_ONLY')
           continue;
       }
 
-      let escapedTableName  = this.escapeID(orderField.Model.getTableName(this.connection));
-      let escapedColumnName = this.escapeID(orderField.Field.columnName);
+      let escapedColumnName = this.getEscapedColumnName(orderField.Model, orderField.Field.columnName, options);
       let orderStr;
 
       if (options.reverseOrder !== true)
@@ -493,7 +492,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       else
         orderStr = (orderField.direction === '-') ? 'ASC' : 'DESC';
 
-      orderByParts.push(`${escapedTableName}.${escapedColumnName} ${orderStr}`);
+      orderByParts.push(`${escapedColumnName} ${orderStr}`);
     }
 
     if (Nife.isEmpty(orderByParts))
@@ -518,21 +517,25 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return `OFFSET ${offset}`;
   }
 
-  generateSelectOrderLimitOffset(queryEngine, options) {
+  generateSelectOrderLimitOffset(queryEngine, _options) {
+    let options = _options || {};
     let {
       order,
       limit,
       offset,
     } = this.getOrderLimitOffset(queryEngine, options);
     let sqlParts = [];
+    let hasOrder = false;
 
     if (Nife.isNotEmpty(order)) {
-      if (!(options && options.isSubQuery) || (options && options.isSubQuery && this.connection.databaseSupportsOrderInSubQuery())) {
+      if (this.connection.isOrderSupportedInContext(options)) {
         let result = this.generateOrderClause(order, options);
-        if (result)
+        if (result) {
+          hasOrder = true;
           sqlParts.push(result);
+        }
 
-        if (!(Nife.instanceOf(limit, 'number') && isFinite(limit)) && options && options.forceLimit) {
+        if (hasOrder && !(Nife.instanceOf(limit, 'number') && isFinite(limit)) && options && options.forceLimit) {
           limit = options.forceLimit;
           offset = 0;
         }
@@ -540,7 +543,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     }
 
     if (!Object.is(limit, Infinity) && Nife.isNotEmpty(limit)) {
-      if (!(options && options.isSubQuery) || (options && options.isSubQuery && this.connection.databaseSupportsLimitInSubQuery())) {
+      if (this.connection.isLimitSupportedInContext(options)) {
         let result = this.generateLimitClause(limit, options);
         if (result)
           sqlParts.push(result);
@@ -548,7 +551,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     }
 
     if (Nife.isNotEmpty(offset)) {
-      if (!(options && options.isSubQuery) || (options && options.isSubQuery && this.connection.databaseSupportsLimitInSubQuery())) {
+      if (this.connection.isLimitSupportedInContext(options)) {
         let result = this.generateOffsetClause(offset, options);
         if (result)
           sqlParts.push(result);
@@ -658,8 +661,10 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
   // eslint-disable-next-line no-unused-vars
   generateIndexName(Model, field, index, options) {
-    let tableName = Model.getTableName(this.connection);
+    if (!index)
+      return '';
 
+    let tableName = Model.getTableName(this.connection);
     if (index === true)
       return this.escapeID(`idx_${tableName}_${field.columnName}`.replace(/\W+/g, '_'));
 
@@ -673,13 +678,16 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       fieldNames.push(indexField.columnName);
     }
 
-    return this.escapeID(`idx_${tableName}_${fieldNames.join('_')}`);
+    return this.escapeID(`idx_${tableName}_${fieldNames.sort().join('_')}`);
   }
 
-  generateColumnIndex(Model, field, index, _options) {
+  generateColumnIndexes(Model, field, _indexes, _options) {
+    let indexes = Nife.toArray(_indexes).filter(Boolean);
+    if (Nife.isEmpty(indexes))
+      return [];
+
     let options           = _options || {};
-    let escapedTableName  = this.escapeID(Model.getTableName(this.connection));
-    let indexName         = this.generateIndexName(Model, field, index, options);
+    let escapedTableName  = this.getEscapedTableName(Model, options);
     let flags             = [];
 
     if (options.concurrently)
@@ -690,25 +698,26 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     flags = flags.join(' ');
 
-    if (index === true)
-      return `CREATE INDEX ${flags} ${indexName} ON ${escapedTableName} (${this.escapeID(field.columnName)});`;
+    return indexes.map((indexNames) => {
+      let indexName = this.generateIndexName(Model, field, indexNames, options);
+      if (indexNames === true)
+        return `CREATE INDEX ${flags} ${indexName} ON ${escapedTableName} (${this.escapeID(field.columnName)});`;
 
-    let fieldNames = [];
-    for (let i = 0, il = index.length; i < il; i++) {
-      let indexFieldName  = index[i];
-      let indexField      = Model.getField(indexFieldName);
-      if (!indexField)
-        throw new Error(`${this.constructor.name}::generateColumnIndex: Unable to find field named "${indexFieldName}".`);
+      let escapedColumnNames = [field.fieldName].concat(indexNames).filter(Boolean).map((fieldName) => {
+        let thisField = Model.getField(fieldName);
+        if (!thisField)
+          throw new Error(`${this.constructor.name}::generateColumnIndexes: Unable to find field named "${fieldName}".`);
 
-      fieldNames.push(this.escapeID(indexField.columnName));
-    }
+        return this.getEscapedColumnName(Model, thisField, options);
+      });
 
-    return `CREATE INDEX ${indexName} ON ${escapedTableName} (${fieldNames.join(',')});`;
+      return `CREATE INDEX ${indexName} ON ${escapedTableName} (${escapedColumnNames.join(',')});`;
+    });
   }
 
   generateDropTableStatement(Model, _options) {
     let options           = _options || {};
-    let escapedTableName  = this.escapeID(Model.getTableName(this.connection));
+    let escapedTableName  = this.getEscapedTableName(Model, options);
     let flags             = [];
 
     if (options.ifExists)
@@ -719,34 +728,34 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return `DROP TABLE ${flags} ${escapedTableName}${(options.cascade === true) ? ' CASCADE' : ''}`;
   }
 
-  generateForeignKeyConstraint(field, type) {
-    let options     = type.getOptions();
+  generateForeignKeyConstraint(field, type, options) {
+    let typeOptions = type.getOptions();
     let targetModel = type.getTargetModel(this.connection);
     let targetField = type.getTargetField(this.connection);
 
     let sqlParts = [
       'FOREIGN KEY(',
-      this.escapeID(field.columnName),
+      this.getEscapedColumnName(field.Model, field, { ...(options || {}), columnNameOnly: true }),
       ') REFERENCES ',
-      this.escapeID(targetModel.getTableName(this.connection)),
+      this.getEscapedTableName(targetModel, options),
       '(',
-      this.escapeID(targetField.columnName),
+      this.getEscapedColumnName(targetModel, targetField, { ...(options || {}), columnNameOnly: true }),
       ')',
     ];
 
-    if (options.deferred === true) {
+    if (typeOptions.deferred === true) {
       sqlParts.push(' ');
       sqlParts.push('DEFERRABLE INITIALLY DEFERRED');
     }
 
-    if (options.onDelete) {
+    if (typeOptions.onDelete) {
       sqlParts.push(' ');
-      sqlParts.push(`ON DELETE ${options.onDelete.toUpperCase()}`);
+      sqlParts.push(`ON DELETE ${typeOptions.onDelete.toUpperCase()}`);
     }
 
-    if (options.onUpdate) {
+    if (typeOptions.onUpdate) {
       sqlParts.push(' ');
-      sqlParts.push(`ON UPDATE ${options.onUpdate.toUpperCase()}`);
+      sqlParts.push(`ON UPDATE ${typeOptions.onUpdate.toUpperCase()}`);
     }
 
     return sqlParts.join('');
@@ -790,9 +799,9 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       let indexes = Nife.toArray(field.index).filter(Boolean);
       for (let i = 0, il = indexes.length; i < il; i++) {
         let index   = indexes[i];
-        let result  = this.generateColumnIndex(Model, field, index, options);
-        if (result)
-          fieldParts.push(result);
+        let result  = this.generateColumnIndexes(Model, field, index, options);
+        if (Nife.isNotEmpty(result))
+          fieldParts.push(result.join('\n\n'));
       }
     });
 
@@ -807,10 +816,8 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       if (field.type.isVirtual())
         return;
 
-      let columnName      = field.columnName || fieldName;
       let constraintParts = [];
-
-      let defaultValue = this.getFieldDefaultValue(field, fieldName, { remoteOnly: true });
+      let defaultValue    = this.getFieldDefaultValue(field, fieldName, { remoteOnly: true });
 
       if (field.primaryKey) {
         if (LiteralBase.isLiteral(field.primaryKey))
@@ -839,7 +846,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       if (Nife.isNotEmpty(constraintParts))
         constraintParts = ` ${constraintParts}`;
 
-      fieldParts.push(`  ${this.escapeID(columnName)} ${field.type.toConnectionType(this.connection, { createTable: true, defaultValue })}${constraintParts}`);
+      fieldParts.push(`  ${this.getEscapedColumnName(Model, field, { columnNameOnly: true })} ${field.type.toConnectionType(this.connection, { createTable: true, defaultValue })}${constraintParts}`);
     });
 
     let ifNotExists = '';
@@ -850,7 +857,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (Nife.isNotEmpty(trailingParts))
       fieldParts = fieldParts.concat(trailingParts.map((part) => `  ${part.trim()}`));
 
-    let finalStatement = `CREATE TABLE ${ifNotExists}${this.escapeID(Model.getTableName(this.connection))} (${fieldParts.join(',\n')}\n);`;
+    let finalStatement = `CREATE TABLE ${ifNotExists}${this.getEscapedTableName(Model)} (${fieldParts.join(',\n')}\n);`;
     return finalStatement;
   }
 
@@ -949,7 +956,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (!values)
       return '';
 
-    let escapedTableName  = this.escapeID(Model.getTableName(this.connection));
+    let escapedTableName  = this.getEscapedTableName(Model, subOptions);
     let escapedFieldNames = Array.from(Object.values(this.getEscapedModelFields(Model, subOptions)));
 
     let insertStatementTail = this.generateInsertStatementTail(
@@ -999,7 +1006,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (Nife.isEmpty(dirtyFields))
       return '';
 
-    let escapedTableName  = this.escapeID(Model.getTableName(this.connection));
+    let escapedTableName  = this.getEscapedTableName(Model, options);
     let sqlParts          = [ 'UPDATE ', escapedTableName, ' SET ' ];
     let setParts          = [];
     let tabs              = '';
@@ -1012,7 +1019,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     for (let i = 0, il = dirtyFields.length; i < il; i++) {
       let dirtyField        = dirtyFields[i];
       let fieldValue        = modelChanges[dirtyField.fieldName].current;
-      let escapedColumnName = this.escapeID(dirtyField.columnName);
+      let escapedColumnName = this.getEscapedColumnName(dirtyField.Model, dirtyField.columnName, { columnNameOnly: true });
       let escapedValue      = (LiteralBase.isLiteral(fieldValue)) ? fieldValue.toString(this.connection) : this.escape(dirtyField, fieldValue);
       if (!escapedValue)
         continue;
@@ -1072,21 +1079,19 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       }
     }
 
-    let escapedTableName = this.escapeID(Model.getTableName(this.connection));
-    if (queryEngine) {
-      let pkField = Model.getPrimaryKeyField();
-      let where   = this.generateWhereAndOrderLimitOffset(queryEngine, options);
-
-      if (where && pkField) {
-        if (pkField)
-          queryEngine = queryEngine.PROJECT(`${Model.getModelName()}:${pkField.fieldName}`);
-
-        let innerSelect       = this.generateSelectStatement(queryEngine, this.stackAssign(options, { isSubQuery: true, noProjectionAliases: true }));
-        let orderLimitOffset  = this.generateSelectOrderLimitOffset(queryEngine, this.stackAssign(options, { forceLimit: 4294967294 }));
-        let escapedColumnName = this.getEscapedColumnName(Model, pkField, options);
-
-        return `DELETE FROM ${escapedTableName} WHERE ${escapedColumnName} IN (${innerSelect})${(orderLimitOffset) ? ` ${orderLimitOffset}` : ''}`;
+    let escapedTableName = this.getEscapedTableName(Model, options);
+    if (queryEngine && queryEngine._queryHasConditions()) {
+      if (queryEngine._queryHasJoins()) {
+        let pkField = Model.getPrimaryKeyField();
+        if (!pkField)
+          throw new Error(`${this.constructor.name}::generateDeleteStatement: Can not delete using table joins on a table with no primary key field.`);
+
+        let escapedTableNameAlias = this.getEscapedTableName(Model, { tableNamePrefix: '_' });
+        let escapedFieldAlias     = this.getEscapedColumnName(Model, pkField, { columnNameOnly: true });
+        let innerSelect = this.generateSelectStatement(queryEngine.AND[pkField.fieldName].EQ(new Literals.Literal(`${escapedTableNameAlias}.${escapedFieldAlias}`)).PROJECT(new Literals.Literal('1')), this.stackAssign(options, { isSubQuery: true, subQueryOperator: 'EXISTS', noProjectionAliases: true }));
+        return `DELETE FROM ${escapedTableName} AS ${escapedTableNameAlias} WHERE EXISTS (${innerSelect})`;
       } else {
+        let where = this.generateWhereAndOrderLimitOffset(queryEngine, options);
         return `DELETE FROM ${escapedTableName}${(where) ? ` ${where}` : ''}`;
       }
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm-sql-base",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "SQL base support for Mythix ORM",
   "main": "lib/index.js",
   "type": "commonjs",
@@ -33,7 +33,7 @@
   },
   "homepage": "https://github.com/th317erd/mythix-orm-sql-base#readme",
   "peerDependencies": {
-    "mythix-orm": "^1.5.5"
+    "mythix-orm": "^1.5.6"
   },
   "dependencies": {
     "nife": "^1.11.3",