@sap/cds-compiler 6.7.3 → 6.8.0

package/lib/sql-identifier.js

@@ -57,18 +57,21 @@ const sqlDialects = {
     reservedWords: keywords.postgres,
     effectiveName: name => name.toLowerCase(),
     asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
+    maxIdentifierLength: 63,
   },
   hana: {
     regularRegex: /^[A-Za-z_][A-Za-z_$#0-9]*$/,
     reservedWords: keywords.hana,
     effectiveName: name => name.toUpperCase(),
     asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
+    maxIdentifierLength: 127,
   },
   hdbcds: {
     regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
     reservedWords: keywords.hdbcds,
     effectiveName: name => name,
     asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
+    maxIdentifierLength: 127,
   },
 };
 
@@ -98,4 +101,9 @@ function delimitedId( name, dialect ) {
   return s.asDelimitedId( name );
 }
 
-module.exports = { smartId, smartFuncId, delimitedId };
+module.exports = {
+  smartId,
+  smartFuncId,
+  delimitedId,
+  sqlDialects,
+};

package/lib/{model → tool-lib}/enrichCsn.js

@@ -39,11 +39,11 @@
 
 'use strict';
 
-const { csnRefs, artifactProperties } = require('./csnRefs');
+const { csnRefs, artifactProperties } = require('../base/csnRefs');
 const { locationString } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
 const { isAnnotationExpression } = require('../base/builtins');
-const shuffleGen = require('../base/shuffle');
+const shuffleGen = require('../utils/shuffle');
 
 function enrichCsn( csn, options = {} ) {
   const transformers = {

package/lib/{model → tool-lib}/revealInternalProperties.js

@@ -283,7 +283,8 @@ function revealInternalProperties( model, nameOrPath ) {
   }
 
   function revealSingleExtension( node, parent ) {
-    return (node.kind && node.__unique_id__ == null && node.$effectiveSeqNo == null && !node.builtin)
+    return (node.kind && node.__unique_id__ == null &&
+            node.$effectiveSeqNo == null && !node.builtin)
       ? reveal( node, parent )
       : artifactIdentifier( node, parent );
   }

package/lib/transform/addTenantFields.js

@@ -23,7 +23,7 @@ const {
   traverseQuery,
   implicitAs,
   pathId,
-} = require( '../model/csnRefs' );
+} = require( '../base/csnRefs' );
 
 const annoTenantIndep = '@cds.tenant.independent';
 

package/lib/transform/db/applyTransformations.js

@@ -12,7 +12,7 @@
  */
 
 
-const { setProp } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
 const { isAnnotationExpression } = require('../../base/builtins');
 
 

package/lib/transform/db/assertUnique.js

@@ -78,7 +78,7 @@ function processAssertUnique( csn, options, messageFunctions ) {
         // constraintKey is the concatenation of all flattened paths (order is important)
         let constraintKey = '';
         flattenedPathObjects.forEach((p) => {
-          const pstr = p.ref.map(path => path.id).join('.');
+          const pstr = p.ref.map(path => path.id || path).join('.');
           constraintKey += pstr;
           if (!pathxrefs[pstr])
             pathxrefs[pstr] = 1;

package/lib/transform/db/assocsToQueries/transformExists.js

@@ -3,7 +3,7 @@
 const {
   forAllQueries, forEachDefinition, walkCsnPath, transformExpression,
 } = require('../../../model/csnUtils');
-const { setProp } = require('../../../base/model');
+const { setProp } = require('../../../utils/objectUtils');
 const { getHelpers } = require('./utils');
 
 const normalizeFromLeaf = require('./normalizeFrom');

package/lib/transform/db/backlinks.js

@@ -4,9 +4,9 @@ const {
   applyTransformationsOnNonDictionary, isAssociationOperand, isDollarSelfOrProjectionOperand,
 } = require('../../model/csnUtils');
 
-const { setProp } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
 const { forEach } = require('../../utils/objectUtils');
-const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { cloneCsnNonDict } = require('../../base/cloneCsn');
 const { ModelError } = require('../../base/error');
 
 /**

package/lib/transform/db/expansion.js

@@ -6,8 +6,8 @@ const {
   getUtils,
   forEachDefinition,
 } = require('../../model/csnUtils');
-const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
-const { setProp } = require('../../base/model');
+const { implicitAs, columnAlias, pathId } = require('../../base/csnRefs');
+const { setProp } = require('../../utils/objectUtils');
 const { killNonrequiredAnno } = require('./killAnnotations');
 const { featureFlags } = require('../featureFlags');
 const { applyTransformationsOnNonDictionary } = require('./applyTransformations');

package/lib/transform/db/flattening.js

@@ -9,11 +9,10 @@ const {
 } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
-const { csnRefs } = require('../../model/csnRefs');
-const { setProp } = require('../../base/model');
-const { forEach } = require('../../utils/objectUtils');
+const { csnRefs } = require('../../base/csnRefs');
+const { setProp, forEach } = require('../../utils/objectUtils');
 const { transformExpression } = require('./applyTransformations');
-const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { cloneCsnNonDict } = require('../../base/cloneCsn');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
 const { adaptAnnotationsRefs } = require('../odata/adaptAnnotationRefs');
 

package/lib/transform/db/killAnnotations.js

@@ -27,6 +27,7 @@ const requiredAnnos = {
   [sqlServiceAnnotation]: true,
   '@cds.external': true, // for external ABAP SQL services and data products for now
   '@data.product': true, // for data product production
+  '@hierarchy': true, // for Fiori Tree Views
 };
 
 /**

package/lib/transform/db/processSqlServices.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
+const { isBetaEnabled } = require('../../base/specialOptions');
 const { hasPersistenceSkipAnnotation } = require('../../model/csnUtils');
 
 const sqlServiceAnnotation = '@protocol';

package/lib/transform/db/rewriteCalculatedElements.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { setProp } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
 const { CompilerAssertion } = require('../../base/error');
 const {
   forEachDefinition,
@@ -9,7 +9,7 @@ const {
   implicitAs,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
-const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { cloneCsnNonDict } = require('../../base/cloneCsn');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 

package/lib/transform/db/temporal.js

@@ -3,8 +3,9 @@
 const {
   getNormalizedQuery, forEachMember,
 } = require('../../model/csnUtils');
-const { implicitAs } = require('../../model/csnRefs');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { implicitAs } = require('../../base/csnRefs');
+const { setProp } = require('../../utils/objectUtils');
+const { isBetaEnabled } = require('../../base/specialOptions');
 const { getTransformers } = require('../transformUtils');
 
 const validToString = '@cds.valid.to';
@@ -206,9 +207,16 @@ function getAnnotationHandler( csn, options, pathDelimiter, messageFunctions ) {
               'Expecting $(NAME) and $(ID) if $(ANNO) is used');
       }
 
-      forEachMember(artifact, (member) => {
+      // Collect paths for unique constraint (original keys + validFrom)
+      const uniquePaths = [];
+      const addedMembers = new Set();
+
+      forEachMember(artifact, (member, memberName) => {
         if (member.key) {
-          member.unique = true;
+          // Add to unique constraint paths - use the same ref format as assertUnique.prepare does
+          // this can then be used by assertUnique.rewrite to process
+          uniquePaths.push({ ref: [ { id: memberName } ], _art: member });
+          addedMembers.add(memberName);
           delete member.key;
           // Remember that this element was a key in the original artifact.
           // This is needed for localized convenience view generation.
@@ -220,8 +228,25 @@ function getAnnotationHandler( csn, options, pathDelimiter, messageFunctions ) {
       });
 
       validFrom.forEach((member) => {
-        member.element.unique = true;
+        // Add validFrom to unique constraint paths (if not already added as a key)
+        const memberName = member.path[member.path.length - 1];
+        if (!addedMembers.has(memberName))
+          uniquePaths.push({ ref: [ { id: memberName } ], _art: member.element });
       });
+
+      // Create $tableConstraints.unique entry - will be rewritten by assertUnique.rewrite()
+      if (uniquePaths.length > 0) {
+        if (!artifact.$tableConstraints)
+          artifact.$tableConstraints = Object.create(null);
+        if (!artifact.$tableConstraints.unique)
+          artifact.$tableConstraints.unique = Object.create(null);
+
+        // Use a named constraint
+        artifact.$tableConstraints.unique.__c_cds_valid = {
+          paths: uniquePaths,
+          parentTable: artifactName,
+        };
+      }
     }
     else {
       validFrom.forEach((member) => {

package/lib/transform/db/views.js

@@ -1,12 +1,12 @@
 'use strict';
 
 const {
-  getUtils, applyTransformationsOnNonDictionary, forEachDefinition,
+  getUtils, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
-const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
+const { implicitAs, columnAlias, pathId } = require('../../base/csnRefs');
 const { ModelError } = require('../../base/error');
-const { setProp } = require('../../base/model');
-const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { setProp } = require('../../utils/objectUtils');
+const { cloneCsnNonDict } = require('../../base/cloneCsn');
 
 /**
  * If a mixin association is published, return the mixin association.
@@ -472,7 +472,7 @@ function getColumnMap( query, csnUtils ) {
 
 
 /**
- * Ensure that each column in the CSN has a name.  A column does not have
+ * Ensure that a single query's columns have names. A column does not have
  * a name if the column is an expression and there is no explicit alias.
  * In that case an internal alias (from csnRefs()) is used and made explicit
  * via non-enumerable `as`.
@@ -485,24 +485,20 @@ function getColumnMap( query, csnUtils ) {
  *  - We can't use e.g. `$as`, as csnRefs() does not use that property, and it must not
  *    invent another name for the column (could happen after flattening).
  *
- * @param {CSN.Model} csn
- * @param {CSN.Options} options
+ * @param {object} query
  * @param {object} csnUtils
+ * @param {CSN.Options} options
  */
-function ensureColumnNames( csn, options, csnUtils ) {
-  forEachDefinition(csn, (def) => {
-    csnUtils.initDefinition(def);
-    for (const query of csnUtils.$getQueries(def) || []) {
-      for (const col of query._select.columns || []) {
-        if (col !== '*' && !columnAlias(col)) {
-          if (options.transformation === 'hdbcds')
-            col.as = csnUtils.getColumnName(col);
-          else
-            setProp(col, 'as', csnUtils.getColumnName(col));
-        }
-      }
+function ensureColumnNames( query, csnUtils, options ) {
+  const select = query.SELECT || query.projection;
+  for (const col of select?.columns || []) {
+    if (col !== '*' && !columnAlias(col)) {
+      if (options.transformation === 'hdbcds')
+        col.as = csnUtils.getColumnName(col);
+      else
+        setProp(col, 'as', csnUtils.getColumnName(col));
     }
-  });
+  }
 }
 
 module.exports = {

package/lib/transform/draft/db.js

@@ -4,10 +4,9 @@ const {
   getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
-const { setProp } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
-const { forEach } = require('../../utils/objectUtils');
+const { setProp, forEach } = require('../../utils/objectUtils');
 const draftAnnotation = '@odata.draft.enabled';
 const booleanBuiltin = 'cds.Boolean';
 

package/lib/transform/effective/associations.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { setProp } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
 const flattening = require('../db/flattening');
 const {
   applyTransformations, forEachDefinition, forEachMemberRecursively, forEachMember, applyTransformationsOnNonDictionary,

package/lib/transform/effective/flattening.js

@@ -4,7 +4,7 @@ const {
   forEachDefinition, forEachMemberRecursively, applyTransformationsOnNonDictionary, transformExpression, transformAnnotationExpression,
 } = require('../../model/csnUtils');
 const { getStructStepsFlattener } = require('../db/flattening');
-const { setProp } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
 const { forEach } = require('../../utils/objectUtils');
 
 

package/lib/transform/effective/main.js

@@ -16,11 +16,13 @@ const handleExists = require('../db/assocsToQueries/transformExists');
 const misc = require('./misc');
 const annotations = require('./annotations');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('../db/rewriteCalculatedElements');
-const { cloneFullCsn } = require('../../model/cloneCsn');
+const { cloneFullCsn } = require('../../base/cloneCsn');
 const { featureFlags, removeFeatureFlags } = require('../featureFlags');
 const getServiceFilterFunction = require('./service');
-const { traverseQuery } = require('../../model/csnRefs');
+const { traverseQuery } = require('../../base/csnRefs');
 const { expandWildcard } = require('../db/expansion');
+const { getQueryFeatureFlagSetter, getDefinitionFeatureFlagSetter } = require('../../checks/featureFlags');
+const shuffleGen = require('../../utils/shuffle');
 
 /**
  * This is just a PoC for now!
@@ -40,6 +42,10 @@ function effectiveCsn( model, options, messageFunctions ) {
   delete csn.vocabularies; // must not be set for effective CSN
   messageFunctions.setModel(csn);
 
+  const { shuffleDict } = shuffleGen(options.testMode);
+  if (options.testMode && csn.definitions)
+    csn.definitions = shuffleDict(csn.definitions);
+
   const transformerUtils = transformUtils.getTransformers(csn, options, messageFunctions, '_');
   const redoProjections = queries.projectionToSELECTAndAddColumns(csn);
 
@@ -48,9 +54,17 @@ function effectiveCsn( model, options, messageFunctions ) {
   let { csnUtils } = transformerUtils;
   csnUtils.initAllDefinitions();
 
+  const setQueryFeatureFlags = getQueryFeatureFlagSetter(csn);
+  const setDefinitionFeatureFlags = getDefinitionFeatureFlagSetter(csn, options);
+
   forEachDefinition(csn, (def) => {
-    if (def.query || def.projection)
-      traverseQuery(def.query || def, null, null, query => expandWildcard(query, csnUtils, options));
+    if (def.query || def.projection) {
+      traverseQuery(def.query || def, null, null, (query) => {
+        expandWildcard(query, csnUtils, options);
+        setQueryFeatureFlags(query);
+      });
+    }
+    setDefinitionFeatureFlags(def);
   });
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
@@ -94,6 +108,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   transformerUtils.csnUtils = getUtils(csn, 'init-all');
   associations.managedToUnmanaged(csn, options, transformerUtils, messageFunctions);
   associations.transformBacklinks(csn, options, transformerUtils, messageFunctions);
+
   const transformers = mergeTransformers([
     options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
     misc.removeDefinitionsAndProperties(csn, options),

package/lib/transform/effective/types.js

@@ -6,7 +6,7 @@ const {
   applyTransformationsOnDictionary,
 } = require('../../model/csnUtils');
 const { forEachKey } = require('../../utils/objectUtils');
-const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
+const { cloneCsnDict, cloneCsnNonDict } = require('../../base/cloneCsn');
 const propertiesToSkipForCasts = { enum: true };
 
 /**

package/lib/transform/{odata/fioriTreeViews.js → fioriTreeViews.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isBuiltinType } = require('../../base/builtins');
+const { isBuiltinType } = require('../base/builtins');
 /**
  * Processing the `@hierarchy` annotation on projections/views and generates:
  *  - the OData annotations: `@Aggregation.RecursiveHierarchy`, `@Hierarchy.RecursiveHierarchy`
@@ -16,17 +16,22 @@ const { isBuiltinType } = require('../../base/builtins');
  *  - the foreign key is of scalar type
  * Otherwise, appropriate warnings/errors are raised.
  */
-function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers) {
+function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers, options) {
   const { error, warning } = messageFunctions;
-  const { isManagedAssociation, isAssociation } = csnUtils;
+  const { isAssociation } = csnUtils;
   const { setAnnotation, addElement, createScalarElement } = transformers;
+  const isODataTransformation = options.transformation === 'odata';
 
-  if (Object.keys(def).some(key => key.startsWith('@hierarchy#')))
-    error(null, [ 'definitions', defName ], {}, 'Assigning qualifier with the @hierarchy annotation is not supported');
+  if (Object.keys(def).some(key => key.startsWith('@hierarchy#'))) {
+    if (isODataTransformation)
+      error(null, [ 'definitions', defName ], {}, 'Assigning qualifier with the @hierarchy annotation is not supported');
+    return;
+  }
 
   // supported only on projections or views
   if (!(def.projection || def.query)) {
-    warning(null, [ 'definitions', defName ], {}, 'Annotation @hierarchy is only supported on projections and views');
+    if (isODataTransformation)
+      warning(null, [ 'definitions', defName ], {}, 'Annotation @hierarchy is only supported on projections and views');
     return;
   }
 
@@ -34,7 +39,8 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
   const mngAssocsToSelf = [];
   const unmgAssocsToSelf = [];
   Object.entries(def.elements).forEach(([ name, elem ]) => {
-    if (isManagedAssociation(elem) && elem.target === defName && ![ 'DraftAdministrativeData' ].includes(name))
+    // if (isManagedAssociation(elem) && elem.target === defName && ![ 'DraftAdministrativeData' ].includes(name))
+    if (isAssociation(elem) && elem.keys && elem.target === defName && ![ 'DraftAdministrativeData' ].includes(name))
       mngAssocsToSelf.push([ name, elem ]);
     else if (isAssociation(elem) && elem.on &&
              elem.target === defName && ![ 'SiblingEntity' ].includes(name))
@@ -45,19 +51,19 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
   // association pointing to self and has a single foreign key that is of scalar type
   if (typeof def['@hierarchy'] === 'boolean' && def['@hierarchy'] === true) {
     if (mngAssocsToSelf.length > 1) {
-      warning(null, [ 'definitions', defName ], {},
-              'Annotation @hierarchy with value true is ignored as multiple managed associations to self exist');
+      if (isODataTransformation)
+        warning(null, [ 'definitions', defName ], {}, 'Annotation @hierarchy with value true is ignored as multiple managed associations to self exist');
       return;
     }
     else if (mngAssocsToSelf.length === 0) {
       if (unmgAssocsToSelf.length === 1) {
-        error(null, unmgAssocsToSelf[0][1].$path || [ 'definitions', defName, 'elements', unmgAssocsToSelf[0][0] ],
-              { name: unmgAssocsToSelf[0][0] }, 'Annotation @hierarchy is not supported for unmanaged association $(NAME)');
-      }
-      else {
-        warning(null, [ 'definitions', defName ], {},
-                'Annotation @hierarchy with value true is ignored as no managed association to self exists');
+        if (isODataTransformation) {
+          error(null, unmgAssocsToSelf[0][1].$path || [ 'definitions', defName, 'elements', unmgAssocsToSelf[0][0] ],
+                { name: unmgAssocsToSelf[0][0] }, 'Annotation @hierarchy is not supported for unmanaged association $(NAME)');
+        }
       }
+      if (isODataTransformation)
+        warning(null, [ 'definitions', defName ], {}, 'Annotation @hierarchy with value true is ignored as no managed association to self exists');
       return;
     }
 
@@ -65,7 +71,8 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
     const assocName = mngAssocsToSelf[0][0];
 
     if (isValidHierarchyAssociation(assoc, assocName)) {
-      addHierarchyAnnotations(def, defName, assoc.keys[0].ref.join(), assocName);
+      if (isODataTransformation)
+        addHierarchyAnnotations(def, defName, assoc.keys[0].ref.join(), assocName);
       addHierarchyFields(def, defName);
     }
   }
@@ -73,19 +80,22 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
     const assocName = def['@hierarchy']['='];
     const unmngAssoc = unmgAssocsToSelf.find(a => a[0] === assocName);
     if (unmngAssoc) {
-      error(null, unmngAssoc[1].$path || [ 'definitions', defName, 'elements', unmngAssoc[0] ],
-            { name: unmngAssoc[0] }, 'Annotation @hierarchy is not supported for unmanaged association $(NAME)');
+      if (isODataTransformation) {
+        error(null, unmngAssoc[1].$path || [ 'definitions', defName, 'elements', unmngAssoc[0] ],
+              { name: unmngAssoc[0] }, 'Annotation @hierarchy is not supported for unmanaged association $(NAME)');
+      }
       return;
     }
 
     const assoc = mngAssocsToSelf.find(a => a[0] === assocName);
     if (!assoc) {
-      warning(null, [ 'definitions', defName ], { name: assocName },
-              'Annotation @hierarchy refers to a non-existing managed association $(NAME)');
+      if (isODataTransformation)
+        warning(null, [ 'definitions', defName ], { name: assocName }, 'Annotation @hierarchy refers to a non-existing managed association $(NAME)');
       return;
     }
     if (isValidHierarchyAssociation(assoc[1], assocName)) {
-      addHierarchyAnnotations(def, defName, assoc[1].keys[0].ref.join(), assocName);
+      if (isODataTransformation)
+        addHierarchyAnnotations(def, defName, assoc[1].keys[0].ref.join(), assocName);
       addHierarchyFields(def, defName);
     }
   }
@@ -94,16 +104,20 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
   function isValidHierarchyAssociation(assoc, assocName) {
     // the association must have exactly one scalar foreign key
     if (assoc.keys.length > 1) {
-      warning(null, assoc.$path || [ 'definitions', defName, 'elements', assocName ], { name: assocName },
-              'Annotation @hierarchy is ignored as the managed association $(NAME) has multiple foreign keys');
+      if (isODataTransformation) {
+        warning(null, assoc.$path || [ 'definitions', defName, 'elements', assocName ], { name: assocName },
+                'Annotation @hierarchy is ignored as the managed association $(NAME) has multiple foreign keys');
+      }
       return false;
     }
 
     const fkName = assoc.keys[0].ref.join();
     const defKey = Object.entries(def.elements).find(([ name, elem ]) => elem.key && name === fkName);
     if (defKey && !isBuiltinType(defKey[1].type)) {
-      warning(null, assoc.$path || [ 'definitions', defName, 'elements', assocName ], { name: assocName },
-              'Annotation @hierarchy is ignored as the foreign key of the managed association $(NAME) is not of a scalar type');
+      if (isODataTransformation) {
+        warning(null, assoc.$path || [ 'definitions', defName, 'elements', assocName ], { name: assocName },
+                'Annotation @hierarchy is ignored as the foreign key of the managed association $(NAME) is not of a scalar type');
+      }
       return false;
     }
     return true;
@@ -143,6 +157,7 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
   }
 
   function addHierarchyFields(def, defName) {
+    // add elements in elements dictionary
     const limitedDescendantCount = createScalarElement('LimitedDescendantCount', 'cds.Integer');
     limitedDescendantCount.LimitedDescendantCount['@Core.Computed'] = true;
     limitedDescendantCount.LimitedDescendantCount.$calc = { val: null };
@@ -162,6 +177,14 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
     limitedRank.LimitedRank['@Core.Computed'] = true;
     limitedRank.LimitedRank.$calc = { val: null };
     addElement(limitedRank, def, defName);
+
+    // add fields in the query columns
+    if (def.query && def.query.SELECT && def.query.SELECT.columns) {
+      def.query.SELECT.columns.push({ val: null, as: 'LimitedDescendantCount', cast: { type: 'cds.Integer' } });
+      def.query.SELECT.columns.push({ val: null, as: 'DistanceFromRoot', cast: { type: 'cds.Integer' } });
+      def.query.SELECT.columns.push({ val: null, as: 'DrillState', cast: { type: 'cds.String' } });
+      def.query.SELECT.columns.push({ val: null, as: 'LimitedRank', cast: { type: 'cds.Integer' } });
+    }
   }
 
   function checkAndReportErrorWhenAnnotationExists(def, defName, anno) {

package/lib/transform/forOdata.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 const transformUtils = require('./transformUtils');
 const {
   forEachDefinition,
@@ -22,15 +22,15 @@ const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./oda
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const flattening = require('./odata/flattening');
 const createForeignKeyElements = require('./odata/createForeignKeys');
-const generateFioriTreeViewAnnotationsAndFields = require('./odata/fioriTreeViews');
+const generateFioriTreeViewAnnotationsAndFields = require('./fioriTreeViews');
 const associations = require('./db/associations');
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
 const { addTenantFields } = require('./addTenantFields');
 const { addLocalizationViews } = require('./localized');
-const { cloneFullCsn } = require('../model/cloneCsn');
-const { csnRefs } = require('../model/csnRefs');
+const { cloneFullCsn } = require('../base/cloneCsn');
+const { csnRefs } = require('../base/csnRefs');
 const replaceForeignKeyRefsInExpressionAnnotations = require('./odata/foreignKeyRefsInXprAnnos');
 const { isAnnotationExpression, xprInAnnoProperties } = require('../base/builtins');
 
@@ -297,7 +297,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
 
     // Generate annotations and fields needed for the Fiori Tree Views out of the @hierarchy annotation
     if (def['@hierarchy'])
-      generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers);
+      generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers, options);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway