@sap/cds-dk 10.0.7 → 10.1.1

package/node_modules/@sap/cds-compiler/lib/render/utils/standardDatabaseFunctions.js

@@ -1,11 +1,24 @@
 'use strict';
 
+/**
+ * @typedef {object} FunctionRendererContext
+ * @property {Function} renderArgs - Renders a function argument node to SQL string.
+ * @property {Function} error - Compiler error reporting function.
+ * @property {string[]} path - Current CSN path for error reporting.
+ * @property {{ embeddingDefaultModel: string, embeddingHanaDefaultRemoteSource: string }} vector - Vector embedding options.
+ */
+
+/**
+ * @typedef {(this: FunctionRendererContext, signature: object) => string} DbFunction
+ */
+
 /**
  * List of functions for which we provide a mapping to the respective SQL dialect.
  * All functions are lowercase, the caller may treat the function name case-insensitive.
  *
  * The `this` context within the functions hold the `renderArgs` function.
  */
+/** @type {Record<string, Record<string, DbFunction>>} */
 const oDataFunctions = {
   // https://www.sqlite.org/lang_corefunc.html
   sqlite: {
@@ -116,7 +129,7 @@ const oDataFunctions = {
     //   let x = this.renderArgs({ ...signature, args: [ args[0] ] });
     //   const isNegative = x.startsWith("'-"); // Check for leading '-'
     //   x = isNegative ? x.replace('-', '') : x; // remove for easier processing
-    //   const sql = `((cast(substr(${x},2,instr(${x},'DT') - 2) as Integer) + (julianday('-4713-11-25T' || replace(replace(replace(substr(${x},instr(${x},'DT') + 2),'H',':'),'M',':'),'S','Z')) - 0.5)) * 86400)`;
+    //   const sql = `((cast(substr(${ x },2,instr(${ x },'DT') - 2) as Integer) + (julianday('-4713-11-25T' || replace(replace(replace(substr(${ x },instr(${ x },'DT') + 2),'H',':'),'M',':'),'S','Z')) - 0.5)) * 86400)`;
     //   return isNegative ? `-(${sql})` : sql;
     // },
   },
@@ -260,7 +273,7 @@ const oDataFunctions = {
     },
     matchespattern(signature) {
       // case … when only works as column expression (not in where)
-      // in the where clause, only "${x} LIKE_REGEXPR ${y}" works
+      // in the where clause, only "${ x } LIKE_REGEXPR ${ y }" works
       const args = getArgs(signature);
       checkArgs.call(this, 'matchespattern', args, 2);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
@@ -556,6 +569,7 @@ const oDataFunctions = {
   },
 };
 
+/** @type {Record<string, Record<string, DbFunction>>} */
 const hanaFunctions = {
   sqlite: {
     /**
@@ -659,6 +673,11 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `floor((${ hanaFunctions.sqlite.months_between.call(this, signature) }) / 12)`;
     },
+
+    //
+    // Note: Vector functions for SQLite (cosine_similarity, l2distance, l2normalize and vector_embedding) have the
+    // same parameters as on HANA because we provide them via UDFs
+    //
   },
   postgres: {
     nano100_between(signature) {
@@ -697,6 +716,33 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `floor((${ hanaFunctions.postgres.months_between.call(this, signature) }) / 12)::INTEGER`;
     },
+
+    //
+    // Vector functions for postgres vector support based on the https://github.com/pgvector/pgvector
+    //
+    cosine_similarity(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'cosine_similarity', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `1 - cosine_distance(${ x },${ y })`;
+    },
+    l2distance(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2distance', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `l2_distance(${ x },${ y })`;
+    },
+    l2normalize(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2normalize', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+
+      return `l2_normalize(${ x })`;
+    },
   },
   h2: {
     nano100_between(signature) {
@@ -757,8 +803,18 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `floor((${ hanaFunctions.h2.months_between.call(this, signature) }) / 12)`;
     },
+
+    //
+    // Note: Vector functions for H2 (cosine_similarity, l2distance, l2normalize, and vector_embedding) have the
+    // same parameters as on HANA because we provide them via UDFs
+    //
+  },
+  common: {
+    vector_embedding(signature) {
+      /** @type {FunctionRendererContext} */ const ctx = /** @type {any} */ (this);
+      return vectorEmbedding.call(ctx, signature);
+    },
   },
-  common: {},
   // identity functions + argument check
   hana: {
     nano100_between(signature) {
@@ -797,8 +853,67 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `years_between(${ this.renderArgs({ ...signature, args }) })`;
     },
+
+    //
+    // Vector functions - only identity check
+    //
+    cosine_similarity(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'cosine_similarity', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `cosine_similarity(${ x },${ y })`;
+    },
+    l2distance(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2distance', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `l2distance(${ x },${ y })`;
+    },
+    l2normalize(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2normalize', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+
+      return `l2normalize(${ x })`;
+    },
+    vector_embedding(signature) {
+      /** @type {FunctionRendererContext} */ const ctx = /** @type {any} */ (this);
+      const sql = vectorEmbedding.call(ctx, signature);
+      if (sql.match('SAP.'))
+        return sql;
+      // If the model does not start with SAP an additional fourth parameter
+      // is necessary specifying the remote source behind which SAP AI Core lies on HANA
+      return `${ sql.substring(0, sql.length - 1) }, ${ this.vector.embeddingHanaDefaultRemoteSource })`;
+    },
   },
 };
+/**
+ * Arguments:
+ * 1. (mandatory) property for which to generate a vector
+ * 2. (optional) DOCUMENT / QUERY kind for embedding function. If not provided we default to 'DOCUMENT'
+ * 3. (optional) model. If not provided we default to a compiler setting or else the SAP NXY model
+ * @this {FunctionRendererContext}
+ * @param {object} signature
+ * @returns {string}
+ */
+function vectorEmbedding( signature ) {
+  const args = getArgs(signature);
+  // Default to kind DOCUMENT if no kind is specified
+  if (args.length === 1)
+    args.push('DOCUMENT');
+  // Default to the compiler option vectorEmbeddingDefaultModel if no model is specified
+  if (args.length === 2)
+    args.push(this.vector.embeddingDefaultModel);
+  checkArgs.call(this, 'vector_embedding', args, 3);
+  const field = this.renderArgs({ ...signature, args: [ args[0] ] });
+  const kind = this.renderArgs({ ...signature, args: [ args[1] ] });
+  const model = this.renderArgs({ ...signature, args: [ args[2] ] });
+  return `vector_embedding(${ field }, ${ kind }, ${ model })`;
+}
 
 /**
  * Normalizes `signature.args` to a positional array, handling both
@@ -808,6 +923,13 @@ function getArgs( signature ) {
   return Array.isArray(signature.args) ? signature.args : Object.values(signature.args);
 }
 
+/**
+ * @this {FunctionRendererContext}
+ * @param {string} funcName
+ * @param {any[]} receivedArgs
+ * @param {number} expectedLength
+ * @param {number | null} alternativeLength
+ */
 function checkArgs( funcName, receivedArgs, expectedLength, alternativeLength = null ) {
   const expectedMismatch = receivedArgs.length < expectedLength;
   const alternativeMismatch

package/node_modules/@sap/cds-compiler/lib/tool-lib/revealInternalProperties.js

@@ -15,6 +15,7 @@
 
 const msg = require('../base/messages');
 const { CompilerAssertion } = require('../base/error');
+const { isLeadingQuery } = require('../compiler/utils');
 
 const $inferred = Symbol.for('cds.$inferred');
 const $location = Symbol.for('cds.$location');
@@ -206,7 +207,7 @@ function revealInternalProperties( model, nameOrPath ) {
 
   function elements( dict, parent ) {
     // do not display elements of leading query as they are the same as the view elements:
-    return (parent._main && parent._main._leadingQuery === parent)
+    return (isLeadingQuery( parent ))
       ? '{ ... }'
       : dictionary( dict );
   }

package/node_modules/@sap/cds-compiler/lib/transform/db/applyTransformations.js

@@ -41,6 +41,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     mixin: dictionary,
     ref: pathRef,
     $origin: () => {}, // no-op
+    $backlink: () => undefined,
     '@': annotation,
   };
 
@@ -68,6 +69,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    * @param {object} node The value of node[_prop]
    */
   function standard( _parent, _prop, node ) {
+    if (_prop === '$backlink')  // above line in transformers doesn't seem to help...
+      return;                   // ...in the OData backend
     if (!node || typeof node !== 'object' ||
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
         (options.skipIgnore && node.$ignore) ||
@@ -420,6 +423,17 @@ function mergeTransformers( transformers, that ) {
   return remapped;
 }
 
+/**
+ * Return true if the annotation expression ref node is a simple reference:
+ * all ref steps are plain strings, and the node has neither `param` nor `cast`.
+ *
+ * @param {object} annotation An annotation expression node (has `ref`, optionally `param`, `cast`)
+ * @returns {boolean}
+ */
+function isSimpleAnnoExprRef(annotation) {
+  return annotation.ref && annotation.ref.every(s => typeof s === 'string') && !annotation.param && !annotation.cast;
+}
+
 module.exports = {
   mergeTransformers,
   transformExpression,
@@ -427,6 +441,7 @@ module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
+  isSimpleAnnoExprRef,
 };
 
 

package/node_modules/@sap/cds-compiler/lib/transform/db/associations.js

@@ -5,6 +5,7 @@ const {
   applyTransformationsOnNonDictionary,
   applyTransformations,
   implicitAs,
+  isSimpleAnnoExprRef,
 } = require('../../model/csnUtils');
 
 /**
@@ -136,7 +137,9 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
         if (obj[anno].ref)
           transformer.ref(obj[anno], 'ref', obj[anno].ref, path.concat(anno));
         const annoAfter = JSON.stringify(obj[anno]);
-        if (annoBefore !== annoAfter && (options.transformation !== 'effective' || obj[anno]['=']))
+        if (annoBefore !== annoAfter &&
+            (options.transformation !== 'effective' || obj[anno]['=']) &&
+            !(obj[anno].ref && isSimpleAnnoExprRef(obj[anno])))
           obj[anno]['='] = true;
       });
   }
@@ -219,7 +222,7 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
      */
     function getTransformer() {
       return {
-        ref: (refOwner, prop, ref, path, grandParent) => {
+        ref: (refOwner, prop, ref, path, grandParent, _opt, ctx) => {
           // [<assoc base>.]<managed assoc>.<field>
           if (ref.length > 1) {
             const { links } = inspectRef(path);
@@ -249,6 +252,11 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
                     else {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];
                     }
+                    if (ctx?.annoExpr === refOwner) {
+                      ctx.annoExpr['='] = isSimpleAnnoExprRef(refOwner)
+                        ? refOwner.ref.join('.')
+                        : true;
+                    }
                   }
                 }
                 else {

package/node_modules/@sap/cds-compiler/lib/transform/db/backlinks.js

@@ -175,12 +175,14 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @returns {Array} New on-condition
    */
   function transformDollarSelfComparison( assocOp, assoc, assocName, elem, elemName, art, artifactName, path ) {
-    // Check: The forward link <assocOp> must point back to this artifact
+    // Check: The forward link <assocOp> must point back to this artifact.
+    // Skip when `$backlink` is present: the core compiler already validated the (possibly
+    // redirected/included) target and provided the redirected keys/on
     // FIXME: Unfortunately, we can currently only check this for non-views (because when a view selects
     // a backlink association element from an entity, the forward link will point to the entity,
     // not to the view).
     // FIXME: This also means that corresponding key fields should be in the select list etc ...
-    if (!art.query && !art.projection && assoc.target && assoc.target !== artifactName) {
+    if (!elem.$backlink && !art.query && !art.projection && assoc.target && assoc.target !== artifactName) {
       messageFunctions.error( null, path, { id: '$self', name: artifactName, target: assoc.target },
                               'Expected association using $(ID) to point back to $(NAME) but found $(TARGET)' );
     }
@@ -199,6 +201,16 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
       return [];
     }
 
+    // Prefer the `$backlink` helper (renaming-aware, target redirected to this artifact)
+    // over the backlink's own keys/on, so renamings are considered. Absent for
+    // same-entity backlinks, where the plain keys/on below are already correct.
+    const backlink = elem.$backlink;
+
+    if (Array.isArray(backlink))
+      return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName, art, path, backlink);
+    if (backlink?.keys?.length)
+      return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName, art, path, backlink);
+
     if (assoc.keys) {
       // Transform comparison of $self to managed association into AND-combined foreign key comparisons
       if (assoc.keys.length > 0)
@@ -230,16 +242,19 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {string} elemName
    * @param {CSN.Artifact} art
    * @param {CSN.Path} path
+   * @param {object} [backlink] renaming-aware `elem.$backlink` (`{ keys }`) to use instead of `assoc.keys`
    * @returns {Array} New on-condition
    */
-  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path) {
+  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path, backlink ) {
     const conditions = [];
     // if the element was structured then it was flattened => change of the delimiter from '.' to '_'
     // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
     const assocName = originalAssocName.replace(/\./g, pathDelimiter);
     elemName = elemName.replace(/\./g, pathDelimiter);
 
-    assoc.keys.forEach((k) => {
+    const keys = backlink?.keys ?? assoc.keys;
+
+    keys.forEach((k) => {
       // Depending on naming conventions, the foreign key may two path steps (hdbcds) or be a single path step with a flattened name (plain, quoted)
       // With to.hdbcds in conjunction with hdbcds naming, we need to NOT use the alias - else we get deployment errors
       const keyName = k.as && doA2J ? [ k.as ] : k.ref;
@@ -282,15 +297,16 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {string} elemName
    * @param {CSN.Artifact} art
    * @param {CSN.Path} path
+   * @param {Array} [backlink] renaming-aware `elem.$backlink` ON-condition to use instead of `assoc.on`
    * @returns {Array} New on-condition
    */
-  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path ) {
+  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path, backlink ) {
     // if the element was structured then it may have been flattened => change of the delimiter from '.' to '_'
     // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
     elemName = elemName.replace(/\./g, pathDelimiter);
     const assocName = originalAssocName.replace(/\./g, pathDelimiter);
     // clone the onCond for later use in the path transformation
-    const newOnCond = cloneCsnNonDict(assoc.on, options);
+    const newOnCond = cloneCsnNonDict(backlink ?? assoc.on, options);
     applyTransformationsOnNonDictionary({ on: newOnCond }, 'on', {
       ref: (parent, prop, ref) => {
         let sourceSide = false;

package/node_modules/@sap/cds-compiler/lib/transform/db/constraints.js

@@ -592,6 +592,67 @@ function createReferentialConstraints( csn, options ) {
   }
 }
 
+/**
+ * Add an `ON DELETE CASCADE` referential constraint on the `DraftAdministrativeData_DraftUUID`
+ * foreign key of each draft shadow table, so deleting a draft's `DRAFT.DraftAdministrativeData`
+ * row removes all its shadow rows.
+ *
+ * Runs after the draft shadow entities exist (they don't during `createReferentialConstraints`).
+ * Their `DraftAdministrativeData` association is unmanaged and points at the service view, so the
+ * regular pass skips it; this pass references the `DRAFT.DraftAdministrativeData` table directly.
+ *
+ * Opt-in via the `draftAdminDataConstraints` option and independent of the global
+ * `assertIntegrity` / `assertIntegrityType` switches.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ */
+function createDraftAdminDataConstraints( csn, options ) {
+  if (options.draftAdminDataConstraints !== true)
+    return;
+
+  const draftAdminData = 'DRAFT.DraftAdministrativeData';
+  if (!csn.definitions[draftAdminData])
+    return;
+
+  const delimiter = options.sqlMapping === 'hdbcds' ? '.' : '_';
+  const foreignKeyName = `DraftAdministrativeData${ delimiter }DraftUUID`;
+
+  const validated = !options.integrityNotValidated;
+  const enforced = !options.integrityNotEnforced;
+
+  forEach(csn.definitions, ( artifactName, artifact ) => {
+    if (artifact.kind !== 'entity' || artifact.query || artifact.projection)
+      return;
+    const foreignKey = artifact.elements?.[foreignKeyName];
+    const assoc = artifact.elements?.DraftAdministrativeData;
+    // only draft shadow tables have both the association and its flattened foreign key
+    if (!foreignKey || !assoc || assoc.type !== ASSOCIATION)
+      return;
+
+    const identifierPrefix = options.pre2134ReferentialConstraintNames ? '' : 'c__';
+    const identifier = `${ identifierPrefix }${ getResultingName(csn, options.sqlMapping, artifactName) }_DraftAdministrativeData`;
+    const mapKey = `${ getResultingName(csn, 'quoted', artifactName) }_DraftAdministrativeData`;
+
+    if (!('$tableConstraints' in artifact))
+      artifact.$tableConstraints = Object.create(null);
+    if (!artifact.$tableConstraints.referential)
+      artifact.$tableConstraints.referential = Object.create(null);
+
+    artifact.$tableConstraints.referential[mapKey] = {
+      identifier,
+      foreignKey: [ foreignKeyName ],
+      parentKey: [ 'DraftUUID' ],
+      dependentTable: artifactName,
+      parentTable: draftAdminData,
+      onDelete: 'CASCADE',
+      onDeleteRemark: options.testMode ? 'Draft shadow entries are deleted when their DraftAdministrativeData entry is deleted' : null,
+      validated,
+      enforced,
+    };
+  });
+}
+
 /**
  * If the artifact has both, unique- and foreign key constraints, it is possible that the constraints have the same identifier.
  * This would end in table which can't be activated.
@@ -616,4 +677,4 @@ function assertConstraintIdentifierUniqueness( artifact, artifactName, path, err
   });
 }
 
-module.exports = { createReferentialConstraints, assertConstraintIdentifierUniqueness };
+module.exports = { createReferentialConstraints, createDraftAdminDataConstraints, assertConstraintIdentifierUniqueness };

package/node_modules/@sap/cds-compiler/lib/transform/db/flattening.js

@@ -11,7 +11,7 @@ const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../base/csnRefs');
 const { setProp, forEach } = require('../../utils/objectUtils');
-const { transformExpression } = require('./applyTransformations');
+const { transformExpression, isSimpleAnnoExprRef } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../base/cloneCsn');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
 const { adaptAnnotationsRefs } = require('../odata/adaptAnnotationRefs');
@@ -246,7 +246,8 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
         adaptRefs.push((...args) => {
           const refChanged = fn(...args);
           if (refChanged && annotation['='])
-            annotation['='] = true;
+            // For simple refs (all-string steps, no param/cast), = contains the string representation of the ref.
+            annotation['='] = isSimpleAnnoExprRef(annotation) ? annotation.ref.join('.') : true;
         });
       }
       else {
@@ -664,7 +665,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
         }
 
         if (options.transformation === 'effective') {
-          adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath);
+          adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath, options);
           const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && findAnnotationExpression(element, pn));
           fks.forEach(fk => copyAnnotations(element, fk[1], false, {}, validAnnoNames));
         }

package/node_modules/@sap/cds-compiler/lib/transform/effective/annotations.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const { CompilerAssertion } = require('../../base/error');
+const { transformAnnotationExpression } = require('../../model/csnUtils');
+const { expressionToCdlString } = require('../../render/toCdl');
 const { forEach } = require('../../utils/objectUtils');
 
 const directMappings = {
@@ -283,6 +285,43 @@ function sealAnnoMagic(csn) {
   };
 }
 
+/**
+ * Replace all annotation expression nodes with their CDL-like string representation.
+ *
+ * @param {CSN.Model} _csn
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions
+ * @returns {object} Transformer object for applyTransformations
+ */
+function stringifyAnnotationExpressions( _csn, options, messageFunctions ) {
+  // exclude '#' so enum-symbol annotation values are kept as is
+  const expressionTransformers = {
+    ref: stringifyExpression,
+    xpr: stringifyExpression,
+    list: stringifyExpression,
+    val: stringifyExpression,
+    func: stringifyExpression,
+    SELECT: stringifyExpression,
+    SET: stringifyExpression,
+  };
+
+  return {
+    '@': (parent, prop, _anno, path) => transformAnnotationExpression(parent, prop, expressionTransformers, path),
+  };
+
+  function stringifyExpression( expressionNode, _prop, _value, _path, parent, parentProp ) {
+    // Keep unchecked refs that already have textual representation.
+    if (expressionNode.ref && typeof expressionNode['='] === 'string') {
+      delete expressionNode.ref;
+      delete expressionNode.param;
+      delete expressionNode.cast;
+      return;
+    }
+
+    parent[parentProp] = expressionToCdlString(expressionNode, options, messageFunctions);
+  }
+}
+
 function isPartOfINAService(csn, artifactName) {
   const parts = artifactName.split('.');
   if (parts.length === 1)
@@ -339,4 +378,5 @@ function getOnConditionAsComparisonTuples(on, assocName) {
 module.exports = {
   remapODataAnnotations,
   sealAnnoMagic,
+  stringifyAnnotationExpressions,
 };

package/node_modules/@sap/cds-compiler/lib/transform/effective/flattening.js

@@ -53,6 +53,18 @@ function flattenRefs(csn, options, csnUtils, messageFunctions) {
   const refFlattener = getStructStepsFlattener(csn, options, messageFunctions, resolved, '_', adaptRefs);
 
   forEachDefinition(csn, (def, defName) => {
+    // Unbound actions/functions/events: only flatten annotation expressions, not params.
+    // Their params may carry $self on-conditions that cannot be resolved without a query context.
+    if (def.kind === 'action' || def.kind === 'function' || def.kind === 'event') {
+      forEachMemberRecursively(def, (member, memberName, prop, path) => {
+        Object.keys(member).filter(pn => pn.startsWith('@') && member[pn]).forEach((pn) => {
+          transformAnnotationExpression(member, pn, [ refFlattener ], path);
+          adaptRefs.forEach(fn => fn());
+          adaptRefs.length = 0;
+        });
+      }, [ 'definitions', defName ]);
+      return;
+    }
     applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: true, skipDict: { actions: 1 } }, [ 'definitions' ]);
 
     adaptRefs.forEach(fn => fn());
@@ -97,8 +109,12 @@ function flattenRefs(csn, options, csnUtils, messageFunctions) {
   });
 
   cleanup.forEach((obj) => {
-    if (obj.ref && obj.ref[0] === '$self')
+    // strip leading $self from ref array and (if it is a string) from '='
+    if (obj.ref && obj.ref[0] === '$self') {
       obj.ref.shift();
+      if (typeof obj['='] === 'string' && obj['='].startsWith('$self.'))
+        obj['='] = obj['='].slice('$self.'.length);
+    }
   });
 }
 

package/node_modules/@sap/cds-compiler/lib/transform/effective/main.js

@@ -103,6 +103,25 @@ function effectiveCsn( model, options, messageFunctions ) {
 
   resolveTypesInActionsAfterFlattening(csnUtils);
 
+  // Rewrite association keys in unbound action/function params to use flattened names.
+  // Not needed for bound actions: their params are reached via the parent entity and handled by flattenFKs in managedToUnmanaged.
+  forEachDefinition(csn, (def) => {
+    if (def.kind !== 'action' && def.kind !== 'function')
+      return;
+    if (!def.params)
+      return;
+    for (const param of Object.values(def.params)) {
+      if (!param.elements)
+        continue;
+      for (const element of Object.values(param.elements)) {
+        if (element.keys)
+          element.keys.forEach((key) => {
+            key.ref = [ key.ref.join('_') ];
+          });
+      }
+    }
+  });
+
   processCalculatedElementsInEntities(csn, options);
   // invalidate csnRef caches after flattening
   transformerUtils.csnUtils = getUtils(csn, 'init-all');
@@ -113,6 +132,7 @@ function effectiveCsn( model, options, messageFunctions ) {
     options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
     misc.removeDefinitionsAndProperties(csn, options),
     options.deriveAnalyticalAnnotations ? annotations.sealAnnoMagic(csn) : {},
+    options.stringifyAnnoXpr ? annotations.stringifyAnnotationExpressions(csn, options, messageFunctions) : {},
   ], null);
 
   if (options.addCdsPersistenceName) {

package/node_modules/@sap/cds-compiler/lib/transform/fioriTreeViews.js

@@ -16,7 +16,7 @@ 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, options) {
+function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers, options, csn) {
   const { error, warning } = messageFunctions;
   const { isAssociation } = csnUtils;
   const { setAnnotation, addElement, createScalarElement } = transformers;
@@ -157,6 +157,17 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
   }
 
   function addHierarchyFields(def, defName) {
+    addHierarchyFieldsTo(def, defName);
+
+    // The localized convenience view is a stand-in for the annotated view at
+    // runtime, so it must carry the same hierarchy columns. It is generated
+    // before this transform runs, hence it is augmented here explicitly.
+    const localizedView = csn?.definitions?.[`localized.${ defName }`];
+    if (localizedView)
+      addHierarchyFieldsTo(localizedView, `localized.${ defName }`);
+  }
+
+  function addHierarchyFieldsTo(def, defName) {
     // add elements in elements dictionary
     const limitedDescendantCount = createScalarElement('LimitedDescendantCount', 'cds.Integer');
     limitedDescendantCount.LimitedDescendantCount['@Core.Computed'] = true;

package/node_modules/@sap/cds-compiler/lib/transform/forRelationalDB.js

@@ -17,7 +17,7 @@ const validate = require('../checks/validator');
 const { addTenantFields } = require('../transform/addTenantFields');
 const { addLocalizationViewsWithJoins } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
-const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
+const { createReferentialConstraints, createDraftAdminDataConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { setProp, forEach } = require('../utils/objectUtils');
 const handleExists = require('./db/assocsToQueries/transformExists');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('./db/rewriteCalculatedElements');
@@ -340,6 +340,11 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // no constraints for drafts
   generateDrafts(csn, options, pathDelimiter, messageFunctions);
 
+  // the DraftAdministrativeData_DraftUUID foreign key still gets a cascade constraint;
+  // must run after generateDrafts, as the shadow tables don't exist before
+  if (options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2')
+    createDraftAdminDataConstraints(csn, options);
+
   // Set the final constraint paths and produce hana tc indexes if required
   // See function comment for extensive information.
   assertUnique.rewrite(csn, options, pathDelimiter);
@@ -362,7 +367,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     findAndMarkSqlServiceArtifacts(artifact, artifactName);
     if (artifact.$dummyService)
       createServiceDummy(artifact, artifactName, csn, messageFunctions);
-    generateFioriTreeViews(artifact, artifactName, messageFunctions, csnUtils, { setAnnotation, addElement, createScalarElement }, options);
+    generateFioriTreeViews(artifact, artifactName, messageFunctions, csnUtils, { setAnnotation, addElement, createScalarElement }, options, csn);
   }, transformViews ]);
 
   // TODO: Could we maybe merge this with the final applyTransformations?