@sap/cds-dk 10.1.2 → 10.2.0

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

@@ -19,7 +19,7 @@ const lazyload = require('./utils/lazyload')( module );
 const trace = require('./base/trace');
 
 const snapi = lazyload('./api/main');
-const csnUtils = lazyload('./model/csnUtils');
+const csnUtils = lazyload('./base/csnUtils');
 const modelApi = lazyload('./base/model-api');
 const messages = lazyload('./base/messages');
 const sqlIdentifier = lazyload('./sql-identifier');
@@ -49,6 +49,7 @@ function parseCdl( cdlSource, filename, options = {} ) {
   };
   const messageFunctions = messages.createMessageFunctions( options, 'parse', model );
   model.$messageFunctions = messageFunctions;
+  cdlSource = cdlSource.toString();
 
   const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
                                 messageFunctions );
@@ -62,6 +63,7 @@ function parseCdl( cdlSource, filename, options = {} ) {
 
 function parseCql( cdlSource, filename = '<query>.cds', options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse' );
+  cdlSource = cdlSource.toString();
   const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
                                 messageFunctions, 'query' );
   messageFunctions.throwWithError();
@@ -70,6 +72,7 @@ function parseCql( cdlSource, filename = '<query>.cds', options = {} ) {
 
 function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse' );
+  cdlSource = cdlSource.toString();
   const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
                                 messageFunctions, 'expr' );
   messageFunctions.throwWithError();

package/node_modules/@sap/cds-compiler/lib/parsers/AstBuildingParser.js

@@ -13,6 +13,7 @@ const { primaryExprProperties } = require('../base/builtins');
 const { parseMultiLineStringLiteral } = require('../language/multiLineStringParser');
 const { normalizeNumberString } = require('../language/textUtils');
 const { parseDocComment } = require('../language/docCommentParser');
+const { XsnArtifact, XsnName } = require('../compiler/xsn-model');
 
 const $location = Symbol.for('cds.$location');
 
@@ -746,6 +747,9 @@ class AstBuildingParser extends BaseParser {
     return art;
   }
 
+  locationCopy( loc ) {
+    return { __proto__: Location.prototype, ...loc };
+  }
   // AST building ---------------------------------------------------------------
 
   assignAnnotation( art, val, name, prefix = '' ) {
@@ -753,7 +757,7 @@ class AstBuildingParser extends BaseParser {
     const pathname = pathName( path );
     if (!pathname)
       return;
-    let absolute = '';
+    let absolute;
     if (name.variant) {
       const variant = pathName( name.variant.path );
       absolute = `${ prefix }${ pathname }#${ variant }`;
@@ -825,8 +829,12 @@ class AstBuildingParser extends BaseParser {
     return { id, location, $delimited: true };
   }
 
+  identNameAst( token = this.lb() ) {
+    return { __proto__: XsnName.prototype, ...this.identAst( token ) };
+  }
+
   fragileAlias( safe = false ) {
-    const ast = this.identAst();
+    const ast = { __proto__: XsnName.prototype, ...this.identAst() };
     if (safe || ast.$delimited || !/^[a-zA-Z][a-zA-Z_]+$/.test( ast.id )) {
       this.warning( 'syntax-deprecated-auto-as', ast.location, { keyword: 'as' },
                     'Add keyword $(KEYWORD) in front of the alias name' );
@@ -862,7 +870,7 @@ class AstBuildingParser extends BaseParser {
     }
     else {
       token.parsedAs = 'ItemAlias';
-      art.name = ref.path[0];
+      art.name = { __proto__: XsnName.prototype, ...ref.path[0] };
       art.value = undefined;
     }
   }
@@ -1230,6 +1238,7 @@ class AstBuildingParser extends BaseParser {
     const { file, line, col } = this.lb( offset ).location;
     const { endLine, endCol } = this.lb().location;
     return {
+      __proto__: Location.prototype,
       file,
       line,
       col,
@@ -1243,7 +1252,12 @@ class AstBuildingParser extends BaseParser {
     const { file, line, col } = start;
 
     return {
-      file, line, col, endLine: end.endLine, endCol: end.endCol,
+      __proto__: Location.prototype,
+      file,
+      line,
+      col,
+      endLine: end.endLine,
+      endCol: end.endCol,
     };
   }
 
@@ -1261,6 +1275,10 @@ class AstBuildingParser extends BaseParser {
     return null;
   }
 
+  wildcardColumn( token = this.lb() ) {
+    return { __proto__: XsnArtifact.prototype, val: '*', location: token.location };
+  }
+
   // TODO: rename to `valAst`
   valueWithLocation( val = undefined, token = this.lb() ) {
     if (val === undefined)
@@ -1431,7 +1449,8 @@ class AstBuildingParser extends BaseParser {
     this.classifyImplicitName( 'ItemAssoc', art.value );
     const path = art.value?.path;
     if (path?.length) {
-      art.name = path.at( -1 ); // usually length 1, but make it also work during error recovery
+      // usually length 1, but make it also work during error recovery:
+      art.name = { __proto__: XsnName.prototype, ...path.at( -1 ) };
       delete art.value;
     }
   }
@@ -1524,8 +1543,10 @@ class AstBuildingParser extends BaseParser {
                   { name, '#': (numDefines ? 'define' : 'extend') } );
     }
     else if (numDefines === 1) {
+      // extend E with { elem …; extend elem …; extend elem … }
+      // → no duplicate error for single definition
       ext.$errorReported = 'syntax-duplicate-extend';
-    } // a definition, but not duplicate
+    }
   }
 
   // Add new definition `art` to dictionary property `env` of node `parent`.
@@ -1544,19 +1565,22 @@ class AstBuildingParser extends BaseParser {
     if (Array.isArray(name)) {
       const last = name.length && name[name.length - 1];
       art.name = { // A.B.C -> 'C'
-        id: last?.id || '', location: last.location, $inferred: 'as',
+        __proto__: XsnName.prototype, id: last?.id || '', location: last.location, $inferred: 'as',
       };
     }
     else if (name) {
-      art.name = name;
+      if (Object.getPrototypeOf(name) === Object.prototype)
+        art.name = { __proto__: XsnName.prototype, ...name };
+      else
+        art.name = name;
       if (!name.id && kind === null) {
-        name.id = name.variant
-          ? `${ pathName( name.path ) }#${ pathName( name.variant.path ) }`
-          : pathName( name.path );
+        art.name.id = art.name.variant
+          ? `${ pathName( art.name.path ) }#${ pathName( art.name.variant.path ) }`
+          : pathName( art.name.path );
       }
     }
     else {
-      art.name = { id: '' };
+      art.name = { __proto__: XsnName.prototype, id: '' };
     }
     if (kind)
       art.kind = kind;
@@ -1567,7 +1591,7 @@ class AstBuildingParser extends BaseParser {
     if (env === 'artifacts' || env === 'vocabularies') {
       dictAddArray( parent[env], id, art );
     }
-    else if (kind || this.options.parseOnly) { // TODO: do not check parseOnly
+    else if (kind || this.options.parseOnly) { // TODO v8: do not check parseOnly
       dictAdd( parent[env], id, art );
     }
     else {
@@ -1613,14 +1637,17 @@ class AstBuildingParser extends BaseParser {
     }
     // Note: the element extensions share a common `location`, also with the
     // extension of the main artifact; its end location will usually set later
-    const main = { kind, name: artName, location };
+    const main = {
+      __proto__: XsnArtifact.prototype, kind, name: artName, location,
+    };
     parent.extensions.push( main );
     parent = main;
 
     const last = elemPath[elemPath.length - 1];
     for (const seg of elemPath) {
       parent.elements = Object.create(null); // no dict location → no createDict()
-      parent = this.addDef( (seg === last ? ext : { location }),
+      // TODO: try to find a good dict location
+      parent = this.addDef( (seg === last ? ext : { __proto__: XsnArtifact.prototype, location }),
                             parent, 'elements', kind, seg );
     }
   }

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

@@ -23,6 +23,14 @@ function asDBName( name ) {
     : name.toUpperCase();
 }
 
+/**
+ * @param {string} name Artifact name
+ * @returns {number} Number of dots in the artifact name
+ */
+function dotCount( name ) {
+  return name.split('.').length - 1;
+}
+
 /**
  * Check for duplicate artifacts or elements
  *
@@ -48,11 +56,12 @@ class DuplicateChecker {
    * @param {string} name Persistence name of the artifact
    * @param {CSN.Location|CSN.Path} location CSN location of the artifact
    * @param {string} modelName CSN artifact name
+   * @param {boolean} persistenceExists Whether the artifact has @cds.persistence.exists
    */
-  addArtifact( name, location, modelName ) {
+  addArtifact( name, location, modelName, persistenceExists = false ) {
     const dbName = this.names === 'plain' ? asDBName(name) : name; // uppercase for plain names
     this.currentArtifact = {
-      name, location, elements: {}, modelName,
+      name, location, elements: {}, modelName, persistenceExists,
     };
     if (!this.seenArtifacts[dbName])
       this.seenArtifacts[dbName] = [ this.currentArtifact ];
@@ -85,24 +94,41 @@ class DuplicateChecker {
    *
    * @param {Function} error Function of makeMessageFunction()
    * @param {CSN.Options} options Options used for the compilation
+   * @param {Function} message Function of makeMessageFunction()
    */
-  check(error, options = null) {
+  check(error, options = null, message = error) {
     forEach(this.seenArtifacts, (artifactName, artifacts) => {
       if (artifacts.length > 1) {
-        artifacts.slice(1).forEach((artifact) => { // report all colliding artifacts, except the first one
-          const collidesWith = this.seenArtifacts[artifactName].find( art => art !== artifact );
+        const sortedArtifacts = artifacts.slice().sort((a, b) => {
+          const dotCountDifference = dotCount(a.modelName) - dotCount(b.modelName);
+          if (dotCountDifference)
+            return dotCountDifference;
+          return a.modelName < b.modelName ? -1 : Number(a.modelName > b.modelName);
+        });
+        const collidesWith = sortedArtifacts.find(a => !a.persistenceExists) || sortedArtifacts[0];
+        sortedArtifacts.forEach((artifact) => { // report all colliding artifacts, except the first one
+          if (artifact === collidesWith)
+            return;
+
           let namingMode;
           if (options)
             namingMode = options.sqlMapping;
           else
             namingMode = 'plain';
 
-          error(null, [ 'definitions', artifact.modelName ], {
-            name: collidesWith.modelName, prop: namingMode, '#': artifact.modelName.includes('.') ? 'dots' : 'std',
-          }, {
-            std: 'Artifact name can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
-            dots: 'Artifact name containing dots can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
-          });
+          const hasExists = artifact.persistenceExists || collidesWith.persistenceExists;
+          if (hasExists) {
+            message('name-duplicate-artifact-exists', [ 'definitions', artifact.modelName ], {
+              name: collidesWith.modelName, prop: namingMode,
+            });
+          }
+          else {
+            error(null, [ 'definitions', artifact.modelName ], {
+              name: collidesWith.modelName, prop: namingMode,
+            }, {
+              std: 'Artifact name can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
+            });
+          }
         });
       }
       artifacts.forEach((artifact) => {

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

@@ -4,7 +4,7 @@
 const {
   forEachDefinition,
   getResultingName,
-} = require('../model/csnUtils');
+} = require('../base/csnUtils');
 const { forEach } = require('../utils/objectUtils');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 

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

@@ -18,7 +18,7 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { normalizeTypeRef, forEachDefinition } = require('../model/csnUtils');
+const { normalizeTypeRef, forEachDefinition } = require('../base/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/specialOptions');
 const { ModelError, CompilerAssertion } = require('../base/error');
@@ -30,7 +30,7 @@ const { isBuiltinType } = require('../base/builtins');
 const { cloneFullCsn } = require('../base/cloneCsn');
 const { getKeysDict, implicitAs } = require('../base/csnRefs');
 const { undelimitedIdentifierRegex } = require('../parsers/identifiers');
-const { getNormalizedQuery } = require('../model/csnUtils');
+const { getNormalizedQuery } = require('../base/csnUtils');
 const {
   line,
   pretty,
@@ -660,12 +660,15 @@ class CsnToCdl {
     let result = this.renderAnnotationAssignmentsAndDocComment(ext, env);
     extName = this.renderArtifactName(extName, env);
 
+    let extendWithIncludes;
     if (ext.includes && ext.includes.length > 0) {
-      // Includes can't be combined with anything in braces {}.
       const affix = isElementExtend ? 'element ' : '';
       const includes = ext.includes.map((inc, i) => this.renderDefinitionReference(inc, env.withSubPath([ 'includes', i ]))).join(', ');
-      result += `${ env.indent }extend ${ affix }${ extName } with ${ includes };\n`;
-      return result;
+      extendWithIncludes = `${ env.indent }extend ${ affix }${ extName } with ${ includes }`;
+      if (!ext.elements && !ext.actions) {
+        result += `${ extendWithIncludes };\n`;
+        return result;
+      }
     }
 
     const typeParams = this.renderTypeParameters(ext, true);
@@ -688,7 +691,9 @@ class CsnToCdl {
       // the latter cannot.
       // If there are actions, check if there are also elements/columns, and if so, use the prefix notation.
       const usePrefixNotation = ext.actions && (ext.columns || ext.elements);
-      if (usePrefixNotation)
+      if (extendWithIncludes)
+        result += `${ extendWithIncludes }${ ext.elements ? ' {\n' : ' actions {\n' }`;
+      else if (usePrefixNotation)
         result += `${ env.indent }extend ${ this.getExtendPrefixVariant(ext) } ${ extName } with {\n`;
       else
         result += `${ env.indent }extend ${ extName } with ${ this.getExtendPostfixVariant(ext) }{\n`;

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

@@ -2,7 +2,7 @@
 'use strict';
 
 const { checkCSNVersion } = require('../json/csnVersion');
-const { forEachDefinition } = require('../model/csnUtils');
+const { forEachDefinition } = require('../base/csnUtils');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 const { getIdentifierUtils } = require('./utils/sql');
 

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

@@ -4,10 +4,10 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, getNormalizedQuery,
-  forEachDefinition, getResultingName,
+  forEachDefinition, getArtifactDatabaseNameOf, getResultingName,
   getVariableReplacement, pathName,
-  implicitAs,
-} = require('../model/csnUtils');
+  implicitAs, hasPersistenceSkipAnnotation,
+} = require('../base/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
 const {
@@ -31,7 +31,7 @@ const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { pathId } = require('../base/csnRefs');
-const { transformExprOperators, isTopLevelPredicate } = require('./utils/operators');
+const { transformExprOperators, isTopLevelPredicate, addTrueComparisonToBooleanFunctions } = require('./utils/operators');
 const { exprAsTree, condAsTree } = require('../base/xprAsTree');
 
 class SqlRenderEnvironment {
@@ -112,7 +112,7 @@ class SqlRenderEnvironment {
 function toSqlDdl( csn, options, messageFunctions ) {
   timetrace.start('SQL rendering');
   const {
-    error, warning, info, throwWithAnyError,
+    error, warning, info, message, throwWithAnyError,
   } = messageFunctions;
   const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options, warning);
   const reportedMissingReplacements = Object.create(null);
@@ -155,12 +155,17 @@ function toSqlDdl( csn, options, messageFunctions ) {
     },
   });
 
-  function renderExpr( x, env ) {
+  function renderExpr( x, env, inCondition ) {
     // TODO:
     //   Can we to structurizing upfront?
     //   Neither condAsTree() nor exprAsTree() traverse `.args` / `.where`.
     //   This is fine, since renderExpr() calls itself for function arguments and filters.
     x = Array.isArray(x) ? condAsTree(x) : exprAsTree(x);
+    // In a condition (WHERE/HAVING/ON), boolean-valued OData functions (`contains` etc.)
+    // may sit in predicate position; on HANA their value form (`CASE … END`) is turned
+    // into a predicate by comparing it to `TRUE`.
+    if (inCondition && options.sqlDialect === 'hana' && Array.isArray(x))
+      x = addTrueComparisonToBooleanFunctions(x);
     x = transformExprOperators(x, options, messageFunctions, env);
     return exprRenderer.renderExpr(x, env);
   }
@@ -213,6 +218,13 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
   // Render each artifact on its own
   forEachDefinition(sortCsnIfTestMode(csn), (artifact, artifactName) => {
+    if (artifact.kind === 'entity' && !(artifact.abstract || hasPersistenceSkipAnnotation(artifact))) {
+      const persistenceName = artifact['@cds.persistence.name'] ||
+        getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect);
+      definitionsDuplicateChecker.addArtifact(
+        persistenceName, artifact?.$location, artifactName, artifact['@cds.persistence.exists']
+      );
+    }
     renderDefinitionInto(artifactName, artifact, mainResultObj, new SqlRenderEnvironment());
   });
 
@@ -303,7 +315,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   });
 
   // trigger artifact and element name checks
-  definitionsDuplicateChecker.check(error, options);
+  definitionsDuplicateChecker.check(error, options, message);
   extensionsDuplicateChecker.check(error);
   deletionsDuplicateChecker.check(error);
 
@@ -632,7 +644,6 @@ function toSqlDdl( csn, options, messageFunctions ) {
       }
     }
     const tableName = renderArtifactName(artifactName);
-    definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art.$location, artifactName);
     result += `TABLE ${ tableName }`;
     result += ' (\n';
     result += Object.keys(art.elements)
@@ -856,7 +867,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       }
       result += ' JOIN ';
       result += `${ renderArtifactName(elm.target) } AS ${ quoteSqlId(elementName) } ON (`;
-      result += `${ renderExpr(elm.on, env.withSubPath([ 'on' ])) })`;
+      result += `${ renderExpr(elm.on, env.withSubPath([ 'on' ]), true) })`;
     }
     return result;
   }
@@ -994,7 +1005,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
           result += renderJoinCardinality(source.cardinality);
         result += `JOIN ${ renderQuerySource(source.args[i], env.withSubPath([ 'args', i ])) }`;
         if (source.on)
-          result += ` ON ${ renderExpr(source.on, env.withSubPath([ 'on' ])) }`;
+          result += ` ON ${ renderExpr(source.on, env.withSubPath([ 'on' ]), true) }`;
 
         result += ')';
       }
@@ -1108,7 +1119,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
     if (path.ref[0].where) {
       const cardinality = path.ref[0].cardinality ? (`${ path.ref[0].cardinality.max }: `) : '';
-      result += `[${ cardinality }${ renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ])) }]`;
+      result += `[${ cardinality }${ renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ]), true) }]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
@@ -1206,7 +1217,6 @@ function toSqlDdl( csn, options, messageFunctions ) {
    */
   function renderViewInto( artifactName, art, resultObj, env ) {
     const viewName = renderArtifactName(artifactName);
-    definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art?.$location, artifactName);
     let result = `${ isProjectionView(csn, art, options) ? 'PROJECTION ' : '' }VIEW ${ viewName }`;
     result += renderComment(art);
     result += renderParameterDefinitions(art.params, env);
@@ -1286,12 +1296,23 @@ function toSqlDdl( csn, options, messageFunctions ) {
       env = env.withSubPath([ 'SET' ]);
       result += query.SET.args
         .map((arg, index) => {
-          // Wrap each query in the SET in parentheses that
-          // - is a SET itself (to preserve precedence between the different SET operations),
-          // - has an ORDER BY/LIMIT (because UNION etc. can't stand directly behind an ORDER BY)
           const argEnv = env.withSubPath([ 'args', index ]);
+          // SQLite rejects parentheses around operands and evaluates compound operators from left to right.
+          // Its leftmost nested set can stay inline; all other SQLite grouping needs a derived table.
+          if (options.sqlDialect === 'sqlite') {
+            const sqliteNeedsGrouping = (index > 0 && arg.SET) ||
+              arg.SET?.orderBy || arg.SET?.limit || arg.SELECT?.orderBy || arg.SELECT?.limit;
+            const queryEnv = sqliteNeedsGrouping ? argEnv.withIncreasedIndent() : argEnv;
+            const queryString = renderQuery( arg, queryEnv, elements || query.SET.elements, false);
+            if (sqliteNeedsGrouping)
+              return `SELECT *\n${ argEnv.indent }FROM (${ queryString })`;
+            return queryString;
+          }
+
+          // Nested sets and operands with their own ORDER BY or LIMIT need grouping.
+          const needsGrouping = arg.SET || arg.SELECT?.orderBy || arg.SELECT?.limit;
           const queryString = renderQuery( arg, argEnv, elements || query.SET.elements, false);
-          return (arg.SET || arg.SELECT?.orderBy || arg.SELECT?.limit) ? `(${ queryString })` : queryString;
+          return needsGrouping ? `(${ queryString })` : queryString;
         })
         .join(`\n${ env.indent }${ query.SET.op?.toUpperCase() }${ query.SET.all ? ' ALL ' : ' ' }`);
 
@@ -1332,13 +1353,21 @@ function toSqlDdl( csn, options, messageFunctions ) {
       .join(',\n') }\n`;
     result += `${ env.indent }FROM ${ renderQuerySource( select.from, env.withSubPath([ 'from' ])) }`;
     if (select.where)
-      result += `\n${ env.indent }WHERE ${ renderExpr(select.where, env.withSubPath([ 'where' ])) }`;
-
-    if (select.groupBy)
-      result += `\n${ env.indent }GROUP BY ${ select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ') }`;
+      result += `\n${ env.indent }WHERE ${ renderExpr(select.where, env.withSubPath([ 'where' ]), true) }`;
+
+    // HANA rejects a bare predicate as a grouping expression; it is a value position,
+    // so wrap a top-level predicate like a select-list column (see renderViewColumn).
+    if (select.groupBy) {
+      result += `\n${ env.indent }GROUP BY ${ select.groupBy.map((expr, i) => {
+        const e = env.withSubPath([ 'groupBy', i ]);
+        return (options.sqlDialect === 'hana' && isTopLevelPredicate(expr))
+          ? wrapPredicateInCase(renderExpr({ xpr: expr.xpr }, e))
+          : renderExpr(expr, e);
+      }).join(', ') }`;
+    }
 
     if (select.having)
-      result += `\n${ env.indent }HAVING ${ renderExpr(select.having, env.withSubPath([ 'having' ])) }`;
+      result += `\n${ env.indent }HAVING ${ renderExpr(select.having, env.withSubPath([ 'having' ]), true) }`;
 
     if (select.orderBy)
       result += `\n${ env.indent }ORDER BY ${ select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ') }`;
@@ -1388,7 +1417,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
    * @returns {string} Rendered ORDER BY entry
    */
   function renderOrderByEntry( entry, env ) {
-    let result = renderExpr(entry, env);
+    // ORDER BY is a value position too; wrap a bare predicate as in GROUP BY.
+    let result = (options.sqlDialect === 'hana' && isTopLevelPredicate(entry))
+      ? wrapPredicateInCase(renderExpr({ xpr: entry.xpr }, env))
+      : renderExpr(entry, env);
     if (entry.sort)
       result += ` ${ entry.sort.toUpperCase() }`;
 
@@ -1447,7 +1479,12 @@ function toSqlDdl( csn, options, messageFunctions ) {
       // 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> ')'
-      result += ` GENERATED ALWAYS AS (${ renderExpr(elm.value, env.withSubPath([ 'value' ])) })`;
+      const valueEnv = env.withSubPath([ 'value' ]);
+      // HANA rejects a bare predicate here; wrap it.
+      const rendered = (options.sqlDialect === 'hana' && isTopLevelPredicate(elm.value))
+        ? wrapStoredPredicateInCase(renderExpr({ xpr: elm.value.xpr }, valueEnv))
+        : renderExpr(elm.value, valueEnv);
+      result += ` GENERATED ALWAYS AS (${ rendered })`;
       // However, it appears many databases require a trailing "STORED".
       if (options.sqlDialect === 'sqlite' || options.sqlDialect === 'postgres')
         result += ' STORED';
@@ -1663,7 +1700,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
         // Filter, possibly with cardinality
         // FIXME: Does SQL understand filter cardinalities?
         const cardinality = s.cardinality ? (`${ s.cardinality.max }: `) : '';
-        result += `[${ cardinality }${ renderExpr(s.where, env.withSubPath([ 'where' ])) }]`;
+        result += `[${ cardinality }${ renderExpr(s.where, env.withSubPath([ 'where' ]), true) }]`;
       }
       return result;
     }
@@ -1743,6 +1780,19 @@ function wrapPredicateInCase( predicate ) {
   return `CASE WHEN (${ predicate }) THEN TRUE WHEN NOT (${ predicate }) THEN FALSE END`;
 }
 
+/**
+ * Wrap a rendered predicate for a stored (`GENERATED ALWAYS AS`) column on HANA.
+ * A generated column can't hold a nullable computed boolean (HANA rejects it with
+ * `to_boolean function is not supported`), so `ELSE FALSE` is used instead of the
+ * three-valued `WHEN NOT (p)`, collapsing a NULL predicate to FALSE.
+ *
+ * @param {string} predicate Rendered predicate SQL
+ * @return {string}
+ */
+function wrapStoredPredicateInCase( predicate ) {
+  return `CASE WHEN (${ predicate }) THEN TRUE ELSE FALSE END`;
+}
+
 /**
  * Render the given string for SQL databases.
  *

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

@@ -19,7 +19,7 @@ const functionsWithoutParams = {
 
 const {
   hasValidSkipOrExists, forEachDefinition, getNamespace, getUnderscoredName,
-} = require('../../model/csnUtils');
+} = require('../../base/csnUtils');
 
 const { implicitAs } = require('../../base/csnRefs');
 

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

@@ -181,7 +181,88 @@ function isPredicateTree( tree ) {
   return predicateOperators.has(op);
 }
 
+// HANA renders these as a value form (`CASE … END`); in predicate position they must be
+// compared to `TRUE` to become a predicate again (see `addTrueComparisonToBooleanFunctions`).
+// Names must match the mapped forms in `standardDatabaseFunctions` exactly (case-sensitive):
+// a differently-cased name (e.g. `CONTAINS`) opts out of the mapping and stays native.
+const predicateValueFunctions = new Set( [
+  'contains', 'startswith', 'endswith', 'matchespattern', 'matchesPattern',
+] );
+
+/**
+ * Rewrite boolean-valued OData function nodes in genuine predicate position within a
+ * condition (WHERE/HAVING/ON) to `<func> = TRUE`, so the HANA value form becomes a
+ * predicate. Affected are the condition itself and operands of `and`/`or`/`not` and
+ * `CASE WHEN`; not operands of a comparison (`contains(x, y) = false`), value operator,
+ * or function argument, where the value form must stay so the surrounding expression is
+ * valid. Mutates `tree` in place.
+ *
+ * @param {object[]} tree Structurized condition tree (see `csnAsTree()`)
+ */
+function addTrueComparisonToBooleanFunctions( tree ) {
+  return visit(tree, true);
+
+  // Returns the (possibly rewritten) node so callers can write it back into their slot.
+  function visit( node, inPredicate ) {
+    if (!node || typeof node !== 'object')
+      return node;
+
+    if (Array.isArray(node)) {
+      if (node.length === 1) { // single-element wrapper that csnAsTree() puts around the expression
+        node[0] = visit(node[0], inPredicate);
+      }
+      else if (node[0] === 'case') {
+        visitCase(node);
+      }
+      else if (typeof node[0] === 'string') { // prefix: `not`/`exists` keep a predicate
+        const keepsPredicate = node[0] === 'not' || node[0] === 'exists';
+        for (let i = 1; i < node.length; ++i)
+          node[i] = visit(node[i], inPredicate && keepsPredicate);
+      }
+      else { // binary `[ lhs, op, rhs ]`: only `and`/`or` operands stay predicates
+        const isLogical = node[1] === 'and' || node[1] === 'or';
+        node[0] = visit(node[0], inPredicate && isLogical);
+        node[2] = visit(node[2], inPredicate && isLogical);
+      }
+      return node;
+    }
+
+    if (node.func && predicateValueFunctions.has(node.func)) {
+      // 3-arg `contains` is native HANA CONTAINS (a predicate), not the value form.
+      const isValueForm = !(node.func === 'contains' && node.args?.length > 2);
+      if (inPredicate && isValueForm)
+        return [ node, '=', { val: true } ];
+    }
+    else if (node.xpr) {
+      if (node.xpr[0] === 'case')
+        visitCase(node.xpr);
+      else
+        node.xpr = visit(csnAsTree(node.xpr), inPredicate);
+    }
+    return node;
+  }
+
+  // In a searched CASE (`case when <cond> …`) the element after `when` is a condition; in a
+  // simple CASE (`case <op> when <val> …`) it is a value compared to the operand, so nothing
+  // is a predicate. A non-string node before the first `when` marks the simple form.
+  function visitCase( xpr ) {
+    const isSimple = xpr[1] != null && typeof xpr[1] === 'object';
+    for (let i = 0; i < xpr.length; ++i) {
+      const kw = typeof xpr[i] === 'string' && xpr[i].toLowerCase();
+      if (kw === 'when' || kw === 'then' || kw === 'else') {
+        if (xpr[i + 1] && typeof xpr[i + 1] === 'object')
+          xpr[i + 1] = visit(csnAsTree([ xpr[i + 1] ]), !isSimple && kw === 'when');
+        i += 1;
+      }
+      else if (i === 1 && isSimple) { // the simple-CASE operand is a value
+        xpr[i] = visit(csnAsTree([ xpr[i] ]), false);
+      }
+    }
+  }
+}
+
 module.exports = {
   transformExprOperators,
   isTopLevelPredicate,
+  addTrueComparisonToBooleanFunctions,
 };