@sap/cds-compiler 5.7.4 → 5.8.2

package/lib/render/utils/standardDatabaseFunctions.js

@@ -99,7 +99,7 @@ const oDataFunctions = {
       const { args } = signature;
       checkArgs.call(this, 'date', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `date(${x}) `;
+      return `date(${x})`;
     },
     // this could also be a negative number
     // also, parts of the EDM.duration are optional which complicates
@@ -199,19 +199,19 @@ const oDataFunctions = {
       const { args } = signature;
       checkArgs.call(this, 'fractionalseconds', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `CAST(date_part('second', ${x}) - floor(date_part('second', ${x})) AS DECIMAL(3,3))`;
+      return `cast(date_part('second', ${x}) - floor(date_part('second', ${x})) AS DECIMAL(3,3))`;
     },
     time(signature) {
       const { args } = signature;
       checkArgs.call(this, 'time', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `to_char(${x}, 'HH24:MI:SS')`;
+      return `to_char(${x}, 'HH24:MI:SS')::TIME`;
     },
     date(signature) {
       const { args } = signature;
       checkArgs.call(this, 'date', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `to_char(${x}, 'YYYY-MM-DD')`;
+      return `${x}::DATE`;
     },
   },
   // https://help.sap.com/docs/HANA_SERVICE_CF/7c78579ce9b14a669c1f3295b0d8ca16/f12b86a6284c4aeeb449e57eb5dd3ebd.html?locale=en-US
@@ -309,13 +309,13 @@ const oDataFunctions = {
       const { args } = signature;
       checkArgs.call(this, 'time', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `cast(to_time(${x}) AS NVARCHAR)`;
+      return `to_time(${x})`;
     },
     date(signature) {
       const { args } = signature;
       checkArgs.call(this, 'date', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `cast(to_date(${x}) AS NVARCHAR)`;
+      return `to_date(${x})`;
     },
   },
   // https://www.h2database.com/html/functions.html
@@ -429,13 +429,13 @@ const oDataFunctions = {
       const { args } = signature;
       checkArgs.call(this, 'time', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `cast(cast(${x} AS TIME) AS VARCHAR)`;
+      return `cast(${x} AS TIME)`;
     },
     date(signature) {
       const { args } = signature;
       checkArgs.call(this, 'date', args, 1);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
-      return `cast(cast(${x} AS DATE) AS VARCHAR)`;
+      return `cast(${x} AS DATE)`;
     },
   },
   common: {
@@ -544,18 +544,255 @@ const oDataFunctions = {
   },
 };
 
-// TODO: add support for the common SAP HANA Functions
 const hanaFunctions = {
-  sqlite: {},
-  postgres: {},
-  hana: { /* no-op */ },
-  h2: {},
+  sqlite: {
+    /**
+     * SQLite relies on floating-point arithmetic for date/time calculations, which can introduce
+     * slight imprecisions due to the use of the `julianday` function. The `julianday` function
+     * computes the difference between two timestamps as a floating-point value in days, which
+     * is then scaled to nano100 units (0.1 microseconds). While this approach is efficient,
+     * the inherent precision limits of floating-point arithmetic can result in small deviations
+     * (e.g., off by a few nano100 units).
+     *
+     * @param {Object} signature - The function signature containing arguments.
+     * @returns {string} - SQL expression to calculate the nano100 difference in SQLite.
+     */
+    nano100_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'nano100_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      // 1 day = 24h*60m*60s*10'000'000 = 864'000'000'000 nano100
+      return `CAST(((julianday(${y}) - julianday(${x})) * 864000000000) as INTEGER)`;
+    },
+    seconds_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'seconds_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `CAST(strftime('%s', ${y}) - strftime('%s', ${x}) AS INTEGER)`;
+    },
+    days_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'days_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `(CASE WHEN (strftime('%s', ${y}) - strftime('%s', ${x})) < 86400 AND (strftime('%s', ${y}) - strftime('%s', ${x})) > -86400 THEN 0 ELSE CAST((strftime('%s', ${y}) - strftime('%s', ${x})) / 86400 AS INTEGER) END)`;
+    },
+    /**
+     * Calculates the difference in months between two dates, `x` and `y`, with a correction for partial months.
+     *
+     * The computation consists of:
+     *
+     * 1. Year/Month Difference:
+     *    - Extracts the year and month parts from both dates and computes a raw difference:
+     *      (year(y) - year(x)) * 12 + (month(y) - month(x)).
+     *
+     * 2. Partial-Month Correction:
+     *    - Generates a composite value of day and time components from each date using:
+     *      strftime('%d%H%M%S%f0000', date)
+     *      This zero-padded composite includes day, hour, minute, second, and fractional seconds.
+     *    - For a forward interval (when y is after or equal to x):
+     *         If the composite for y is less than that for x, then the final month is incomplete, so subtract 1.
+     *    - For a backward interval (when y is before x):
+     *         If the composite for y is greater than that for x, then the final month is incomplete, so add 1.
+     *
+     * 3. Leap-Year Adjustment:
+     *    - The composite value inherently captures all day/time details (including the leap day, Feb 29),
+     *      so the extra day in a leap year is automatically accounted for in the partial-month correction.
+     *
+     * @param {object} signature - Contains the function arguments.
+     * @returns {string} A SQL expression that calculates the adjusted month difference.
+     */
+    months_between(signature) {
+      // Ensure exactly two arguments (startDate, endDate)
+      checkArgs.call(this, 'months_between', signature.args, 2);
+
+      // Render the arguments as SQL expressions.
+      const x = this.renderArgs({ ...signature, args: [ signature.args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ signature.args[1] ] });
+
+      // Construct the SQL expression:
+      // 1. Base month difference from the year and month components.
+      // 2. Partial-month correction using a composite integer of day and time.
+      const res = `
+        (
+          (
+            (CAST(strftime('%Y', ${y}) AS Integer) - CAST(strftime('%Y', ${x}) AS Integer)) * 12
+          )
+          +
+          (
+            CAST(strftime('%m', ${y}) AS Integer) - CAST(strftime('%m', ${x}) AS Integer)
+          )
+          +
+          (
+            CASE
+              /* For backward intervals: if the composite (day + time) of y is greater than x, add 1. */
+              WHEN CAST(strftime('%Y%m', ${y}) AS Integer) < CAST(strftime('%Y%m', ${x}) AS Integer)
+                THEN (CAST(strftime('%d%H%M%S%f0000', ${y}) AS Integer) > CAST(strftime('%d%H%M%S%f0000', ${x}) AS Integer))
+              /* For forward intervals: if the composite of y is less than x, subtract 1. */
+              ELSE (CAST(strftime('%d%H%M%S%f0000', ${y}) AS Integer) < CAST(strftime('%d%H%M%S%f0000', ${x}) AS Integer)) * -1
+            END
+          )
+        )
+      `;
+      // Remove extra whitespace and return the single-line SQL expression.
+      return res.replace(/\s+/g, ' ');
+    },
+    years_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'years_between', args, 2);
+      return `floor((${hanaFunctions.sqlite.months_between.call(this, signature)}) / 12)`;
+    },
+  },
+  postgres: {
+    nano100_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'nano100_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      // make sure to cast NUMERIC to BIGINT (corresponds to cds.Int64)
+      return `(EXTRACT(EPOCH FROM (${y}) - (${x})) * 10000000)::BIGINT`;
+    },
+    seconds_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'seconds_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `EXTRACT(EPOCH FROM (${y}) - (${x}))::BIGINT`;
+    },
+    days_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'days_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `EXTRACT(DAY FROM ${y}::timestamp - ${x}::timestamp)::integer`;
+    },
+    months_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'months_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `(EXTRACT(YEAR FROM AGE(${y}, ${x})) * 12 + EXTRACT(MONTH FROM AGE(${y}, ${x})))::INTEGER`;
+    },
+    years_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'years_between', args, 2);
+      return `floor((${hanaFunctions.postgres.months_between.call(this, signature)}) / 12)::INTEGER`;
+    },
+  },
+  h2: {
+    nano100_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'nano100_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `CAST(DATEDIFF('MICROSECOND', ${x}, ${y}) * 10 AS BIGINT)`;
+    },
+    seconds_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'seconds_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `CAST(DATEDIFF('SECOND', ${x}, ${y}) AS BIGINT)`;
+    },
+    days_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'days_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `CASE WHEN ABS(DATEDIFF('SECOND', ${x}, ${y})) < 86400 THEN 0 ELSE CAST(FLOOR(DATEDIFF('SECOND', ${x}, ${y}) / 86400) AS INTEGER) END`;
+    },
+    /**
+     * Uses DATEDIFF('MONTH') and then applies a partial-month correction for day-of-month boundaries in both
+     * forward and backward (negative) scenarios.
+     */
+    months_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'months_between', args, 2);
+
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      const res = `
+        CAST(
+          DATEDIFF('MONTH', ${x}, ${y})
+          + CASE
+              WHEN DATEDIFF('DAY', ${x}, ${y}) >= 0
+                   AND EXTRACT(DAY FROM ${y}) < EXTRACT(DAY FROM ${x})
+              THEN -1
+    
+              WHEN DATEDIFF('DAY', ${x}, ${y}) < 0
+                   AND EXTRACT(DAY FROM ${y}) > EXTRACT(DAY FROM ${x})
+              THEN 1
+    
+              ELSE 0
+            END
+          AS INTEGER
+        )
+      `;
+      return res.replace(/\s+/g, ' ');
+    },
+    years_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'years_between', args, 2);
+      return `floor((${hanaFunctions.h2.months_between.call(this, signature)}) / 12)`;
+    },
+  },
   common: {},
+  // identity functions + argument check
+  hana: {
+    nano100_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'nano100_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `nano100_between(${x}, ${y})`;
+    },
+    seconds_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'seconds_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `seconds_between(${x}, ${y})`;
+    },
+    days_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'days_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `days_between(${x}, ${y})`;
+    },
+    months_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'months_between', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `months_between(${x}, ${y})`;
+    },
+    years_between(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'years_between', args, 2);
+      return `years_between(${this.renderArgs(signature)})`;
+    },
+  },
 };
 
 function checkArgs( funcName, receivedArgs, expectedLength, alternativeLength = null ) {
   const expectedMismatch = receivedArgs.length < expectedLength;
-  const alternativeMismatch = expectedMismatch && (!alternativeLength || alternativeLength && receivedArgs.length < alternativeLength);
+  const alternativeMismatch
+    = expectedMismatch &&
+    (!alternativeLength ||
+      (alternativeLength && receivedArgs.length < alternativeLength));
   if (expectedMismatch && alternativeMismatch) {
     this.error('def-missing-argument', [ ...this.path, 'args' ], {
       '#': alternativeLength ? 'alternative' : 'std',
@@ -565,7 +802,7 @@ function checkArgs( funcName, receivedArgs, expectedLength, alternativeLength =
       name: funcName,
     });
   }
-};
+}
 
 module.exports.standardDatabaseFunctions = {
   sqlite: { ...oDataFunctions.sqlite, ...hanaFunctions.sqlite },

package/lib/transform/addTenantFields.js

@@ -18,7 +18,12 @@
 'use strict';
 
 const { createMessageFunctions } = require( '../base/messages' );
-const { csnRefs, traverseQuery, implicitAs } = require( '../model/csnRefs' );
+const {
+  csnRefs,
+  traverseQuery,
+  implicitAs,
+  pathId,
+} = require( '../model/csnRefs' );
 
 const annoTenantIndep = '@cds.tenant.independent';
 
@@ -85,7 +90,7 @@ function addTenantFields( csn, options, messageFunctions ) {
       independent = art.kind;   // might be used for message variant
       checkIncludes( art );     // recompile should work
     }
-    else if (projection) {      // events - TODO: mention in doc
+    else if (projection) {      // events, types - TODO: mention in doc
       independent = art.kind;   // might be used for message variant
       // recompile should work: no new `tenant` source element for `select *`
       traverseQuery( projection, null, null, handleQuery );
@@ -187,12 +192,13 @@ function addTenantFields( csn, options, messageFunctions ) {
 
   function handleQuerySource( query ) {
     if (independent) {
-      const art = query.ref[0]; // yes, the base
+      const art = pathId(query.ref[0]); // yes, the base
       if (csn.definitions[art][annoTenantIndep])
         return true;
       error( 'tenant-invalid-query-source', msgLocations( csnPath ), { art, '#': independent }, {
         std: 'Can\'t use a tenant-dependent query source $(ART) in a tenant-independent entity',
         event: 'Can\'t use a tenant-dependent query source $(ART) in an event',
+        type: 'Can\'t use a tenant-dependent query source $(ART) in a type definition',
       } );
       return true;
     }

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

@@ -346,6 +346,9 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       },
     };
 
+    if (assocRef.args) // copy named arguments
+      subselect.SELECT.from.ref = [ { id: target, args: assocRef.args } ];
+
     setProp(subselect.SELECT.from, '_art', csn.definitions[target]);
     setProp(subselect.SELECT.from, '_links', [ { idx: 0, art: csn.definitions[target] } ]);
 

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

@@ -106,14 +106,21 @@ function getHelpers( csn, inspectRef, error ) {
   function getFirstAssoc( xprPart, path ) {
     const { links, art } = getLinksAndArt({}, path);
     for (let i = 0; i < xprPart.ref.length - 1; i++) {
-      if (links[i].art && links[i].art.target) {
+      if (links[i].art?.target) {
         return {
-          head: (i === 0 ? [] : xprPart.ref.slice(0, i)), root: links[i].art, ref: xprPart.ref[i], tail: xprPart.ref.slice(i + 1),
+          head: (i === 0 ? [] : xprPart.ref.slice(0, i)),
+          root: links[i].art,
+          ref: xprPart.ref[i],
+          tail: xprPart.ref.slice(i + 1),
         };
       }
     }
+    const { ref } = xprPart;
     return {
-      head: (xprPart.ref.length === 1 ? [] : xprPart.ref.slice(0, xprPart.ref.length - 1)), root: art, ref: xprPart.ref[xprPart.ref.length - 1], tail: [],
+      head: (ref.length === 1 ? [] : ref.slice(0, ref.length - 1)),
+      root: art,
+      ref: ref.at(-1),
+      tail: [],
     };
   }
 

package/lib/transform/db/expansion.js

@@ -652,8 +652,10 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
       if (typeof root.$env === 'string' && (isComplexOrNestedQuery || options.transformation !== 'odata' || root.$env === pathId(obj.ref[0])))
         obj.ref = [ root.$env, ...obj.ref ];
 
-      if (iterateOptions.keepKeysOrigin)
+      if (iterateOptions.keepKeysOrigin) {
         setProp(obj, '$originalKeyRef', { ref: root.ref, as: root.as });
+        setProp(obj, '$path', root.$path);
+      }
 
       return obj;
     });

package/lib/transform/db/flattening.js

@@ -15,7 +15,7 @@ const { forEach } = require('../../utils/objectUtils');
 const { transformExpression } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
-const adaptAnnotationsRefs = require('../odata/adaptAnnotationRefs');
+const { adaptAnnotationsRefs } = require('../odata/adaptAnnotationRefs');
 
 /**
  * Strip off leading $self from refs where applicable.
@@ -220,7 +220,8 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
           //       full path into target, uncomment this line and
           //       comment/remove setProp in expansion.js
           // setProp(parent, '$structRef', parent.ref);
-          [ parent.ref, refChanged ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, suspend, suspendPos, parent.$bparam);
+          const flattenParameters = false; // structured parameters remain structured
+          [ parent.ref, refChanged ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, suspend, suspendPos, parent.$bparam, flattenParameters);
           resolved.set(parent, { links, art, scope });
           // Explicitly set implicit alias for things that are now flattened - but only in columns
           // TODO: Can this be done elegantly during expand phase already?
@@ -649,8 +650,11 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
             delete element.default;
         }
 
-        if (options.transformation === 'effective')
+        if (options.transformation === 'effective') {
           adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath);
+          const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && findAnnotationExpression(element, pn));
+          fks.forEach(fk => copyAnnotations(element, fk[1], false, {}, validAnnoNames));
+        }
         orderedElements.push(...fks);
       });
 

package/lib/transform/db/killAnnotations.js

@@ -25,6 +25,7 @@ const requiredAnnos = {
   '@cds.redirection.target': true,
   '@Core.Computed': true,
   [sqlServiceAnnotation]: true,
+  '@cds.external': true, // for external ABAP SQL services and data products for now
 };
 
 /**

package/lib/transform/db/processSqlServices.js

@@ -1,23 +1,26 @@
 'use strict';
 
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 
 const sqlServiceAnnotation = '@protocol';
-// Problem: How can we clone a Symbol when sorting?
-// const sqlServiceEntities = Symbol.for('SQL Service enabled entities');
+
 /**
  * Find all entities in SQL services and mark them with an annotation and
  * remember them in a symbol property for easier processing in toSql-rendering.
  *
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @returns {Function}
  */
-function processSqlServices(csn) {
+function processSqlServices(csn, options) {
   setProp(csn, '$sqlServiceEntities', Object.create(null));
+  setProp(csn, '$dummyServiceEntities', Object.create(null));
   return function findAndMarkSqlServiceArtifacts(artifact, artifactName) {
-    const sqlServiceName = isEntityInSqlService(artifact, artifactName, csn);
+    const { sqlServiceName, dummyServiceName } = isEntityInSqlService(artifact, artifactName, csn, options);
     if (sqlServiceName?.length > 0)
       setProp(artifact, '$sqlService', sqlServiceName);
+    if (dummyServiceName?.length > 0)
+      setProp(artifact, '$dummyService', dummyServiceName);
   };
 }
 
@@ -29,35 +32,85 @@ function processSqlServices(csn) {
 function isSqlService(artifact) {
   return artifact.kind === 'service' && artifact[sqlServiceAnnotation] === 'sql';
 }
+
 /**
+ * Checks if the given artifact is an external ABAP SQL service.
  *
- * @param {CSN.Artifact} artifact
- * @param {string} artifactName
- * @param {CSN.Model} csn
- * @returns {string|null}
+ * @param {object} artifact - The artifact to check.
+ * @param {CSN.Options} options
+ * @returns {boolean} - Returns true if the artifact is an external ABAP SQL service, otherwise false.
+ */
+function isDummyService(artifact, options) {
+  return isBetaEnabled(options, 'sqlServiceDummies') && artifact.kind === 'service' && artifact['@cds.external'] && artifact[sqlServiceAnnotation] === 'dummy';
+}
+
+/**
+ * Determines if an artifact is part of a SQL service or an external ABAP SQL service.
+ *
+ * @param {object} artifact - The artifact to check.
+ * @param {string} artifactName - The name of the artifact.
+ * @param {object} csn - The CSN (Core Schema Notation) object containing definitions.
+ * @param {CSN.Options} options
+ * @returns {object} An object containing the names of the SQL service and external ABAP SQL service, if found.
  */
-function isEntityInSqlService(artifact, artifactName, csn) {
-  if (artifact.kind !== 'entity' || !artifactName.includes('.'))
-    return null;
+function isEntityInSqlService(artifact, artifactName, csn, options) {
+  const result = { sqlServiceName: undefined, dummyServiceName: undefined };
+  if (artifact.kind !== 'entity' || !artifactName.includes('.') || artifact['@cds.persistence.skip'] === true)
+    return result;
 
   const nameParts = artifactName.split('.');
-  for (let i = nameParts.length; i >= 0; i--) {
+  for (let i = nameParts.length - 1; i >= 0; i--) {
     const possibleServiceName = nameParts.slice(0, i).join('.');
     if (!csn.definitions[possibleServiceName])
       continue;
 
     const definition = csn.definitions[possibleServiceName];
     if (isSqlService(definition))
-      return possibleServiceName;
+      result.sqlServiceName = possibleServiceName;
+
+    if (isDummyService(definition, options))
+      result.dummyServiceName = possibleServiceName;
 
     // We don't allow nested services/contexts - if we find one, we don't need to keep searching
     if (definition.kind === 'service' || definition.kind === 'context')
-      return null;
+      return result;
   }
 
-  return null;
+  return result;
+}
+
+/**
+ * Creates a dummy ABAP SQL service for the given artifact if it is marked as an external ABAP SQL service.
+ * The dummy service is a copy of the original artifact with certain properties removed.
+ * The dummy service is then added to the CSN (Core Schema Notation) definitions.
+ *
+ * @param {object} artifact - The artifact to create a dummy service for.
+ * @param {string} artifactName - The name of the artifact.
+ * @param {object} csn - The Core Schema Notation (CSN) object where the dummy service will be added.
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ */
+function createServiceDummy(artifact, artifactName, csn, { error }) {
+  if (!artifact.$dummyService)
+    return;
+
+  artifact['@cds.persistence.exists'] = true;
+  artifact.$ignore = true;
+
+  const dummy = { ...artifact };
+  delete dummy['@cds.persistence.exists'];
+  delete dummy.$ignore;
+
+  if (csn.definitions[`dummy.${artifactName}`])
+    error(null, [ 'definitions', artifactName ], { name: `dummy.${artifactName}` }, 'Generated artifact name $(NAME) conflicts with existing entity');
+  else
+    csn.definitions[`dummy.${artifactName}`] = dummy;
 }
 
 module.exports = {
-  processSqlServices, isSqlService, sqlServiceAnnotation,
+  processSqlServices,
+  isSqlService,
+  isDummyService,
+  sqlServiceAnnotation,
+  createServiceDummy,
 };

package/lib/transform/draft/db.js

@@ -4,7 +4,7 @@ const {
   hasAnnotationValue, getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
-const { setProp, isDeprecatedEnabled } = require('../../base/model');
+const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
@@ -25,8 +25,8 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   const allServices = getServiceNames(csn);
   const draftRoots = new WeakMap();
   const {
-    createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
-    addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
+    createAndAddDraftAdminDataProjection, createScalarElement,
+    createAssociationElement, addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
   } = getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
@@ -231,6 +231,11 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     };
     draftAdministrativeData.DraftAdministrativeData.notNull = true;
     addElement(draftAdministrativeData, draftsArtifact, artifactName);
+
+    if (isBetaEnabled(options, 'draftMessages')) {
+      const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
+      addElement(draftMessages, draftsArtifact, artifactName);
+    }
     // Note that we may need to do the HANA transformation steps for managed associations
     // (foreign key field generation, generatedFieldName, creating ON-condition) by hand,
     // because the corresponding transformation steps have already been done on all artifacts