@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/render/toSql.js

@@ -189,9 +189,11 @@ function toSqlDdl( csn, options, messageFunctions ) {
     constraintDeletions: [],
     migrations: Object.create(null),
     hdbrole: Object.create(null),
+    hdbsynonym: Object.create(null),
   };
 
   const sqlServiceEntities = Object.create(null);
+  const dummySqlServiceEntities = Object.create(null);
 
   // Registries for artifact and element names per CSN section
   const definitionsDuplicateChecker = new DuplicateChecker(options.sqlMapping);
@@ -209,8 +211,9 @@ function toSqlDdl( csn, options, messageFunctions ) {
   for (const artifactName in csn.deletions)
     renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], mainResultObj);
 
+  const supportsSqlExtensions = (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'));
 
-  if (csn.changedPrimaryKeys && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
+  if (csn.changedPrimaryKeys && supportsSqlExtensions) {
     csn.changedPrimaryKeys = options.testMode ? sortCsn(csn.changedPrimaryKeys) : csn.changedPrimaryKeys;
     csn.changedPrimaryKeys.forEach((artifactName) => {
       const drop = render.dropKey(artifactName);
@@ -221,7 +224,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   // Render each artifact extension
   // Only SAP HANA SQL is currently supported.
   // Note that extensions may contain new elements referenced in migrations, thus should be compiled first.
-  if (csn.extensions && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
+  if (csn.extensions && supportsSqlExtensions) {
     csn.extensions = options.testMode ? sortCsn(csn.extensions) : csn.extensions;
     for (let i = 0; i < csn.extensions.length; ++i) {
       const extension = csn.extensions[i];
@@ -236,7 +239,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
   // Render each artifact change
   // Only SAP HANA SQL is currently supported.
-  if (csn.migrations && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
+  if (csn.migrations && supportsSqlExtensions) {
     csn.migrations = options.testMode ? sortCsn(csn.migrations) : csn.migrations;
     for (const migration of csn.migrations) {
       if (migration.migrate) {
@@ -249,7 +252,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
   }
 
-  if (csn.changedPrimaryKeys && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
+  if (csn.changedPrimaryKeys && supportsSqlExtensions) {
     csn.changedPrimaryKeys = options.testMode ? sortCsn(csn.changedPrimaryKeys) : csn.changedPrimaryKeys;
     csn.changedPrimaryKeys.forEach((artifactName) => {
       const add = render.addKey(artifactName, csn.definitions[artifactName].elements);
@@ -276,6 +279,22 @@ function toSqlDdl( csn, options, messageFunctions ) {
       mainResultObj.hdbrole[`${sqlServiceName }_access`] = JSON.stringify(accessRole, null, 2);
   });
 
+  // Can only happen for HDI based deployment
+  Object.keys(dummySqlServiceEntities).forEach((sqlServiceName) => {
+    const synonym = Object.create(null);
+    Object.entries(dummySqlServiceEntities[sqlServiceName]).forEach(([ name ]) => {
+      const artName = renderArtifactNameWithoutQuotes(name);
+      const dummyArtName = renderArtifactNameWithoutQuotes(`dummy.${ name}`);
+      synonym[artName] = {
+        target: {
+          object: dummyArtName,
+        },
+      };
+    });
+
+    mainResultObj.hdbsynonym[`${sqlServiceName}`] = JSON.stringify(synonym, null, 2);
+  });
+
   // trigger artifact and element name checks
   definitionsDuplicateChecker.check(error, options);
   extensionsDuplicateChecker.check(error);
@@ -340,8 +359,14 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderDefinitionInto( artifactName, art, resultObj, env ) {
     env.path = [ 'definitions', artifactName ];
     // Ignore whole artifacts if forRelationalDB says so
-    if (art.abstract || hasValidSkipOrExists(art))
+    if (art.abstract || hasValidSkipOrExists(art)) {
+      if (art.$dummyService) { // collect entities that are in an external ABAP sql service so we can render the .hdbsynonym later
+        dummySqlServiceEntities[art.$dummyService] ??= Object.create(null);
+        dummySqlServiceEntities[art.$dummyService][artifactName] = art;
+      }
+
       return;
+    }
 
     switch (art.kind) {
       case 'entity':
@@ -349,6 +374,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
           sqlServiceEntities[art.$sqlService] ??= Object.create(null);
           sqlServiceEntities[art.$sqlService][artifactName] = art;
         }
+
         if (art.query || art.projection) {
           const result = renderView(artifactName, art, env);
           if (result)
@@ -587,13 +613,12 @@ function toSqlDdl( csn, options, messageFunctions ) {
    */
   function renderEntityInto( artifactName, art, resultObj, env ) {
     const childEnv = env.withIncreasedIndent();
-    const hanaTc = art.technicalConfig && art.technicalConfig.hana;
     // tables can have @sql.prepend and @sql.append
     const { front, back } = getSqlSnippets(options, art);
     let result = front;
     // Only SAP HANA has row/column tables
     if (options.sqlDialect === 'hana') {
-      if (hanaTc && hanaTc.storeType) {
+      if (art.technicalConfig?.hana?.storeType) {
         // Explicitly specified
         result += `${art.technicalConfig.hana.storeType.toUpperCase()} `;
       }
@@ -607,7 +632,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     result += `TABLE ${tableName}`;
     result += ' (\n';
     result += Object.keys(art.elements)
-      .map(eltName => renderElement(eltName, art.elements[eltName], definitionsDuplicateChecker, getFzIndex(eltName, hanaTc), childEnv))
+      .map(eltName => renderElement(eltName, art.elements[eltName], definitionsDuplicateChecker, getFzIndex(eltName, art.technicalConfig?.hana), childEnv))
       .filter(s => s !== '')
       .join(',\n');
 
@@ -643,7 +668,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     // Append table constraints if any
     // 'CONSTRAINT <name> UNIQUE (<column_list>)
     // OR create a unique index for HDI
-    const uniqueConstraints = art.$tableConstraints && art.$tableConstraints.unique;
+    const uniqueConstraints = art.$tableConstraints?.unique;
     for (const cn in uniqueConstraints) {
       const constraint = renderUniqueConstraintString(uniqueConstraints[cn], renderArtifactName(`${artifactName}_${cn}`), tableName, quoteSqlId, options);
       if (options.src === 'hdi')
@@ -670,7 +695,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     // Only HANA has indices
     // FIXME: Really? We should provide a DB-agnostic way to specify that
     if (options.sqlDialect === 'hana')
-      renderIndexesInto(art.technicalConfig && art.technicalConfig.hana.indexes, artifactName, resultObj, env);
+      renderIndexesInto(art.technicalConfig?.hana?.indexes, artifactName, resultObj, env);
 
     if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT ${renderStringForSql(getHanaComment(art), options.sqlDialect)}`;
@@ -746,7 +771,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
    * @returns {object} fzindex for the element
    */
   function getFzIndex( elemName, hanaTc ) {
-    if (!hanaTc || !hanaTc.fzindexes || !hanaTc.fzindexes[elemName])
+    if (!hanaTc?.fzindexes?.[elemName])
       return undefined;
 
     if (Array.isArray(hanaTc.fzindexes[elemName][0])) {
@@ -823,12 +848,12 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (elm.target) {
       result += env.indent;
       if (elm.cardinality) {
-        if (isBetaEnabled(options, 'hanaAssocRealCardinality') && elm.cardinality.src && elm.cardinality.src === 1)
+        if (isBetaEnabled(options, 'hanaAssocRealCardinality') && elm.cardinality.src === 1)
           result += 'ONE TO ';
         else
           result += 'MANY TO ';
 
-        if (elm.cardinality.max && (elm.cardinality.max === '*' || Number(elm.cardinality.max) > 1))
+        if (elm.cardinality.max === '*' || Number(elm.cardinality.max) > 1)
           result += 'MANY';
         else
           result += 'ONE';
@@ -1002,11 +1027,11 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderJoinCardinality( card ) {
     let result = '';
     if (card) {
-      if (card.srcmin && card.srcmin === 1)
+      if (card.srcmin === 1)
         result += 'EXACT ';
-      result += card.src && card.src === 1 ? 'ONE ' : 'MANY ';
+      result += card.src === 1 ? 'ONE ' : 'MANY ';
       result += 'TO ';
-      if (card.min && card.min === 1)
+      if (card.min === 1)
         result += 'EXACT ';
       if (card.max)
         result += (card.max === 1) ? 'ONE ' : 'MANY ';
@@ -1080,7 +1105,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     // the ref is not rendered as { id: ...; args: } but as short form of ref[0] ;)
     // An empty actual parameter list is rendered as `()`.
     const ref = csn.definitions[path.ref[0].id] || csn.definitions[path.ref[0]];
-    if (ref && ref.params) {
+    if (ref?.params) {
       result += path.ref[0]?.args
         ? `(${renderArgs(path.ref[0], '=>', env.withSubPath([ 'ref', 0 ]), syntax)})`
         : '()';
@@ -1156,8 +1181,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
    */
   function renderViewColumn( col, elements, env ) {
     let result = '';
-    const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
-    if (leaf && elements[leaf] && elements[leaf].virtual) {
+    const leaf = col.as || col.ref?.[col.ref.length - 1] || col.func;
+    if (leaf && elements[leaf]?.virtual) {
       if (isDeprecatedEnabled(options, '_renderVirtualElements'))
         // render a virtual column 'null as <alias>'
         result += `${env.indent}NULL AS ${quoteSqlId(col.as || leaf)}`;
@@ -1182,7 +1207,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
    */
   function renderView( artifactName, art, env ) {
     const viewName = renderArtifactName(artifactName);
-    definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
+    definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art?.$location, artifactName);
     let result = `VIEW ${viewName}`;
 
     if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
@@ -1268,9 +1293,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
           // - has an ORDER BY/LIMIT (because UNION etc. can't stand directly behind an ORDER BY)
           const argEnv = env.withSubPath([ 'args', index ]);
           const queryString = renderQuery( arg, argEnv, elements || query.SET.elements, false);
-          return (arg.SET || arg.SELECT && (arg.SELECT.orderBy || arg.SELECT.limit)) ? `(${queryString})` : queryString;
+          return (arg.SET || arg.SELECT?.orderBy || arg.SELECT?.limit) ? `(${queryString})` : queryString;
         })
-        .join(`\n${env.indent}${query.SET.op && query.SET.op.toUpperCase()}${query.SET.all ? ' ALL ' : ' '}`);
+        .join(`\n${env.indent}${query.SET.op?.toUpperCase()}${query.SET.all ? ' ALL ' : ' '}`);
+
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
       // If the whole SET has an ORDER BY/LIMIT, wrap the part before that in parentheses
@@ -1278,12 +1304,16 @@ function toSqlDdl( csn, options, messageFunctions ) {
       // to the last SET argument, not to the whole SET)
       if (query.SET.orderBy || query.SET.limit) {
         result = `(${result})`;
-        if (query.SET.orderBy)
-          result += `\n${env.indent}ORDER BY ${query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ')}`;
-
-        if (query.SET.limit)
-          result += `\n${env.indent}${renderLimit(query.SET.limit, env.withSubPath([ 'limit' ]))}`;
+        if (query.SET.orderBy) {
+          const orderBy = query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ');
+          result += `\n${env.indent}ORDER BY ${orderBy}`;
+        }
+        if (query.SET.limit) {
+          const limit = renderLimit(query.SET.limit, env.withSubPath([ 'limit' ]));
+          result += `\n${env.indent}${limit}`;
+        }
       }
+
       return result;
     }
     // Otherwise must have a SELECT
@@ -1332,7 +1362,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
    * @returns {string|undefined} Id of first path step
    */
   function firstPathStepId( ref ) {
-    return ref && ref[0] && (ref[0].id || ref[0]);
+    return (ref?.[0]?.id || ref?.[0]);
   }
 
   /**
@@ -1431,7 +1461,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
    */
   function renderBuiltinType( typeName ) {
     const types = cdsToSqlTypes[options.sqlDialect];
-    const result = types && types[typeName] || cdsToSqlTypes.standard[typeName];
+    const result = types?.[typeName] || cdsToSqlTypes.standard[typeName];
     if (!result && options.testMode)
       throw new CompilerAssertion(`Expected to find a type mapping for ${typeName}`);
     return result || 'CHAR';

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;
     });