@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/checks/actionsFunctions.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../model/csnUtils');
+const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -52,13 +53,13 @@ function checkActionOrFunction(art, artName, prop, path) {
   function checkActionOrFunctionParameter(param, currPath, actKind) {
     const paramType = param.type ? this.csnUtils.getFinalTypeDef(param.type) : param;
 
-    if (param.default || paramType.default) {
-      this.error('param-default', currPath, { '#': actKind },
-                 {
-                   std: 'Artifact parameters can\'t have a default value', // Not used
-                   action: 'Action parameters can\'t have a default value',
-                   function: 'Function parameters can\'t have a default value',
-                 });
+    if (!isBetaEnabled(this.options, 'optionalActionFunctionParameters') && (param.default || paramType.default)) {
+      this.message('param-default', currPath, { '#': actKind },
+                   {
+                     std: 'Artifact parameters can\'t have a default value', // Not used
+                     action: 'Action parameters can\'t have a default value',
+                     function: 'Function parameters can\'t have a default value',
+                   });
     }
 
     if (paramType.type && this.csnUtils.isAssocOrComposition(param.type)) {

package/lib/checks/selectItems.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { forEachGeneric } = require('../model/csnUtils');
+const { forEachGeneric, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -17,21 +17,103 @@ function validateSelectItems(query) {
   const { SELECT } = query;
   if (!SELECT)
     return;
+  /**
+   * Check for a $self.<assoc> in columns etc. - since the $self.<assoc> references the "outside" view
+   * of the association, this is not allowed.
+   *
+   * @param {string} queryPart Part of the query that is being checked
+   * @returns {Function} Function as callback for applyTransformations
+   */
+  function checkRefForInvalid$Self(queryPart) {
+    const signalError = (error, parent, type) => {
+      if (queryPart === 'columns') {
+        error(null, parent.$path,
+              { name: parent.ref[0], type },
+              'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
+      }
+      else if (queryPart === 'orderBy') {
+        error(null, parent.$path,
+              { id: queryPart, type },
+              'Items of the $(ID)-clause must not contain path steps of type $(TYPE)');
+      }
+      else {
+        error(null, parent.$path,
+              { id: queryPart, name: parent.ref[0], type },
+              'Items of the $(ID)-clause starting with $(NAME) must not contain path steps of type $(TYPE)');
+      }
+    };
+    return function checkForInvalid$SelfInRef(parent) {
+      if (parent.ref && (parent.$scope === '$self' || parent.$scope === '$query')) {
+        const { _links } = parent;
+        for (let j = parent.$scope === '$self' ? 1 : 0; j < _links.length - 1; j++) {
+          if (_links[j].art.target) {
+            if (_links[j].art.on) {
+              // It's an unmanaged association - traversal is always forbidden
+              signalError(this.error, parent, _links[j].art.type);
+            }
+            else {
+              // It's a managed association - access of the foreign keys is allowed
+              const nextRef = parent.ref[j + 1].id || parent.ref[j + 1];
+              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
+                signalError(this.error, parent, _links[j].art.type);
+            }
+          }
+        }
+
+        const last = _links[_links.length - 1];
 
-  forEachGeneric(SELECT, 'columns', (selectItem) => {
-    if (selectItem.ref && (selectItem.ref[0] === '$self' || selectItem.ref[0] === '$projection')) {
-      const pathStepWithTarget = selectItem._links.slice(1).find(link => link.art.target);
-      if (pathStepWithTarget) {
-        this.error(null, selectItem.$path,
-                   { name: selectItem.ref[0], type: pathStepWithTarget.art.type },
-                   'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
+        if (last.art.target && last.art.on) {
+          // It's an unmanaged association - traversal is always forbidden
+          signalError(this.error, parent, last.art.type);
+        } // managed is okay, can be handled via tuple expansion
       }
-    }
-    else if (this.options.transformation === 'hdbcds' && selectItem.xpr && selectItem.func) {
-      this.error(null, selectItem.$path,
-                 'Window functions are not supported by SAP HANA CDS');
-    }
-  });
+    };
+  }
+
+  /**
+   * Check the given assoc filter for usage of $self - in an assoc-filter, you must only
+   * address things on the target side of the association, not from global scope.
+   *
+   * @param {object} parent
+   * @param {string} prop
+   * @param {Array} where
+   */
+  function checkFilterForInvalid$Self(parent, prop, where) {
+    where.forEach((whereStep) => {
+      if (whereStep.ref && ( whereStep.ref[0] === '$projection' || whereStep.ref[0] === '$self')) {
+        this.error('expr-where-unexpected-self', whereStep.$path,
+                   { name: whereStep.ref[0] },
+                   'Path steps inside of filters must not start with $(NAME)');
+      }
+    });
+  }
+
+  const aTCB = (parent, prop) => {
+    applyTransformationsOnNonDictionary(parent, prop, {
+      ref: checkRefForInvalid$Self(prop).bind(this),
+      where: checkFilterForInvalid$Self.bind(this),
+    }, { skipStandard: { on: true }, drillRef: true });
+  };
+
+  const transformers = {
+    columns: aTCB,
+    groupBy: aTCB,
+    orderBy: aTCB,
+    having: aTCB,
+    where: aTCB,
+  };
+
+  if (this.options.transformation === 'hdbcds') {
+    transformers.xpr = (parent) => {
+      if (parent.func) {
+        this.error(null, parent.$path,
+                   'Window functions are not supported by SAP HANA CDS');
+      }
+    };
+  }
+
+  applyTransformationsOnNonDictionary(query, 'SELECT', transformers );
+
   // .call() with 'this' to ensure we have access to the options
   rejectManagedAssociationsAndStructuresForHdbcdsNames.call(this, SELECT, SELECT.$path);
 }

package/lib/checks/types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getUtils, isBuiltinType, hasAnnotationValue } = require('../model/csnUtils');
+const { getUtils, hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -55,7 +55,7 @@ function checkElementTypeDefinitionHasType(member, memberName, prop, path) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(member)) {
-    warnAboutMissingType(this.error, path, memberName, true);
+    errorAboutMissingType(this.error, path, memberName, true);
     return;
   }
 
@@ -96,7 +96,7 @@ function checkTypeDefinitionHasType(artifact, artifactName, prop, path) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(artifact)) {
-    warnAboutMissingType(this.error, path, artifactName);
+    errorAboutMissingType(this.error, path, artifactName);
     return;
   }
 
@@ -157,9 +157,8 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
  * @param {CSN.Path} path the path to the element or the artifact
  * @param {string} name of the element or the artifact which is dubious
  * @param {boolean} isElement indicates whether we are dealing with an element or an artifact
- * @todo Rename, is an error not a warning
  */
-function warnAboutMissingType(error, path, name, isElement = false) {
+function errorAboutMissingType(error, path, name, isElement = false) {
   error('check-proper-type', path, { art: name, '#': isElement ? 'elm' : 'std' }, {
     std: 'Dubious type $(ART) without type information',
     elm: 'Dubious element $(ART) without type information',
@@ -174,12 +173,10 @@ function warnAboutMissingType(error, path, name, isElement = false) {
  *
  * @param {CSN.Artifact} artifact the artifact to check
  * @returns {boolean} indicates whether the artifact has type information
- * @todo What is the point of isBuiltinType here if we check for artifact.type at the end?
  */
 function hasArtifactTypeInformation(artifact) {
   // When is what property set?
-  return isBuiltinType(artifact.type) || // => `Integer`
-    artifact.elements ||  // => `type A {}`
+  return artifact.elements ||  // => `type A {}`
     artifact.items ||     // => `type A : array of Integer`
     artifact.enum ||      // => `type A : Integer enum {}`, `type` also set
     artifact.target ||    // => `type A : Association to B;`

package/lib/checks/validator.js

@@ -32,7 +32,6 @@ const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
-const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
 const {
   checkSqlAnnotationOnArtifact,
@@ -62,7 +61,7 @@ const forHanaArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
+const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */

package/lib/compiler/assert-consistency.js

@@ -97,7 +97,6 @@ function assertConsistency( model, stage ) {
         '$lateExtensions',
         '_entities', '$entity',
         '$blocks',
-        '$newfeatures',
         '$messageFunctions',
         '$functions',
         '$volatileFunctions',
@@ -143,7 +142,6 @@ function assertConsistency( model, stage ) {
     },
     fileDep: { test: TODO },    // in usings
     $frontend: { parser: true, test: isString, enum: [ 'cdl', 'json', 'xml' ] },
-    $newfeatures: { test: TODO }, // if new features have been used which break the old backends
     messages: {
       enumerable: () => true,  // does not matter (non-enum std), enum in CSN/XML parser
       test: isArray( TODO ),
@@ -175,7 +173,6 @@ function assertConsistency( model, stage ) {
         return innerDict( val, parent, lang, spec );
       } ),
     },
-    _assocSources: { kind: true, test: TODO }, // just null: isArray( inDefinitions ) during resolve
     $magicVariables: {
       // $magicVariables contains "builtin" artifacts that differ from
       // "normal artifacts" and therefore have a custom schema
@@ -256,6 +253,7 @@ function assertConsistency( model, stage ) {
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
+          '_extension', // for unapplied extensions
         ],
       },
       none: { optional: () => true }, // parse error
@@ -375,13 +373,21 @@ function assertConsistency( model, stage ) {
     },
     // locations of parentheses pairs around expression:
     $parens: { parser: true, test: TODO },
+    $prefix: { test: isString }, // compiler-corrected path prefix
     $syntax: {
       parser: true,
       kind: [ 'entity', 'view', 'type', 'aspect' ],
       test: isString,            // CSN parser should check for 'entity', 'view', 'projection'
     },
     value: {
-      optional: [ 'location', '$inferred', 'sort', 'nulls' ],
+      optional: [
+        'location', '$inferred', 'sort', 'nulls',
+        'param', 'scope', // for dynamic parameter '?'
+        // through cast() with enum through CSN->XSN
+        // TODO: re-check #9225, this should be directly in the query element,
+        // not inside value, no `enum` inside `cast`!
+        'elements', 'items', 'enum', '$expand', 'target',
+      ],
 
       kind: true,
       test: expression,         // properties below are "sub specifications"
@@ -439,7 +445,10 @@ function assertConsistency( model, stage ) {
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
-      optional: [ 'name', '$duplicate', '$expected', 'args', 'suffix' ],
+      optional: [
+        'name', '$duplicate', '$expected', 'args', 'suffix',
+        'param', 'scope', // for dynamic parameter '?'
+      ],
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
@@ -456,7 +465,7 @@ function assertConsistency( model, stage ) {
       optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: TODO },
+    $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
     $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
@@ -475,7 +484,7 @@ function assertConsistency( model, stage ) {
     variant: { test: TODO }, // TODO: not set in CDL parser
     element: { test: TODO }, // TODO: { test: isString },
     action: { test: isString },
-    param: { test: isString },
+    param: { test: TODO },
     alias: { test: isString },
     expectedKind: { kind: [ 'extend' ], inherits: 'kind' },
     virtual: { kind: true, test: locationVal() },
@@ -528,7 +537,6 @@ function assertConsistency( model, stage ) {
     _service: { kind: true, test: TODO },
     _main: { kind: true, test: TODO },
     _artifact: { test: TODO },
-    _base: { test: TODO, kind: true },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
     _joinParent: { test: TODO },
@@ -552,6 +560,7 @@ function assertConsistency( model, stage ) {
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
         'limit', '_status',
+        '_extension', // for unapplied extensions
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -585,21 +594,57 @@ function assertConsistency( model, stage ) {
     // (it can contain the artifact itself with no/failed autoexposure):
     _descendants: { kind: [ 'entity' ], test: isDictionary( isArray( TODO ) ) },
 
-    $errorReported: { parser: true, test: isBoolean },     // to avoid duplicate messages
+    $errorReported: { parser: true, kind: true, test: isString },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
-    $inferred: { parser: true, kind: true, test: isString },
+    $inferred: {
+      parser: true,
+      kind: true,
+      test: isOneOf([
+        // Uppercase values are used in logic, lowercase value are "just for us", i.e.
+        // debugging or to add non-enumerable properties such as $generated in Universal CSN.
+        // However, that is no longer true. For example, `autoexposed` is used in populate.js
+        // as well.
+        'IMPLICIT',
+        'REDIRECTED',
+
+        '$autoElement', // for magicVars: $user is automatically changed to $user.id
+        '$generated', // compiler generated annotations, e.g. @Core.Computed
+        '*', // inferred from query wildcard
+        'as', // query alias name
+        'aspect-composition',
+        'autoexposed', // for auto-exposed entities (they can't be referred to)
+        'cast', // type from cast() function
+        'composition-entity',
+        'copy', // only used in rewriteCondition(): On-condition is copied
+        'duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
+        'expand-element', // expanded elements
+        'expand-param',  // expanded params (difference to expand-element only for debugging)
+        'include', // through includes, e.g. `entity E : F {}`
+        'keys',
+        'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
+        'localized-entity', // `.texts` entity
+        'nav', // only used for MASKED, TODO(v4): Remove
+        'none', // only used in ensureColumnName(): Used in object representing empty alias
+        'query', // inferred query properties, e.g. `key`
+        'rewrite', // on-conditions or FKeys are rewritten
+      ]),
+    },
 
     // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
     // client, universal: render expanded elements?  gensrc: produce annotate statements?
-    $expand: { kind: true, test: isString }, // TODO: rename it to $elementsExpand ?
+    // TODO: rename it to $elementsExpand ?
+    $expand: {
+      kind: true,
+      // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
+      test: isOneOf([ 'origin', 'annotate', 'target' ]),
+    },
 
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
-    $a2j: { kind: true, enumerable: true, test: TODO },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
-    $expected: { parser: true, test: isString },
+    $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
     $volatileFunctions: { test: TODO },
@@ -859,6 +904,13 @@ function assertConsistency( model, stage ) {
       isString(node, parent, prop, spec);
   }
 
+  function isOneOf(values) {
+    return function isOneOfInner( node, parent, prop ) {
+      if (!values.includes(node))
+        throw new Error( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
+    };
+  }
+
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
       throw new Error( `Expected string${ at( [ node, parent ], prop ) }` );

package/lib/compiler/base.js

@@ -16,16 +16,18 @@ const kindProperties = {
   namespace: { artifacts: true }, // on-the-fly context
   context: { artifacts: true, normalized: 'namespace' },
   service: { artifacts: true, normalized: 'namespace' },
-  entity: { elements: true, actions: true, params: () => false },
+  entity: {
+    elements: true, actions: true, params: () => false, include: true,
+  },
   select: { normalized: 'select', elements: true },
   $join: { normalized: 'select' },
   $tableAlias: { normalized: 'alias' }, // table alias in select
   $self: { normalized: 'alias' }, // table alias in select
   $navElement: { normalized: 'element' },
   $inline: { normalized: 'element' }, // column with inline property
-  event: { elements: true },
-  type: { elements: propExists, enum: propExists },
-  aspect: { elements: propExists },
+  event: { elements: true, include: true },
+  type: { elements: propExists, enum: propExists, include: true },
+  aspect: { elements: propExists, actions: true, include: true },
   annotation: { elements: propExists, enum: propExists },
   enum: { normalized: 'element' },
   element: { elements: propExists, enum: propExists, dict: 'elements' },

package/lib/compiler/builtins.js

@@ -1,7 +1,7 @@
 // The builtin artifacts of CDS
 
 // TODO: split this file
-// - in base/: common definitions
+// - in base/: common definitions, datetime formats
 // - in compiler/: XSN-specific
 // - in ?: CSN-specific
 
@@ -154,12 +154,14 @@ function compileArg( src ) {
     expr: src.expr || [],
     separator: src.separator || [],
   };
-  for (const generic of [ 'intro', 'expr', 'separator' ]) { // intro before expr!
+  for (const generic of [ 'intro', 'expr', 'separator' ]) {
+    // intro before expr: if both intro and expr, tag as 'expr'
     for (const token of src[generic] || [])
       tgt[token] = generic;
   }
-  if (tgt.intro)             // same token could be in both 'expr' and 'intro':
-    tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
+  // As GenericIntro is always together with GenericExpr, only mention those
+  // which are not already proposed for GenericExpr:
+  tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
   return tgt;
 }
 
@@ -193,6 +195,92 @@ const magicVariables = {
 
 // see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP Cds via function
 
+/**
+ * Patterns for literal token tests and creation.  The value is a map from the
+ * `prefix` argument of function `quotedliteral` to the following properties:
+ *  - `test_msg`: error message which is issued if `test_fn` fails.
+ *  - `test_fn`: function called with argument `value`, fails falsy return value
+ *  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
+ *  - `unexpected_char`: regular expression matching an illegal character in `value`,
+ *    the error location is only correct for a literal <prefix>'<value>'
+ *  - `literal`: the value which is used instead of `prefix` in the AST
+ * TODO: we might do a range check (consider leap seconds, i.e. max value 60),
+ *       but always allow Feb 29 (no leap year computation)
+ * Notes:
+ *  - Dates/Times as defined in ISO 8601, see <https://en.wikipedia.org/wiki/ISO_8601>
+ */
+const quotedLiteralPatterns = {
+  x: {
+    test_variant: 'uneven-hex',
+    test_fn: (str => Number.isInteger(str.length / 2)),
+    unexpected_variant: 'invalid-hex',
+    unexpected_char: /[^0-9a-f]/i,
+    json_type: 'string',
+  },
+  time: {
+    test_variant: 'time',
+    test_fn: (x) => {
+      // Leading `T` allowed in ISO 8601.
+      const match = x.match( /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/ );
+      return match !== null && checkTime( match[1], match[2], match[3] );
+    },
+    json_type: 'string',
+  },
+  date: {
+    test_variant: 'date',
+    test_fn: (x) => {
+      const match = x.match( /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/ );
+      return match !== null && checkDate( match[1], match[2], match[3] );
+    },
+    json_type: 'string',
+  },
+  timestamp: {
+    test_variant: 'timestamp',
+    test_fn: (x) => {
+      // eslint-disable-next-line max-len
+      const match = x.match( /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?$/ );
+      return match !== null && checkDate( match[1], match[2], match[3] ) &&
+        checkTime( match[4], match[5], match[6] );
+    },
+    json_type: 'string',
+  },
+};
+
+/**
+ * Check that the given date is within boundaries.
+ * We can't use Date.parse() since that also allows non-standard values (2022-02-31 for example).
+ * Checks according to ISO 8601.
+ *
+ * @returns {boolean} True if the date is valid.
+ */
+function checkDate(year, month, day) {
+  // Negative years are allowed
+  year = Math.abs(Number.parseInt(year, 10));
+  month = Number.parseInt(month, 10);
+  day = Number.parseInt(day, 10);
+  // If any is NaN, the condition will be false.
+  // Year 0 does not exist, but ISO 8601 allows it and defines it as 1 BC.
+  return !Number.isNaN(year) && month > 0 && month < 13 && day > 0 && day < 32;
+}
+
+/**
+ * Check that the given time is within boundaries.
+ * Checks according to ISO 8601.
+ *
+ * @returns {boolean} True if the date is valid.
+ */
+function checkTime(hour, minutes, seconds) {
+  hour = Number.parseInt(hour, 10);
+  minutes = Number.parseInt(minutes, 10);
+  seconds = seconds ? Number.parseInt(seconds, 10) : 0;
+  if (hour === 24) // allow 24:00:00 (ISO 8601 version earlier than 2019)
+    return minutes === 0 && seconds === 0;
+  // If any is NaN, the condition will be false.
+  return hour >= 0 && hour < 24 &&
+    minutes >= 0 && minutes < 60 &&
+    seconds >= 0 && seconds < 61; // we allow 60 for lead seconds
+}
+
 /** All types belong to one category. */
 const typeCategories = {
   string: [],
@@ -403,6 +491,7 @@ module.exports = {
   typeParameters,
   functionsWithoutParens,
   specialFunctions,
+  quotedLiteralPatterns,
   initBuiltins,
   isInReservedNamespace,
   isBuiltinType,

package/lib/compiler/checks.js

@@ -414,7 +414,7 @@ function check( model ) {       // = XSN
     }
   }
 
-  // TODO: make this part of the the name resolution in the compiler
+  // TODO: make this part of the name resolution in the compiler
   // Check that queries in 'art' do not contain unmanaged associations in GROUP BY or ORDER BY
   function checkNoUnmanagedAssocsInGroupByOrderBy( query ) {
     const art = query._main;    // TODO - remove, use query for semantic location