@sap/cds-compiler 4.4.2 → 4.5.0

package/lib/render/toHdbcds.js

@@ -4,12 +4,13 @@ const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
   getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
+  pathName,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
   renderFunc, createExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
   hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
-  cdsToSqlTypes, cdsToHdbcdsTypes, withoutCast,
+  cdsToSqlTypes, cdsToHdbcdsTypes, withoutCast, variableForDialect,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -1209,11 +1210,10 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string|object} s Path step
    * @param {number} idx Path position
-   * @param {any[]} ref
    * @param {HdbcdsRenderEnvironment} env
    * @returns {string} Rendered path step
    */
-  function renderPathStep( s, idx, ref, env ) {
+  function renderPathStep( s, idx, env ) {
     // Simple id or absolute name
     if (typeof s === 'string') {
       // HANA-specific extra magic (should actually be in forRelationalDB)
@@ -1227,12 +1227,6 @@ function toHdbcdsSource( csn, options ) {
         return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
           : renderAbsoluteNameWithQuotes(env.currentArtifactName, env);
       }
-      // HANA-specific translation of '$now' and '$user'
-      if (s === '$now' && ref.length === 1)
-        return 'CURRENT_TIMESTAMP';
-
-      // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
-      // FIXME: We should rather explicitly recognize quoting somehow
 
       // TODO: quote $parameters if it doesn't reference a parameter, this requires knowledge about the kind
       // Example: both views are correct in HANA CDS
@@ -1319,39 +1313,35 @@ function toHdbcdsSource( csn, options ) {
   /**
    * @param {object} x Expression with a ref property
    * @returns {string} Rendered expression
-   * @todo no extra magic with x.param or x.global
+   * @todo no extra magic with x.param
    */
   function renderExpressionRef( x ) {
-    if (!x.param && !x.global) {
+    if (!x.param) {
       const magicReplacement = getVariableReplacement(x.ref, options);
-      if (x.ref[0] === '$user') {
+      if (x.ref[0] === '$user' || x.ref[0] === '$tenant') {
         if (magicReplacement !== null)
           return renderStringForHdbcds(magicReplacement);
 
-        // Note: The compiler already transforms $user into $user.id.
-
-        // FIXME: this is all not enough: we might need an explicit select item alias (?)
-        if (x.ref[1] === 'id')
-          return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
-
-        else if (x.ref[1] === 'locale')
-          return 'SESSION_CONTEXT(\'LOCALE\')';
-
-        else if (x.ref[1] === 'tenant')
-          return 'SESSION_CONTEXT(\'TENANT\')';
+        const name = pathName(x.ref);
+        const result = variableForDialect(options, name);
+        // Invalid second path step doesn't cause a return
+        if (result)
+          return result;
       }
-      else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
-        if (x.ref[1] === 'from')
-          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
-
-        else if (x.ref[1] === 'to')
-          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
+      else if (x.ref[0] === '$at' || x.ref[0] === '$valid' || x.ref[0] === '$now') {
+        const name = pathName(x.ref);
+        const result = variableForDialect(options, name);
+        // Invalid second path step doesn't cause a return
+        if (result)
+          return result;
       }
       else if (x.ref[0] === '$session' && magicReplacement !== null) {
         return renderStringForHdbcds(magicReplacement);
       }
     }
-    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
+    const prefix = x.param ? ':' : '';
+    const ref = x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.');
+    return `${prefix}${ref}`;
   }
 
   /**

package/lib/render/toSql.js

@@ -4,7 +4,7 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  forEachDefinition, getResultingName, getVariableReplacement,
+  forEachDefinition, getResultingName, getVariableReplacement, pathName,
 } = require('../model/csnUtils');
 const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
 const {
@@ -608,7 +608,7 @@ function toSqlDdl( csn, options ) {
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
 
 
-    if (options.sqlDialect === 'hana') {
+    if (options.sqlDialect === 'hana' && options.withHanaAssociations) {
       const associations = Object.keys(art.elements)
         .map(name => renderAssociationElement(name, art.elements[name], childEnv))
         .filter(s => s !== '')
@@ -761,7 +761,6 @@ function toSqlDdl( csn, options ) {
    * is not an association.
    * Any change to the cardinality rendering must be reflected in A2J mapAssocToJoinCardinality() as well.
    *
-   * @todo Duplicate check
    * @param {string} elementName Name of the element to render
    * @param {CSN.Element} elm CSN element
    * @param {SqlRenderEnvironment} env Render environment
@@ -905,12 +904,11 @@ function toSqlDdl( csn, options ) {
    *
    * Returns the source as a string.
    *
-   * @todo Misleading name, should be something like 'renderQueryFrom'. All the query parts should probably also be rearranged.
    * @param {object} source Query source
    * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered view source
    */
-  function renderViewSource( source, env ) {
+  function renderQuerySource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(source, env.withIncreasedIndent())})`;
@@ -922,12 +920,12 @@ function toSqlDdl( csn, options ) {
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
+      let result = `${renderQuerySource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
       for (let i = 1; i < source.args.length; i++) {
         result = `(${result} ${source.join.toUpperCase()} `;
         if (options.sqlDialect === 'hana')
           result += renderJoinCardinality(source.cardinality);
-        result += `JOIN ${renderViewSource(source.args[i], env.withSubPath([ 'args', i ]))}`;
+        result += `JOIN ${renderQuerySource(source.args[i], env.withSubPath([ 'args', i ]))}`;
         if (source.on)
           result += ` ON ${renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
 
@@ -1150,7 +1148,7 @@ function toSqlDdl( csn, options ) {
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
-    if (associations !== '' && options.sqlDialect === 'hana') {
+    if (associations !== '' && options.sqlDialect === 'hana' && options.withHanaAssociations) {
       result += `${env.indent}\nWITH ASSOCIATIONS (\n${associations}\n`;
       result += `${env.indent})`;
     }
@@ -1257,7 +1255,7 @@ function toSqlDdl( csn, options ) {
       })
       .filter(s => s !== '')
       .join(',\n')}\n`;
-    result += `${env.indent}FROM ${renderViewSource( select.from, env.withSubPath([ 'from' ]))}`;
+    result += `${env.indent}FROM ${renderQuerySource( select.from, env.withSubPath([ 'from' ]))}`;
     if (select.where)
       result += `\n${env.indent}WHERE ${renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
 
@@ -1335,23 +1333,15 @@ function toSqlDdl( csn, options ) {
   function renderTypeReference( elm, env ) {
     let result = '';
 
-    // Anonymous structured type: Not supported with SQL (but shouldn't happen anyway after forHana flattened them)
     if (!elm.type && !elm.value) {
-      if (!elm.elements)
+      // Anonymous structured type: Not supported with SQL, but doesn't happen anyway after flattening.
+      if (options.testMode)
         throw new ModelError(`to.sql(): Missing type of: ${JSON.stringify(env.path)}`);
-
-      // TODO: Signal is not covered by tests
-      error(null, env.path,
-            'Anonymous structured types are not supported for conversion to SQL');
       return result;
     }
-
-    // Association type
-    if (elm.target) {
-      // TODO: Signal is not covered by tests
-      // We can't do associations yet
-      error(null, env.path,
-            'Association and composition types are not yet supported for conversion to SQL');
+    else if (elm.target) {
+      if (options.testMode)
+        throw new ModelError(`to.sql(): Unexpected association in: ${JSON.stringify(env.path)}`);
       return result;
     }
 
@@ -1370,7 +1360,6 @@ function toSqlDdl( csn, options ) {
     if (elm.value) {
       if (!elm.value.stored)
         throw new CompilerAssertion('Found calculated element on-read in rendering; should have been replaced!');
-      // TODO: Properly implement calculated elements on-write:
       // The SQL standard 2016 describes the syntax in section 11.3 - 11.4
       // of the SQL Foundation spec (for 2003 in 5WD-02-Foundation-2003-09.pdf). Summarized:
       //   <generation clause> ::= GENERATED ALWAYS AS '(' <value expression> ')'
@@ -1383,7 +1372,6 @@ function toSqlDdl( csn, options ) {
     return result;
   }
 
-
   /**
    * Render the name of a builtin CDS type
    *
@@ -1487,7 +1475,7 @@ function toSqlDdl( csn, options ) {
    * @return {string}
    */
   function renderExpressionRef( x, env ) {
-    if (!x.param && !x.global) {
+    if (!x.param) {
       const magicReplacement = getVariableReplacement(x.ref, options);
 
       if (x.ref[0] === '$user') {
@@ -1499,6 +1487,15 @@ function toSqlDdl( csn, options ) {
         if (result)
           return result;
       }
+      else if (x.ref[0] === '$tenant') {
+        if (magicReplacement !== null)
+          return renderStringForSql(magicReplacement, options.sqlDialect);
+
+        const name = pathName(x.ref);
+        const result = variableForDialect(options, name);
+        if (result)
+          return result;
+      }
       else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
         const result = render$at(x);
         // Invalid second path step doesn't cause a return
@@ -1508,18 +1505,12 @@ function toSqlDdl( csn, options ) {
       else if (x.ref[0] === '$session' && magicReplacement !== null) {
         return renderStringForSql(magicReplacement, options.sqlDialect);
       }
-      else if (x.ref[0] === '$now') { // TODO: Can there be cases where $now is followed by something?
-        switch (options.sqlDialect) {
-          case 'plain':
-          case 'sqlite':
-          case 'hana':
-            return 'CURRENT_TIMESTAMP';
-          case 'h2':
-          case 'postgres':
-            return 'current_timestamp';
-          default:
-            return quoteSqlId(x.ref[0]);
-        }
+      else if (x.ref[0] === '$now') {
+        const name = pathName(x.ref);
+        const result = variableForDialect(options, name);
+        if (result)
+          return result;
+        return quoteSqlId(x.ref[0]);
       }
     }
     // FIXME: We currently cannot distinguish whether '$parameters' was quoted or not - we
@@ -1544,7 +1535,7 @@ function toSqlDdl( csn, options ) {
     if (x.ref.length > 2 || typeof x.ref[1] !== 'string')
       return null; // `$user` can only have two path steps
 
-    const name = `$user.${x.ref[1]}`;
+    const name = pathName(x.ref);
     const result = variableForDialect(options, name);
     if (result)
       return result;
@@ -1565,7 +1556,7 @@ function toSqlDdl( csn, options ) {
     if (x.ref.length > 2 || typeof x.ref[1] !== 'string')
       return null; // `$at` can only have two path steps
 
-    const name = `$at.${x.ref[1]}`;
+    const name = pathName(x.ref);
     const config = variableForDialect(options, name);
     if (config)
       return config;
@@ -1586,22 +1577,10 @@ function toSqlDdl( csn, options ) {
   function renderPathStep( s, idx, env ) {
     // Simple id or absolute name
     if (typeof (s) === 'string') {
-      // TODO: When is this actually executed and not handled already in renderExpr?
-      const magicForHana = {
-        '$user.id': 'SESSION_CONTEXT(\'APPLICATIONUSER\')',
-        '$user.locale': 'SESSION_CONTEXT(\'LOCALE\')',
-      };
       // Some magic for first path steps
-      if (idx === 0) {
-        // HANA-specific translation of '$now' and '$user'
-        // FIXME: this is all not enough: we might need an explicit select item alias
-        if (options.sqlDialect === 'hana' && magicForHana[s])
-          return magicForHana[s];
-
-        // Ignore initial $projection and initial $self
-        if (s === '$projection' || s === '$self')
-          return '';
-      }
+      // Ignore initial $projection and initial $self
+      if (idx === 0 && (s === '$projection' || s === '$self'))
+        return '';
       return quoteSqlId(s);
     }
     // ID with filters or parameters

package/lib/render/utils/common.js

@@ -344,30 +344,39 @@ function getDefaultTypeLengths( sqlDialect ) {
  */
 const variablesToSql = {
   fallback: {
-    // no fallback for $user.id and $user.tenant -> warning in call-site
+    // no fallback for $user.id and $tenant -> warning in call-site
     '$user.locale': '\'en\'',
-    // $at.* are handled in all dialects -> there is no need for a fallback
+    // $at.*/$now are handled in all dialects -> there is no need for a fallback
   },
   hana: {
     '$user.id': "SESSION_CONTEXT('APPLICATIONUSER')",
     '$user.locale': "SESSION_CONTEXT('LOCALE')",
-    '$user.tenant': "SESSION_CONTEXT('TENANT')",
+    $tenant: "SESSION_CONTEXT('APPLICATIONTENANT')",
     '$at.from': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-FROM'))",
     '$at.to': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-TO'))",
+    '$valid.from': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-FROM'))",
+    '$valid.to': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-TO'))",
+    $now: 'CURRENT_TIMESTAMP',
   },
   postgres: {
     '$user.id': "current_setting('cap.applicationuser')",
     '$user.locale': "current_setting('cap.locale')",
-    '$user.tenant': "current_setting('cap.tenant')",
+    $tenant: "current_setting('cap.tenant')",
     '$at.from': "current_setting('cap.valid_from')::timestamp",
     '$at.to': "current_setting('cap.valid_to')::timestamp",
+    '$valid.from': "current_setting('cap.valid_from')::timestamp",
+    '$valid.to': "current_setting('cap.valid_to')::timestamp",
+    $now: 'current_timestamp',
   },
   'better-sqlite': {
     '$user.id': "session_context( '$user.id' )",
     '$user.locale': "session_context( '$user.locale' )",
-    '$user.tenant': "session_context( '$user.tenant' )",
+    $tenant: "session_context( '$tenant' )",
     '$at.from': "session_context( '$valid.from' )",
     '$at.to': "session_context( '$valid.to' )",
+    '$valid.from': "session_context( '$valid.from' )",
+    '$valid.to': "session_context( '$valid.to' )",
+    $now: 'CURRENT_TIMESTAMP',
   },
   sqlite: {
     // For sqlite, we render the string-format-time (strftime) function.
@@ -377,17 +386,26 @@ const variablesToSql = {
     '$at.from': "strftime('%Y-%m-%dT%H:%M:%S.000Z', 'now')",
     // + 1ms compared to $at.from
     '$at.to': "strftime('%Y-%m-%dT%H:%M:%S.001Z', 'now')",
+    '$valid.from': "strftime('%Y-%m-%dT%H:%M:%S.000Z', 'now')",
+    '$valid.to': "strftime('%Y-%m-%dT%H:%M:%S.001Z', 'now')",
+    $now: 'CURRENT_TIMESTAMP',
   },
   plain: {
     '$at.from': 'current_timestamp',
     '$at.to': 'current_timestamp',
+    '$valid.from': 'current_timestamp',
+    '$valid.to': 'current_timestamp',
+    $now: 'CURRENT_TIMESTAMP',
   },
   h2: {
     '$user.id': '@applicationuser',
     '$user.locale': '@locale',
-    '$user.tenant': '@tenant',
+    $tenant: '@tenant',
     '$at.from': '@valid_from',
     '$at.to': '@valid_to',
+    '$valid.from': '@valid_from',
+    '$valid.to': '@valid_to',
+    $now: 'current_timestamp',
   },
 };
 

package/lib/transform/db/applyTransformations.js

@@ -85,6 +85,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
         const trans = transformers[name] || transformers[name.charAt(0)] || standard;
         if (customTransformers[name])
           customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
+        else if (options.processAnnotations && customTransformers['@'] && name.charAt(0) === '@')
+          customTransformers['@'](node, name, node[name], csnPath, _parent, _prop);
         trans( node, name, node[name], csnPath );
       }
     }
@@ -109,6 +111,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       const trans = transformers[name] || transformers[name.charAt(0)] || standard;
       if (customTransformers[name])
         customTransformers[name](node, name, node[name], csnPath, dict);
+      else if (options.processAnnotations && customTransformers['@'] && name.charAt(0) === '@')
+        customTransformers['@'](node, name, node[name], csnPath, dict);
       trans( node, name, node[name], csnPath );
     }
     csnPath.pop();
@@ -150,8 +154,13 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       else if (node && typeof node === 'object') {
         csnPath.push(_prop);
 
-        for (const name of Object.getOwnPropertyNames( node ))
-          annotation( node, name, node[name] );
+        if (Array.isArray(node)) {
+          node.forEach( (n, i) => annotation( node, i, n ) );
+        }
+        else {
+          for (const name of Object.getOwnPropertyNames( node ))
+            annotation( node, name, node[name] );
+        }
 
         csnPath.pop();
       }
@@ -287,7 +296,55 @@ function applyTransformationsOnDictionary( dictionary, customTransformers = {},
   return applyTransformationsInternal(dictionary, null, customTransformers, [], { directDict: true, ...options }, path);
 }
 
+/**
+ * transformExpression is a lightweight version of applyTransformations
+ * used primarily to transform annotation expressions.
+ * @param {object} parent Start node
+ * @param {object} customTransformers Map of callback functions
+ * @param {CSN.Path} path Path to parent
+ * @returns {object} transformed parent
+ */
+function transformExpression( parent, customTransformers, path = [] ) {
+  const csnPath = [ ...path ];
+  /**
+   *
+   * @param {object} _parent
+   * @param {string} _prop
+   * @param {object} node
+   */
+  function standard( _parent, _prop, node ) {
+    if (!node || typeof node !== 'object' ||
+        !{}.propertyIsEnumerable.call( _parent, _prop ) ||
+        (typeof _prop === 'string' && _prop.startsWith('@')))
+      return;
+
+
+    csnPath.push(_prop);
+    if (Array.isArray(node)) {
+      node.forEach( (n, i) => standard( node, i, n ) );
+    }
+    else {
+      for (const name of Object.getOwnPropertyNames( node )) {
+        const ct = customTransformers[name];
+        if (ct) {
+          if (Array.isArray(ct))
+            ct.forEach(cti => cti(node, name, node[name], csnPath, _parent, _prop));
+          else
+            ct(node, name, node[name], csnPath, _parent, _prop);
+        }
+        standard(node, name, node[name]);
+      }
+    }
+    csnPath.pop();
+  }
+
+  for (const name of Object.getOwnPropertyNames( parent ))
+    standard( parent, name, parent[name] );
+  return parent;
+}
+
 module.exports = {
+  transformExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,

package/lib/transform/db/backlinks.js

@@ -18,6 +18,7 @@ const { forEach } = require('../../utils/objectUtils');
  * @returns {import('../../model/csnUtils').genericCallback} callback for forEachDefinition
  */
 function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimiter, doA2J = true ) {
+  let prepend$self = false;
   return transformSelfInBacklinks;
   /**
    * @param {CSN.Artifact} artifact
@@ -26,12 +27,15 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {CSN.Path} path
    */
   function transformSelfInBacklinks( artifact, artifactName, dummy, path ) {
+    prepend$self = false;
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
     if (options.transformation === 'effective' && artifact.elements || artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
       processDict(artifact.elements, path.concat([ 'elements' ]));
-    if (artifact.query?.SELECT?.mixin)
+    if (artifact.query?.SELECT?.mixin) {
+      prepend$self = options.transformation === 'effective';
       processDict(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
+    }
 
     /**
      * Loop over the dict and start the processing.
@@ -237,6 +241,10 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
         { ref: k.ref },
       ];
 
+      if (prepend$self)
+        a[1].ref = [ '$self', ...a[1].ref ];
+
+
       conditions.push([ a[0], '=', a[1] ]);
     });
 
@@ -273,11 +281,15 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
         // we are in the "path" from the forwarding assoc => need to remove the first part of the path
         if (ref[0] === assocName) {
           ref.shift();
+          if (prepend$self)
+            ref.unshift('$self');
         }
         else if (ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
           // We could also have a $self in front of the assoc name - so we would need to shift twice
           ref.shift();
           ref.shift();
+          if (prepend$self)
+            ref.unshift('$self');
         }
         else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
           ref.unshift(elemName);

package/lib/transform/db/expansion.js

@@ -10,6 +10,7 @@ const {
 const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
+const { killNonrequiredAnno } = require('./killAnnotations');
 
 /**
  * For keys, columns, groupBy and orderBy, expand structured things.
@@ -27,7 +28,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
 
   rewriteExpandInline();
 
-  applyTransformations(csn, {
+  const transformers = {
     keys: (parent, name, keys, path) => {
       parent.keys = expand(keys, path.concat('keys'), true);
     },
@@ -53,7 +54,13 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     orderBy: (parent, name, orderBy, path) => {
       parent.orderBy = expand(orderBy, path.concat('orderBy'));
     },
-  }, [], iterateOptions);
+  };
+
+  // To not have a whole model loop for such a "small" thing, we kill all non-sql-backend relevant annotations here
+  if (options.transformation === 'sql' || options.transformation === 'hdbcds')
+    transformers['@'] = killNonrequiredAnno;
+
+  applyTransformations(csn, transformers, [], iterateOptions);
 
   /**
    * Turn .expand/.inline into normal refs. @cds.persistence.skip .expand with to-many (and all transitive views).
@@ -529,7 +536,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         else
           newThing.push(col);
       }
-      else if (col.ref && col.$scope === '$magic' && ( col.ref[0] === '$user' || col.ref[0] === '$session' ) && !col.as) {
+      else if (col.ref && col.$scope === '$magic' && ( col.ref[0] === '$user' || col.ref[0] === '$tenant' || col.ref[0] === '$session' ) && !col.as) {
         col.as = implicitAs(col.ref);
         newThing.push(col);
       }
@@ -618,6 +625,20 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           setProp(obj, '$implicitAlias', true);
       }
 
+      // If our column/thing was cast to a structured type, we need to keep the "cast" insync with the
+      // flattened out leaf elements that we turn the ref into
+      if (obj.cast?.type) {
+        const addedRef = currentRef.slice(root.ref.length);
+        if (addedRef.length > 0) {
+          // Decouple from other leafs
+          obj.cast = { ...obj.cast };
+          if (!obj.cast.type.ref)
+            obj.cast.type = { ref: [ obj.cast.type ] };
+
+          obj.cast.type.ref = [ ...obj.cast.type.ref, ...addedRef ];
+        }
+      }
+
       // The Java runtime, as of 2023-09-13, assumes that for _simple projections_, all references
       // are relative to the query source.  To avoid breaking that assumption unless necessary,
       // we only add the table alias if:

package/lib/transform/db/flattening.js

@@ -17,7 +17,7 @@ const { cardinality2str } = require('../../model/csnUtils');
  * @param {CSN.Model} csn
  */
 function removeLeadingSelf( csn ) {
-  const magicVars = [ '$now', '$self', '$projection', '$user', '$session', '$at' ];
+  const magicVars = [ '$now', '$self', '$projection', '$user', '$tenant', '$session', '$at' ];
   applyTransformations(csn, {
     elements: (parent, prop, elements) => {
       for (const [ elementName, element ] of Object.entries(elements)) {
@@ -184,7 +184,7 @@ function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, ite
    * For each step of the links, check if there is a type reference.
    * If there is, resolve it and store the result in a WeakMap.
    *
-   * @param {Array} [links=[]]
+   * @param {Array} [links]
    * @todo seems too hacky
    * @returns {WeakMap} A WeakMap where a link is the key and the type is the value
    */

package/lib/transform/db/killAnnotations.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const requiredAnnos = {
+  '@cds.persistence.skip': true,
+  '@cds.persistence.exists': true,
+  '@cds.persistence.table': true,
+  '@cds.persistence.journal': true, // Build checks on it
+  '@sql.append': true,
+  '@sql.prepend': true,
+  '@sql.replace': true, // We do a check on this, no real function
+  '@assert.unique': true, // We do a check on this, no real function
+  '@assert.integrity': true,
+  '@cds.valid.from': true,
+  '@cds.valid.to': true,
+  '@cds.valid.key': true,
+  '@odata.draft.enabled': true,
+  '@fiori.draft.enabled': true,
+  '@cds.persistence.calcview': true,
+  '@cds.persistence.udf': true,
+  '@cds.autoexpose': true,
+  '@cds.autoexposed': true,
+  '@cds.redirection.target': true,
+  '@Core.Computed': true,
+};
+
+/**
+ *
+ * @param {object} carrier
+ * @param {string} annoKey
+ */
+function killNonrequiredAnno( carrier, annoKey ) {
+  if (!requiredAnnos[annoKey] && !annoKey.startsWith('@assert.unique.'))
+    delete carrier[annoKey];
+}
+
+
+module.exports = { killNonrequiredAnno };