@sap/cds-compiler 6.9.3 → 7.0.1

package/lib/transform/forRelationalDB.js

@@ -3,20 +3,19 @@
 const { isBetaEnabled } = require('../base/specialOptions');
 const shuffleGen = require('../utils/shuffle');
 const {
-  forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
+  applyTransformationsOnNonDictionary,
   getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
-  walkCsnPath, isPersistedOnDatabase,
+  walkCsnPath,
 } = require('../model/csnUtils');
 const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const {
-  csnRefs, pathId, traverseQuery, columnAlias,
+  csnRefs, traverseQuery,
 } = require('../base/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
-const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
 const { addTenantFields } = require('../transform/addTenantFields');
-const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
+const { addLocalizationViewsWithJoins } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { setProp, forEach } = require('../utils/objectUtils');
@@ -36,7 +35,7 @@ const associations = require('./db/associations');
 const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags, removeFeatureFlags } = require('./featureFlags');
-const { cloneCsnNonDict, cloneFullCsn } = require('../base/cloneCsn');
+const { cloneFullCsn } = require('../base/cloneCsn');
 const { processSqlServices, createServiceDummy } = require('./db/processSqlServices');
 const { expandWildcard } = require('./db/expansion');
 const removeEnums = require('../checks/enums');
@@ -105,14 +104,17 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   const setQueryFeatureFlags = getQueryFeatureFlagSetter(csn);
   const setDefinitionFeatureFlags = getDefinitionFeatureFlagSetter(csn, options);
 
-  // csnRefs cache init, expandWildcards, ensureColumnNames, and feature flags in one loop
+  // csnRefs cache init and feature flags in one loop
   // as preparation for the following transformations and validations
   forEachDefinition(csn, (def) => {
     csnUtils.initDefinition(def);
     if (def.query || def.projection) {
       traverseQuery(def.query || def, null, null, (query) => {
-        expandWildcard(query, csnUtils, options);
-        ensureColumnNames(query, csnUtils, options);
+        // Normalize implicit wildcards (no columns → ['*']) so downstream code
+        // can always rely on an explicit columns array being present.
+        const SELECT = query.SELECT ?? query.projection;
+        if (SELECT)
+          SELECT.columns ??= [ '*' ];
         setQueryFeatureFlags(query);
       });
     }
@@ -120,9 +122,22 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   });
 
   const dialect = options.sqlDialect;
-  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
-  if (!doA2J)
-    forEachDefinition(csn, handleMixinOnConditions);
+
+  const hasCalcElements = csn.meta?.[featureFlags]?.$calculatedElements;
+
+  // Only expand wildcards early for views whose inferred elements contain calculated
+  // elements (have $calc). All other views defer expansion past validation to keep
+  // column lists compact during the expensive enrichment + validation passes.
+  if (hasCalcElements) {
+    forEachDefinition(csn, (def) => {
+      if ((def.query || def.projection) && defHasCalculatedElements(def)) {
+        traverseQuery(def.query || def, null, null, (query) => {
+          expandWildcard(query, csnUtils, options);
+          ensureColumnNames(query, csnUtils, options);
+        });
+      }
+    });
+  }
 
   // replace all type refs to builtin types with direct type
   transformUtils.rewriteBuiltinTypeRef(csn);
@@ -137,7 +152,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // exit if validators found errors
   throwWithAnyError();
 
-  if (csn.meta?.[featureFlags]?.$calculatedElements)
+  if (hasCalcElements)
     rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
   timetrace.start('Where-Exists handling');
@@ -163,12 +178,21 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     assertUnique.prepare(csn, options, messageFunctions),
   ]);
 
-  if (doA2J) {
-    // Expand a structured thing in: keys, columns, order by, group by
-    // In addition, kill all non-sql-backend relevant annotations
-    expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils, { processAnnotations: true });
-    bindCsnReference();
-  }
+  // Deferred wildcard expansion for any remaining unexpanded queries.
+  // expandWildcard() returns early when no '*' exists, so already-expanded views are a no-op.
+  forEachDefinition(csn, (def) => {
+    if (def.query || def.projection) {
+      traverseQuery(def.query || def, null, null, (query) => {
+        expandWildcard(query, csnUtils, options);
+        ensureColumnNames(query, csnUtils, options);
+      });
+    }
+  });
+
+  // Expand a structured thing in: keys, columns, order by, group by
+  // In addition, kill all non-sql-backend relevant annotations
+  expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils, { processAnnotations: true });
+  bindCsnReference();
 
   timetrace.stop('Expand Structures (expressions + refs)');
 
@@ -196,7 +220,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // With that, we could still ensure the processing order (assuming we don't run into problems with scoping).
   // To analyze: Increased memory vs. saved cycles
   // Looked at it with AFC: This is only a small part of the overall processing time, enrich step of validator is just as expensive
-  if (doA2J) {
+  {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
     flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, pathDelimiter);
@@ -206,17 +230,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // No structured elements exists anymore
     flattening.flattenElements(csn, options, messageFunctions, pathDelimiter);
   }
-  else {
-    // For to.hdbcds with naming mode hdbcds we also need to resolve the types
-    flattening.resolveTypeReferences(csn, options, messageFunctions, new WeakMap(), pathDelimiter);
-  }
   timetrace.stop('Flattening (refs + elements)');
 
   // With flattening errors, it makes little sense to continue.
   throwWithAnyError();
 
-  if (doA2J)
-    handleAssocToJoins();
+  handleAssocToJoins();
 
   if (options.testMode && csn.definitions)
     csn.definitions = shuffleDict(csn.definitions);
@@ -269,25 +288,22 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions),
   ]);
 
-  if (doA2J) {
-    // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
-    flattening.handleManagedAssociationsAndCreateForeignKeys(
-      csn, options, messageFunctions, pathDelimiter, true, csnUtils,
-      { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') }
-    );
-    forEachDefinition(csn, flattenIndexes);
-    // Managed associations get an on-condition - in views and entities
-    associations.attachOnConditions(csn, csnUtils, pathDelimiter);
-
-    // Add the foreign keys also to the columns if the association itself was explicitly selected
-    // TODO: Extend the expansion to also expand managed to their foreign
-    // TODO: Remember where in .elements we had associations and do it then?
-    applyTransformations(csn, {
-      columns: expandManagedToFksInArray(),
-      groupBy: expandManagedToFksInArray(true),
-      orderBy: expandManagedToFksInArray(true),
-    }, [], { allowArtifact: artifact => artifact.query !== undefined || artifact.projection !== undefined });
-  }
+  flattening.handleManagedAssociationsAndCreateForeignKeys(
+    csn, options, messageFunctions, pathDelimiter, true, csnUtils,
+    { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') }
+  );
+  forEachDefinition(csn, flattenIndexes);
+  // Managed associations get an on-condition - in views and entities
+  associations.attachOnConditions(csn, csnUtils, pathDelimiter);
+
+  // Add the foreign keys also to the columns if the association itself was explicitly selected
+  // TODO: Extend the expansion to also expand managed to their foreign
+  // TODO: Remember where in .elements we had associations and do it then?
+  applyTransformations(csn, {
+    columns: expandManagedToFksInArray(),
+    groupBy: expandManagedToFksInArray(true),
+    orderBy: expandManagedToFksInArray(true),
+  }, [], { allowArtifact: artifact => artifact.query !== undefined || artifact.projection !== undefined });
 
   {
     // Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
@@ -296,8 +312,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // Allow using managed associations as steps in on-conditions to access their fks
     // To be done after handleAssociations, since then the foreign keys of the managed assocs
     // are part of the elements
-    if (doA2J)
-      fns.push(associations.getFKAccessFinalizer(csn, options, csnUtils, pathDelimiter, true));
+    fns.push(associations.getFKAccessFinalizer(csn, options, csnUtils, pathDelimiter, true));
 
     forEachDefinition(csn, fns);
   }
@@ -307,33 +322,19 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // handled and before handleDBChecks which removes the localized attribute.
   // Association elements of localized convenience views do not have hidden properties
   // like $managed set, so we cannot do this earlier on.
-  if (doA2J)
-    addLocalizationViewsWithJoins(csn, options);
-  else
-    addLocalizationViews(csn, options);
+  addLocalizationViewsWithJoins(csn, options);
 
   forEachDefinition(csn, [
-    (definition, artName, prop, path) => {
-      if (!doA2J && definition.query && isPersistedOnDatabase(definition)) {
-        // reject managed association and structure publishing for to-hdbcds.hdbcds
-        const that = { csnUtils, options, error };
-        rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path);
-      }
-    },
     // Transform '$self' in backlink associations to appropriate key comparisons
     // Must happen before draft processing because the artificial ON-conditions in generated
     // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
     // But it must also happen after flattenForeignKeys has been called for all artifacts,
     // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
-    backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, doA2J),
+    backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, true),
   ]);
 
-  /**
-   * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
-   * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
-   * hence we do not generate the referential constraints for them.
-   */
-  if (options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2' && doA2J)
+  // Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
+  if (options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2')
     createReferentialConstraints(csn, options);
 
   // no constraints for drafts
@@ -364,31 +365,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     generateFioriTreeViews(artifact, artifactName, messageFunctions, csnUtils, { setAnnotation, addElement, createScalarElement }, options);
   }, transformViews ]);
 
-  if (!doA2J) {
-    forEachDefinition(csn, [
-      // Strip 'key' property from type elements
-      removeKeyPropInType,
-      (artifact, artifactName) => {
-        if (artifact.kind === 'type') {
-          forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
-            // Check type parameters (length, precision, scale ...)
-            if (!member.$ignore) {
-              if (member.type)
-                checkTypeParameters(member, artifact, path);
-              if (member.items?.type)
-                checkTypeParameters(member.items, artifact, path.concat([ 'items' ]));
-            }
-          }, [ 'definitions', artifactName ]);
-        }
-      },
-    ]);
-  }
-
   // TODO: Could we maybe merge this with the final applyTransformations?
   applyTransformations(csn, {
-    type: (parent, prop, type, path) => {
-      checkTypeParameters(parent, csn.definitions[path[1]], path);
-    },
     $tableConstraints: (parent, prop, tableConstraints, path) => {
       /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
       assertConstraintIdentifierUniqueness(parent, path[1], path, error);
@@ -400,9 +378,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         if ((!element.virtual || artifact.query))
           csnUtils.addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(name, options.sqlMapping, options.sqlDialect), element);
       });
-      // Remove leading $self to keep renderer-diffs smaller
-      if (doA2J && options.transformation === 'hdbcds')
-        flattening.removeLeadingSelf(parent, prop, elements);
     },
   }, [ (definitions, artifactName, artifact) => {
     // Attach @cds.persistence.name to artifacts
@@ -456,7 +431,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
       }
     },
     includes: killProp,
-    masked: killProp,
     localized: killProp,
   };
 
@@ -467,25 +441,24 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     };
   }
 
-  if (options.sqlDialect === 'hana' && options.withHanaAssociations === false && doA2J)
+  if (options.sqlDialect === 'hana' && options.withHanaAssociations === false)
     killers.target = killParent;
 
 
   const killTypes = [];
 
-  if (doA2J) { // replace types and aspects with dummies to shrink overall CSN size
-    killers.kind = (parent, prop, kind, path) => {
-      if (kind === 'type' || kind === 'aspect') {
-        const artifactName = path[1];
-        killTypes.push(() => {
-          csn.definitions[artifactName] = {
-            kind,
-            type: 'cds.Integer',
-          };
-        });
-      }
-    };
-  }
+  // replace types and aspects with dummies to shrink overall CSN size
+  killers.kind = (parent, prop, kind, path) => {
+    if (kind === 'type' || kind === 'aspect') {
+      const artifactName = path[1];
+      killTypes.push(() => {
+        csn.definitions[artifactName] = {
+          kind,
+          type: 'cds.Integer',
+        };
+      });
+    }
+  };
 
   applyTransformations(csn, killers, [], { skipIgnore: false });
 
@@ -524,66 +497,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     Object.assign(csnUtils, csnRefApi);
   }
 
-  // For non-A2J only
-  function handleMixinOnConditions(artifact, artifactName) {
-    if (!artifact.query) // projections can't have mixins
-      return;
-    forAllQueries(artifact.query, (query, path) => {
-      const { mixin } = query.SELECT || {};
-      if (mixin) {
-        query.SELECT.columns
-          // filter for associations which are used in the SELECT
-          .filter(c => c.ref && c.ref.length > 1)
-          .forEach((usedAssoc) => {
-            const assocName = pathId(usedAssoc.ref[0]);
-            const mixinAssociation = mixin[assocName];
-            if (mixinAssociation)
-              mixinAssociation.on = getResolvedMixinOnCondition(mixinAssociation, query, assocName, path.concat([ 'mixin', assocName ]));
-          });
-      }
-    }, [ 'definitions', artifactName, 'query' ]);
-  }
-
-  // For non-A2J only
-  function getResolvedMixinOnCondition(mixinAssociation, query, assocName, path) {
-    const referencedThroughStar = query.SELECT.columns.some(column => column === '*');
-    return mixinAssociation.on.map(handeMixinOnConditionPart);
-
-    function handeMixinOnConditionPart(onConditionPart, i) {
-      let columnToReplace;
-      if (onConditionPart.ref && (onConditionPart.ref[0] === '$projection' || onConditionPart.ref[0] === '$self')) {
-        const { links } = csnUtils.inspectRef(path.concat([ 'on', i ]));
-        if (links)
-          columnToReplace = onConditionPart.ref[links.length - 1];
-      }
-      if (!columnToReplace)
-        return onConditionPart;
-
-      const replaceWith = query.SELECT.columns.find(col => columnAlias(col) === columnToReplace);
-      if (!replaceWith && referencedThroughStar) {
-        // not explicitly in column list, check query sources
-        // get$combined also includes elements which are part of "excluding {}"
-        // this shouldn't be an issue here, as such references get rejected
-        const elementsOfQuerySources = csnUtils.get$combined(query);
-        forEach(elementsOfQuerySources, (id, element) => {
-          // if the ref points to an element which is not explicitly exposed in the column list,
-          // but through the '*' operator -> replace the $projection / $self with the correct source entity
-          if (id === columnToReplace)
-            onConditionPart.ref[0] = element[0].parent;
-        });
-        return onConditionPart;
-      }
-      else if (replaceWith) {
-        const clone = cloneCsnNonDict(replaceWith, options);
-        delete clone.cast;  // No implicit CAST in on-condition
-        delete clone.as;
-        return clone;
-      }
-
-      return onConditionPart;
-    }
-  }
-
 
   /**
    * @param {CSN.Artifact} artifact
@@ -593,21 +506,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     if (!artifact.$ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
-        // First pass: Set alias name for SELECTs without table alias. Required for setting proper table aliases
-        // for HDBCDS in naming mode HDBCDS.  We use the same schema as the core-compiler, so duplicates should
-        // have already been reported.
-        if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
-          let selectDepth = 0;
-          traverseQuery(artifact.query, null, null, (query, fromSelect) => {
-            if (!query.ref && !query.as && fromSelect) {
-              // Use +1; for UNION, it's the next select, for SELECT, it's increased later.
-              query.as = `$_select_${ selectDepth + 1 }__`;
-            }
-            if (query.SELECT)
-              ++selectDepth;
-          });
-        }
-
         const process = (parent, prop, query, path) => {
           transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop));
           replaceAssociationsInGroupByOrderBy(parent, options, csnUtils.inspectRef, error, path.concat(prop));
@@ -620,19 +518,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   }
 
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function removeKeyPropInType(artifact, artifactName) {
-    if (!doA2J && !artifact.$ignore && artifact.kind === 'type') {
-      forEachMemberRecursively(artifact, (member) => {
-        if (member.key)
-          delete member.key;
-      }, [ 'definitions', artifactName ]);
-    }
-  }
-
   function handleAssocToJoins() {
     timetrace.start('A2J');
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
@@ -688,116 +573,9 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // Length/Precision/Scale is done in addDefaultTypeFacets
   }
 
-  /**
-   * Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
-
-   * @param {*} node
-   * @param {CSN.Artifact} artifact
-   * @param {CSN.Path} path
-   */
-  function checkTypeParameters(node, artifact, path) {
-    if (node.type && !node.virtual) {
-      const absolute = node.type;
-      switch (absolute) {
-        case 'cds.String':
-        case 'cds.Binary':
-        case 'cds.hana.VARCHAR': {
-          checkTypeParamValue(node, 'length', { min: 1, max: 5000 }, path);
-          break;
-        }
-        case 'cds.Decimal': {
-          // Don't check with "plain"?
-          if (node.precision || node.scale) {
-            checkTypeParamValue(node, 'precision', { max: 38 }, path);
-            checkTypeParamValue(node, 'scale', { max: node.precision }, path);
-          }
-          break;
-        }
-
-        case 'cds.hana.BINARY':
-        case 'cds.hana.NCHAR':
-        case 'cds.hana.CHAR': {
-          checkTypeParamValue(node, 'length', { min: 1, max: 2000 }, path);
-          break;
-        }
-        case 'cds.hana.ST_POINT':
-        case 'cds.hana.ST_GEOMETRY': {
-          checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
-          break;
-        }
-        case 'cds.Map': {
-          if (options.sqlDialect === 'plain')
-            error('ref-unsupported-type', path, { '#': 'dialect', type: node.type, value: 'plain' });
-          else if (options.transformation === 'hdbcds')
-            error('ref-unsupported-type', path, { '#': 'hdbcds', type: node.type, value: options.sqlDialect });
-          break;
-        }
-        case 'cds.Vector': {
-          if (options.sqlDialect === 'plain') {
-            error('ref-unsupported-type', path, {
-              '#': 'dialect',
-              type: node.type,
-              value: options.sqlDialect,
-            });
-          }
-          else if (options.transformation === 'hdbcds') {
-            error('ref-unsupported-type', path, {
-              '#': 'hdbcds', type: node.type, value: options.sqlDialect,
-            });
-          }
-          // Technical limitation of SQLite vector extension
-          else if (options.sqlDialect === 'sqlite' && node.length && node.length % 4 !== 0) {
-            error('ref-unexpected-args', path, {
-              '#': 'vector_length', elemref: path.at(-1),
-            });
-          }
-          break;
-        }
-        default:
-          break; // nothing to check for unknown types
-      }
-    }
-
-    // Check that the value of the type property `paramName` (e.g. length, precision, scale ...) is of `expectedType`
-    // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
-    function checkTypeParamValue(node, paramName, range = null, path = null) {
-      const paramValue = node[paramName];
-      if (paramValue == null) {
-        if (options.toSql || artifact.query || ![ 'cds.Binary', 'cds.hana.BINARY', 'cds.hana.NCHAR', 'cds.hana.CHAR' ].includes(node.type))
-          return true;
-
-        return error('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
-      }
-      if (range) {
-        if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
-          error('type-unexpected-argument', path, {
-            '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false,
-          });
-          return false;
-        }
-        if (range.min && paramValue < range.min) {
-          error('type-unexpected-argument', path, {
-            '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false,
-          });
-          return false;
-        }
-      }
-      return true;
-    }
-  }
 
   /**
-  * Check if the maximum length of the value of the given type is restricted.
-  *
-  * @param {string} type
-  * @returns {boolean}
-  */
-  function isMaxParameterLengthRestricted(type) {
-    return !(options.toSql && type === 'cds.String' && (options.sqlDialect === 'sqlite' || options.sqlDialect === 'plain'));
-  }
 
-  /**
-   * Flatten technical configuration stuff
    *
    * @param {CSN.Artifact} art
    * @param {string} artName Artifact Name
@@ -861,6 +639,20 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   }
 }
 
+function defHasCalculatedElements(def) {
+  return _hasCalcElement(def.elements);
+}
+
+function _hasCalcElement(elements) {
+  for (const name in elements) {
+    if (elements[name].$calc)
+      return true;
+    if (elements[name].elements && _hasCalcElement(elements[name].elements))
+      return true;
+  }
+  return false;
+}
+
 module.exports = {
   transformForRelationalDBWithCsn,
 };