@sap/cds-compiler 6.3.4 → 6.4.2

package/lib/transform/db/rewriteCalculatedElements.js

@@ -9,7 +9,6 @@ const {
   implicitAs,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
-const { getColumnMap } = require('./views');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
@@ -23,11 +22,10 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  * @param {CSN.Options} options
  * @param {object} csnUtils
  * @param {string} pathDelimiter
- * @param {object} messageFunctions
+ * @param {object} _messageFunctions
  */
-function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, messageFunctions ) {
+function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, _messageFunctions ) {
   const { inspectRef, effectiveType } = csnUtils;
-  const { error } = messageFunctions;
 
   const views = [];
   const entities = [];
@@ -119,9 +117,6 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
    * Rewrite calculated-elements-columns in views/projections and replace them
    * with their "root"-expression.
    *
-   * As a first step, we ensure that all views/projections have a .columns (see {@link calculateColumns}) and that
-   * all calculated elements are addressed explicitly and not via a * (see {@link makeAllCalculatedElementsExplicitColumns}).
-   *
    * Then, we check the `art` of each ref for a `.value` and rewrite accordingly.
    * We need to ensure that the scope of the rewritten expressions is still correct!
    * An `id` in the `.value` needs to point to the entity containing the element,
@@ -133,73 +128,64 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
    * @param {CSN.Path} path
    */
   function rewriteInView( SELECT, elements, path ) {
-    const containsExpandInline = hasExpandInline(SELECT);
-    let cleanupCallbacks;
-    if (!SELECT.columns) // needs to happen for all subqueries!
-      cleanupCallbacks = calculateColumns(elements, SELECT);
-    else
-      cleanupCallbacks = makeAllCalculatedElementsExplicitColumns(elements, SELECT, containsExpandInline);
-
-    const name = SELECT.from.args ? undefined : SELECT.from.as || (SELECT.from.ref && implicitAs(SELECT.from.ref));
-
-    if (!containsExpandInline) {
-      applyTransformationsOnNonDictionary({ SELECT }, 'SELECT', {
-        ref: (parent, prop, ref, p, root) => {
-          const {
-            art, env, links, scope,
-          } = getRefInfo(parent, p);
-
-          // calc element publishes association, treat as regular
-          // unmanaged association
-          const calcElementIsAssoc = art?.value && art.target;
-          // TODO: Calculated elements on-write
-          if (art?.value && !art.value.stored && !calcElementIsAssoc) {
-            const alias = parent.as || implicitAs(parent.ref);
-            // TODO: What about other scopes? expand/inline?
-            const value = (scope !== 'ref-target') ? absolutifyPaths(env, art, ref, links, name).value : keepAssocStepsInRef(ref, links, art).value;
-
-            // Is a shallow copy enough?
-            if (art.value.cast)
-              root[p[p.length - 1]] = { xpr: [ value ] };
-            else
-              root[p[p.length - 1]] = { ...value };
+    expandStructSelectItems(SELECT);
+
+    const name = SELECT.from.args
+      ? undefined
+      : SELECT.from.as || (SELECT.from.ref && implicitAs(SELECT.from.ref));
+
+    applyTransformationsOnNonDictionary({ SELECT }, 'SELECT', {
+      ref: transformRef,
+    }, {}, path);
+
+    /**
+     * @param {object} parent
+     * @param {string} prop
+     * @param ref
+     * @param p
+     * @param root
+     */
+    function transformRef(parent, prop, ref, p, root) {
+      const {
+        art, env, links, scope,
+      } = getRefInfo(parent, p);
+
+      // calc element publishes association, treat as regular unmanaged association
+      const calcElementIsAssoc = art?.value && art.target;
+
+      if (!art?.value || art.value.stored || calcElementIsAssoc)
+        return;
+
+      if (scope === 'inline' || scope === 'expand') {
+        // Calculated elements in expand/inline are not supported, yet.
+        // Error is reported in expansion.js
+        return;
+      }
 
-            if (p[p.length - 2] === 'columns')
-              root[p[p.length - 1]].as = alias;
-            else
-              delete root[p[p.length - 1]].as;
+      const alias = parent.as || implicitAs(parent.ref);
 
-            // If the calculated element has a type, use it. But only if the column did not have an explicit type.
-            // Note: We should not check `art.type`, because we only need the type for columns, not filters.
-            if (parent.cast)
-              root[p[p.length - 1]].cast = parent.cast;
-            else if (parent._element?.type)
-              root[p[p.length - 1]].cast = { type: parent._element.type };
+      // TODO: What about other scopes? expand/inline may become relevant again if we allow calc elements in them.
+      const value = (scope !== 'ref-target')
+        ? absolutifyPaths(env, art, ref, links, name).value
+        : keepAssocStepsInRef(ref, links, art).value;
 
-            // TODO: Copy annotations? May become relevant in the future
-          }
-        },
-      }, {}, path);
-    }
+      // TODO: Is a shallow copy enough?
+      root[p.at(-1)] = art.value.cast ? { xpr: [ value ] } : { ...value };
 
-    cleanupCallbacks.forEach(fn => fn());
-  }
+      if (p.at(-2) === 'columns' || p.at(-2) === 'expand')
+        root[p.at(-1)].as = alias;
+      else
+        delete root[p.at(-1)].as;
 
-  /**
-   *
-   * @param {CSN.QuerySelect} SELECT
-   * @returns {boolean}
-   */
-  function hasExpandInline( SELECT ) {
-    if (!SELECT.columns)
-      return false;
+      // If the calculated element has a type, use it. But only if the column did not have an explicit type.
+      // Note: We should not check `art.type`, because we only need the type for columns, not filters.
+      if (parent.cast)
+        root[p.at(-1)].cast = parent.cast;
+      else if (parent._element?.type)
+        root[p.at(-1)].cast = { type: parent._element.type };
 
-    for (const column of SELECT.columns) {
-      if (column.expand || column.inline)
-        return true;
+      // TODO: Copy annotations? May become relevant in the future
     }
-
-    return false;
   }
 
   /**
@@ -329,228 +315,38 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
   }
 
   /**
-   * For a `view V as select from E;` or a `entity P as projection on E;` calculate and
-   * attach the .columns if they contain a calculated element so we can rewrite them in
-   * the later steps.
-   *
-   * @param {CSN.Elements} elements Artifact elements
-   * @param {object} carrier The thing that will "carry" the columns - .SELECT or .projection
-   * @returns {Function[]} Cleanup callbacks that remove `_`-links.
-   */
-  function calculateColumns( elements, carrier ) {
-    carrier.columns = [ '*' ];
-    const cleanupCallbacks = makeAllCalculatedElementsExplicitColumns(elements, carrier, false);
-    if (carrier.columns.length === 1 && carrier.columns[0] === '*')
-      delete carrier.columns;
-    return cleanupCallbacks;
-  }
-
-  /**
-   *
-   * @param {CSN.QuerySelect} SELECT
-   * @returns {object}
-   */
-  function getDirectlyAddressableElements( SELECT ) {
-    const { from } = SELECT;
-    if (from.ref) {
-      return from._art.elements;
-    }
-    else if (from.SELECT) {
-      return from.SELECT.elements;
-    }
-    else if (from.SET) {
-      // args[0] could be SELECT or UNION
-      return getDirectlyAddressableElements({ from: from.SET.args[0] });
-    }
-    else if (from.args) {
-      const mergedElements = Object.create(null);
-      for (const arg of from.args) {
-        if (arg.ref) {
-          for (const elementName in arg._art.elements)
-            mergedElements[elementName] = arg._art.elements[elementName];
-        }
-        else if (arg.SET) {
-          return getDirectlyAddressableElements({ from: arg.SET.args[0] });
-        }
-        else if (arg.SELECT) { // TODO: UNION
-          for (const elementName in arg.SELECT.elements)
-            mergedElements[elementName] = arg.SELECT.elements[elementName];
-        }
-        else if (arg.args) { // TODO: Is it safe to do recursion here?
-          for (const subarg of arg.args) {
-            const elements = getDirectlyAddressableElements({ from: subarg });
-            for (const elementName in elements)
-              mergedElements[elementName] = elements[elementName];
-          }
-        }
-        else {
-          throw new CompilerAssertion(`Unhandled arg type: ${ JSON.stringify(arg, null, 2) }`);
-        }
-      }
-      return mergedElements;
-    }
-    throw new CompilerAssertion(`Unhandled query type:  ${ JSON.stringify(SELECT, null, 2) }`);
-  }
-
-  /**
-   * Ensure that all elements of the query that are calculated elements have an explicit column that we can rewrite.
-   * If a field originally comes in via the *, then we need to add an explicit column for it.
+   * Expands all references to structures to its separate leaf elements, adding columns if needed.
    *
-   * @param {CSN.Elements} elements
-   * @param {CSN.QuerySelect} SELECT
-   * @param {boolean} containsExpandInline
-   * @returns {Function[]} Cleanup callbacks that remove `_`-links.
+   * @param {object} SELECT
    */
-  function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
-    const cleanupCallbacks = [];
-    const root = getDirectlyAddressableElements(SELECT);
-    const columnMap = getColumnMap( { SELECT }, csnUtils );
-    const hasStar = SELECT.columns.includes('*');
-    const unfoldingMap = {};
-    let starContainsCalculated = false;
-    let containsCalcOnRead = false;
-    for (const name in elements) {
-      const originalRef = columnMap[name] && columnMap[name].ref || [ name ];
-
-      if (columnMap[name] || hasStar) {
-        let element;
-        if (columnMap[name]?.expand || columnMap[name]?.inline)
-          element = elements[name]; // only the direct thing in .elements has the .excluding respected properly!
-        else
-          element = columnMap[name]?._art || columnMap[name]?._element || root[name] || elements[name];
-        const branches = getBranches(element, name, effectiveType, pathDelimiter); // TODO: is our elements[name] really the root[name]?
-        if (hasCalcOnReadLeaf(branches)) {
-          containsCalcOnRead = true;
-          const columns = [];
-          for (const branchName in branches) {
-            const branch = branches[branchName];
-            const leafElement = branch.steps[branch.steps.length - 1];
-            if (columnMap[branchName]) { // Existing column - don't overwrite, we need $env!
-              columns.push(columnMap[branchName]);
-            }
-            else {
-              // TODO: Hm, will we have a $env in the leaf of the thing then?
-              const column = { ref: [ ...originalRef, ...branches[branchName].ref.slice(1) ], as: branchName };
-              setProp(column, '_element', leafElement);
-              cleanupCallbacks.push(() => delete column._element);
-              columns.push(column);
-            }
-          }
-          if (columnMap[name]) {
-            unfoldingMap[name] = [ false, [ ...columns ] ];
-          }
-          else if (hasStar) { // Via * - just append
-            starContainsCalculated = true;
-            unfoldingMap[name] = [ true, [ ...columns ] ];
-          }
-        }
-        else {
-          if (usesCalcOnRead(branches))
-            containsCalcOnRead = true;
-          if (!columnMap[name] && hasStar) { // Via * - just append
-            unfoldingMap[name] = [ true, [ { ref: [ name ] } ] ];
-          }
-          else { // just a random column - keep
-            unfoldingMap[name] = [ false, [ columnMap[name] ] ];
-          }
+  function expandStructSelectItems(SELECT) {
+    for (let i = 0; i < SELECT.columns?.length; i++) {
+      const column = SELECT.columns[i];
+      if (column.expand)
+        continue; // skip expand
+
+      if (column.ref && column._element) {
+        const columnName = column.as || implicitAs(column.ref);
+        const branches = getBranches(column._element, columnName, effectiveType, pathDelimiter);
+        const paths = Object.keys(branches);
+        if (paths.length > 1 || paths[0] !== columnName) {
+          SELECT.columns[i] = Object.entries(branches).map(([ name, branch ]) => {
+            const elem = branch.steps.at(-1);
+            // TODO: Table alias somehow?
+            const ref = [ ...column.ref, ...branch.ref.slice(1) ];
+            const newColumn = { ref, as: name };
+
+            // If the calculated element has a type, use it.
+            if (elem['@Core.Computed'] && elem.type) // very crude - we could walk the branches to see if we are dealing with a real calc element?
+              newColumn.cast = { type: elem.type };
+
+            return newColumn;
+          });
         }
       }
     }
 
-    if (containsExpandInline && containsCalcOnRead) {
-      error('query-unsupported-calc', SELECT.$path, { '#': 'std' });
-    }
-    else if (containsCalcOnRead) {
-      const newColumns = [];
-      if (hasStar && !starContainsCalculated)
-        newColumns.push('*');
-      for (const name in elements) {
-        const [ isViaStar, columns ] = unfoldingMap[name];
-        if (isViaStar && starContainsCalculated || !isViaStar)
-          newColumns.push(...columns);
-      }
-
-      SELECT.columns = newColumns;
-    }
-    return cleanupCallbacks;
-  }
-
-  /**
-   * Returns true if any leaf node is a calculated element on-read.
-   * On-write behaves like regular elements, hence they do not count here.
-   *
-   * @param {object} branches
-   * @returns {boolean}
-   */
-  function hasCalcOnReadLeaf( branches ) {
-    for (const branchName in branches) {
-      const branch = branches[branchName].steps;
-      const leaf = branch[branch.length - 1];
-      if (hasOnReadValue(leaf))
-        return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Returns true if the branch/column uses a calc-on-read,
-   * for example in a filter.
-   *
-   * TODO: Enable calculated elements next to nested projections
-   *
-   * @param {object} branches
-   * @returns {boolean}
-   */
-  function usesCalcOnRead( branches ) {
-    let returnValue = false;
-    for (const branchName in branches) {
-      const column = branches[branchName]?.steps[0]?._column;
-      if (column) {
-        applyTransformationsOnNonDictionary({ column }, 'column', {
-          // eslint-disable-next-line no-loop-func
-          ref: (parent) => {
-            if (hasOnReadValue(parent))
-              returnValue = true;
-          },
-        }, {
-          drillRef: true,
-          // skip subqueries and nested projections
-          // calculated elements and nested projections
-          // only conflict on same level
-          skipStandard: [ 'SELECT', 'expand', 'inline' ],
-        });
-      }
-    }
-
-    return returnValue;
-  }
-
-  /**
-   * A leaf can reference a column which in turn references a real element - that might have a .value.
-   * Find such cases.
-   *
-   * @param {object} baseLeaf Leaf to start at
-   * @returns {boolean}
-   */
-  function hasOnReadValue( baseLeaf ) {
-    const visited = new WeakSet();
-    const stack = [ baseLeaf ];
-    while (stack.length > 0) {
-      const leaf = stack.pop();
-      if (!visited.has(leaf)) { // Don't re-process things
-        if (leaf.value && !leaf.value.stored)
-          return true;
-        else if (leaf._art)
-          stack.push(leaf._art);
-        else if (leaf['@Core.Computed'] && leaf._column && leaf._column !== baseLeaf)
-          stack.push(leaf._column);
-      }
-
-      visited.add(leaf);
-    }
-
-    return false;
+    SELECT.columns = SELECT.columns.flat(Infinity);
   }
 
   /**

package/lib/transform/effective/main.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getUtils, mergeTransformers, applyTransformations,
+  getUtils, mergeTransformers, applyTransformations, forEachDefinition,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const effectiveFlattening = require('./flattening');
@@ -19,6 +19,8 @@ const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities }
 const { cloneFullCsn } = require('../../model/cloneCsn');
 const { featureFlags } = require('../featureFlags');
 const getServiceFilterFunction = require('./service');
+const { traverseQuery } = require('../../model/csnRefs');
+const { expandWildcard } = require('../db/expansion');
 
 /**
  * This is just a PoC for now!
@@ -46,6 +48,11 @@ function effectiveCsn( model, options, messageFunctions ) {
   let { csnUtils } = transformerUtils;
   csnUtils.initAllDefinitions();
 
+  forEachDefinition(csn, (def) => {
+    if (def.query || def.projection)
+      traverseQuery(def.query || def, null, null, query => expandWildcard(query, csnUtils, options));
+  });
+
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
     ...messageFunctions, csnUtils, ...csnUtils, csn, options,

package/lib/transform/forOdata.js

@@ -210,7 +210,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
 
   // needs to be performed after creating foreign keys for the entire model,
   // because of multiple managed associations in refs
-  replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
+  replaceForeignKeyRefsInExpressionAnnotations(csn, csnUtils, { skipArtifact: isExternalServiceMember });
 
   bindCsnReferenceOnly();
 

package/lib/transform/forRelationalDB.js

@@ -37,6 +37,7 @@ const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags } = require('./featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
 const { processSqlServices, createServiceDummy } = require('./db/processSqlServices');
+const { expandWildcard } = require('./db/expansion');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -44,68 +45,12 @@ function forEachDefinition(csn, cb) {
 }
 
 /**
- * Return a copy of the compact CSN model with a number of transformations made for rendering
- * in HANA CDS style, used by 'toHana', toSql' and 'toRename'.
- * The behavior is controlled by the following options:
- * options = {
- *    sqlMapping // See the behavior of 'sqlMapping' in toHana, toSql and toRename
- * }
- * The result model will always have 'options.forHana' set, to indicate that these transformations have happened.
- * The following transformations are made:
- * - (000) Some primitive type names are mapped to HANA type names (e.g. DateTime => UTCDateTime,
- *         Date => LocalDate, ...).The primitive type 'UUID' is renamed to 'String' (see also 060 below).
- * - (001) Add a temporal where condition to views where applicable before assoc2join
- * - (010) (not for to.hdbcds with hdbcds names): Transform associations to joins
- * - (015) Draft shadow entities are generated for entities/views annotated with '@odata.draft.enabled'.
- * - (020) Check: in "plain" mode, quoted ids are not allowed.
- *         (a) check in namespace declarations
- *         (b) check in artifact/element definitions.
- * - (040) Abstract entities and entities 'implemented in' something are ignored, as well
- *         as entities annotated with '@cds.persistence.skip' or '@cds.persistence.exists'.
- * - (050) Checks on the hierarchical model (pre-flattening)
- *         array of, @cds.valid.from/to
- * - (045) The query is stripped from entities that are annotated with '@cds.persistence.table',
- *         essentially converting views to entities.
- * - (060) Users of primitive type 'UUID' (which is renamed to 'String' in 000) get length 36'.
- * - (070) Default length N is supplied for strings if not specified.
- * - (080) Annotation definitions are ignored (note that annotation assignments are filtered out by toCdl).
- * - (090) Compositions become associations.
- * - (100) 'masked' is ignored (a), and attribute 'localized' is removed (b)
- * - (110) Actions and functions (bound or unbound) are ignored.
- * - (120) (a) Services become contexts.
- * - (130) (not for to.hdbcds with hdbcds names): Elements having structured types are flattened into
- *         multiple elements (using '_' or '.' as name separator, depending on 'sqlMapping').
- * - (140) (not for to.hdbcds with hdbcds names): Managed associations get explicit ON-conditions, with
- *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'sqlMapping').
- * - (150) (a) Elements from inherited (included) entities are copied into the receiving entity
- *         (b) The 'include' property is removed from entities.
- * - (160) Projections become views, with MIXINs for association elements (adding $projection where
- *         appropriate for ON-conditions).
- * - (170) ON-conditions referring to '$self' are transformed to compare explicit keys instead.
- * - (180) In projections and views, ...
- *         (a) association elements that are mixins must not be explicitly redirected
- *         (b) MIXINs are created for association elements in the select list that are not mixins by themselves.
- * - (190) For all enum types, ...
- *         (a) enum constants in defaults are replaced by their values (assuming a matching enum as element type)
- *         (b) the enum-ness is stripped off (i.e. the enum type is replaced by its final base type).
- * - (200) The 'key' property is removed from all elements of types.
- * - (210) (not for to.hdbcds with hdbcds names): Managed associations in GROUP BY and ORDER BY are
- *         replaced by by their foreign key fields.
- * - (220) Contexts that contain no artifacts or only ignored artifacts are ignored.
- * - (230) (only for to.hdbcds with hdbcds names): The following are rejected in views
- *         (a) Structured elements
- *         (b) Managed association elements
- *         (c) Managed association entries in GROUP BY
- *         (d) Managed association entries in ORDER BY
- * - (240) All artifacts (a), elements, foreign keys, parameters (b) that have a DB representation are annotated
- *         with their database name (as '@cds.persistence.name') according to the naming convention chosen
- *         in 'options.sqlMapping'.
- * - (250) Remove name space definitions again (only in forRelationalDB). Maybe we can omit inserting namespace definitions
- *         completely (TODO)
+ * Transform the given `csn` into a CSN that has SQL/HANA related transformations applied,
+ * such as flattening, wildcard expansion, etc.
  *
- * @param {CSN.Model}   csn
- * @param {CSN.Options} options
- * @param {object}      messageFunctions Message functions such as `error()`, `info()`, …
+ * @param {CSN.Model}      csn
+ * @param {CSN.SqlOptions} options
+ * @param {object}         messageFunctions Message functions such as `error()`, `info()`, …
  */
 function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // copy the model as we don't want to change the input model
@@ -148,6 +93,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   ensureColumnNames(csn, options, csnUtils);
 
+  forEachDefinition(csn, (def) => {
+    // TODO: Combine query traversal with ensureColumnNames()
+    if (def.query || def.projection)
+      traverseQuery(def.query || def, null, null, query => expandWildcard(query, csnUtils, options));
+  });
+
   const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
@@ -185,8 +136,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   expandStructsInExpression({ drillRef: true });
 
   forEachDefinition(csn, [
-    // (001) Add a temporal where condition to views where applicable before assoc2join
-    //       assoc2join eventually rewrites the table aliases
+    // Add a temporal where condition to views where applicable before assoc2join
+    // assoc2join eventually rewrites the table aliases
     temporal.getViewDecorator(csn, messageFunctions, csnUtils, options),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
     assertUnique.prepare(csn, options, messageFunctions),
@@ -242,7 +193,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // With flattening errors, it makes little sense to continue.
   throwWithAnyError();
 
-  // (010) If requested, translate associations to joins
   if (doA2J)
     handleAssocToJoins();
 
@@ -287,12 +237,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
 
   forEachDefinition(csn, [
-    // (040) Ignore entities and views that are abstract or implemented
+    // Ignore entities and views that are abstract or implemented
     // or carry the annotation cds.persistence.skip/exists
     // These entities are not removed from the csn, but flagged as "to be ignored"
     cdsPersistence.getAnnoProcessor(),
-    // (050) Check @cds.valid.from/to only on entity
-    //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
+    // Check @cds.valid.from/to only on entity
+    // Views are checked in (001), unbalanced valid.from/to's or mismatching origins
     temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions),
   ]);
 
@@ -308,7 +258,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   }
 
   {
-    // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
+    // Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
     // and make them entities
     const fns = [ cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions) ];
     // Allow using managed associations as steps in on-conditions to access their fks
@@ -338,7 +288,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path);
       }
     },
-    // (170) Transform '$self' in backlink associations to appropriate key comparisons
+    // 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,
@@ -371,7 +321,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && (csn.meta?.[featureFlags]?.$sqlService || csn.meta?.[featureFlags]?.$dummyService || csn.meta?.[featureFlags]?.$dataProductService) ? processSqlServices(csn, options) : () => {};
 
   // Apply view-specific transformations
-  // (160) Projections now finally become views
+  // Projections now finally become views
   // Replace managed association in group/order by with foreign keys
   const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions);
   forEachDefinition(csn, [ (artifact, artifactName) => {
@@ -382,7 +332,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   if (!doA2J) {
     forEachDefinition(csn, [
-      // (200) Strip 'key' property from type elements
+      // Strip 'key' property from type elements
       removeKeyPropInType,
       (artifact, artifactName) => {
         if (artifact.kind === 'type') {
@@ -697,15 +647,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // Length/Precision/Scale is done in addDefaultTypeFacets
   }
 
-  // If 'obj' has final type 'cds.UUID' (renamed to String in 000), set its length to 36.
-  // function setLengthForFormerUuid(obj) {
-  //   if (!obj || !obj.type)
-  //     return;
-  //   if (obj.type === 'cds.UUID' && !obj.length) {
-  //     obj.length = 36;
-  //   }
-  // }
-
   /**
    * Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.