@sap/cds-compiler 6.9.2 → 7.0.1

package/lib/parsers/AstBuildingParser.js

@@ -11,7 +11,7 @@ const { quotedLiteralPatterns, specialFunctions } = require('../compiler/builtin
 const { primaryExprProperties } = require('../base/builtins');
 
 const { parseMultiLineStringLiteral } = require('../language/multiLineStringParser');
-const { normalizeNewLine, normalizeNumberString } = require('../language/textUtils');
+const { normalizeNumberString } = require('../language/textUtils');
 const { parseDocComment } = require('../language/docCommentParser');
 
 const $location = Symbol.for('cds.$location');
@@ -537,30 +537,22 @@ class AstBuildingParser extends BaseParser {
    * `;` between statements is optional only after a `}` (ex braces of structure
    * values for annotations and foreign key specifications).
    *
-   * Unfortunate exception: always optional after `entity … as projection on`.
+   * Unfortunate exception: optional after `entity … as projection on` without sub
+   * queries in `where`, …
    *
-   * Beware: mentioned in leanConditions, i.e. executed in predictions!
+   * Used via:
+   *  - <prepare=afterBrace>: make guard succeed after closing `}` (not for anno values)
+   *  - <prepare=afterBrace, arg=sloppyOn>: switch on sloppy-`;` mode
+   *  - <guard=afterBrace>: succeeds if after previous `}` (with <prepare>)
+   *  - <guard=afterBrace, arg=orSloppy>: also succeeds (with warning) if sloppy
+   *
+   * Beware: mentioned in grammar option `hardGuards`, i.e. executed in predictions!
+   * (Needed for the rule exit prediction.)
    */
   afterBrace( arg, test ) {
     if (!test) {
-      if (arg === 'normal' && this.lb().type !== '}') {
-        const { type, keyword } = this.la();
-        if (type !== ';' && type !== '}' && type !== 'EOF' && keyword !== 'actions') {
-          const prev = this.lb().location;
-          const loc = new Location( prev.file, prev.endLine, prev.endCol );
-          this.warning( 'syntax-missing-proj-semicolon', loc,
-                        { expecting: [ "';'" ], offending: this.antlrName( this.la() ) },
-                        'Missing $(EXPECTING) before $(OFFENDING)');
-        }
-      }
-      // with arg 'init' (used in rule `start`/`artifactsBlock`), and arg 'sloppy'
-      // or 'normal' (used in rule `entityDef`), set marker in dynamic context:
-      if (!arg)
-        this.afterBrace$ = this.tokenIdx;
-      else if (arg === 'init')
-        this.dynamic_.sloppySemicolon$ = [ false ];
-      else if (arg === 'sloppy' || this.la().keyword === 'actions')
-        this.dynamic_.sloppySemicolon$[0] = (arg === 'sloppy');
+      // -42 is the magic number for sloppy semicolon handling
+      this.afterBrace$ = (arg ? -42 : this.tokenIdx);
       return null;
     }
     // TODO TOOL: the following test belongs to the BaseParser.js:
@@ -568,14 +560,21 @@ class AstBuildingParser extends BaseParser {
         this.conditionStackLength == null && // after error recover
         test !== 'M')
       return false;
-    const { sloppySemicolon$ } = this.dynamic_;
-    if (!sloppySemicolon$?.[0])
-      return this.afterBrace$ !== this.tokenIdx;
-    if (test === true && sloppySemicolon$) // TODO: single-let mode for running parser
-      sloppySemicolon$[0] = false;
-    return this.afterBrace$ !== this.tokenIdx && test === 'M';
-    // TODO: should we always fail for expected set (test === 'M'), at least if
-    // token is not on a new line?
+    if (this.afterBrace$ === this.tokenIdx)
+      return false;
+    if (!arg || this.afterBrace$ !== -42 || test === 'M')
+      return true;
+    if (test === true) {        // TODO: single-char mode for run
+      const { type, location } = this.lb();
+      if (type !== '}') {
+        const loc = new Location( location.file, location.endLine, location.endCol );
+        this.warning( 'syntax-missing-proj-semicolon', loc,
+                      { expecting: [ "';'" ], offending: this.antlrName( this.la() ) },
+                      'Missing $(EXPECTING) before $(OFFENDING)');
+      }
+      this.afterBrace$ = -1;    // switch off sloopy-`;`
+    }
+    return false;
   }
 
   /**
@@ -632,7 +631,11 @@ class AstBuildingParser extends BaseParser {
         this.conditionStackLength == null && // after error recover
         mode !== 'M')
       return false;
-    return true; //  mode !== 'Y';
+    // remark: collecting an `Id` as sync token does not help much yet, because
+    // using `Id` as sync token is restricted at the moment (too often sub-optimal).
+    // TODO (introduce base parser method): allow if followed by ':'/'='/';'/','/'}',
+    // or wait for future “try different recovery possibilities”.
+    return mode !== 'Y';
   }
 
   // Space handling etc, locations ----------------------------------------------
@@ -743,22 +746,6 @@ class AstBuildingParser extends BaseParser {
     return art;
   }
 
-  ruleTokensText() {
-    let tokenIdx = this.stack.at(-1).tokenIdx + 1;
-    const stop = this.tokenIdx;
-
-    let { text: result, location: prev } = this.tokens[tokenIdx];
-    while (++tokenIdx < stop) {
-      const { text, location } = this.tokens[tokenIdx];
-      if (location.line > prev.endLine ||
-          location.line === prev.endLine && location.col > prev.endCol)
-        result += ' ';
-      result += normalizeNewLine( text );
-      prev = location;
-    }
-    return result;
-  }
-
   // AST building ---------------------------------------------------------------
 
   assignAnnotation( art, val, name, prefix = '' ) {
@@ -1203,11 +1190,14 @@ class AstBuildingParser extends BaseParser {
   }
 
   checkStructProps( dict ) {
-    const special = primaryExprProperties.find( prop => dict[prop] !== undefined );
-    if (special || dict['=']) {
-      const prop = special || '=';
-      this.message( 'syntax-invalid-anno-struct', dict[prop].name.location,
-                    { '#': (special ? 'std' : 'ref'), prop } );
+    const prop = primaryExprProperties.find( p => dict[p] !== undefined );
+    if (prop) {
+      this.error( 'syntax-invalid-anno-struct', dict[prop].name.location,
+                  { '#': 'std', prop } );
+    }
+    else if (dict['='] && (dict['='].literal !== 'string' || !dict['='].val)) {
+      this.error( 'syntax-invalid-anno-struct', dict['='].location,
+                  { '#': 'ref', prop: '=' } );
     }
   }
 
@@ -1350,8 +1340,8 @@ class AstBuildingParser extends BaseParser {
         funcToken.parsedAs = 'func';
 
       const filter = path[0].cardinality || path[0].where; // XSN TODO: filter$location
-      if (filter) // TODO v7: make this be reported via guard, as error
-        this.message( 'syntax-unexpected-filter', filter.location, {} );
+      if (filter) // TODO v8: make this error be reported via guard
+        this.error( 'syntax-unexpected-filter', filter.location, {} );
       // TODO: XSN representation of functions is a bit strange - rework
       return this.attachLocation( {
         op: { location, val: 'call' },
@@ -1382,8 +1372,8 @@ class AstBuildingParser extends BaseParser {
         }, 'References after function calls can\'t be resolved. Use $(CODE) in function arguments');
       }
       const filter = item.cardinality || item.where; // XSN TODO: filter$location
-      if (filter) // TODO v7: make this be reported via guard, as error
-        this.message( 'syntax-unexpected-filter', filter.location, {} );
+      if (filter) // TODO v8: make this error be reported via guard
+        this.error( 'syntax-unexpected-filter', filter.location, {} );
     }
 
     const args = [];

package/lib/parsers/Lexer.js

@@ -181,6 +181,8 @@ function string( text, lexer, parser, beg ) {
         prefix.location.endCol !== lexer.location.col ||
         !quotedLiterals.includes( prefix.keyword )))
       prefix = null;
+    // TODO: warning (error in v8) if non-quotedLiterals prefix and/or
+    // try to do it via grammar = hard `<guard=followedByQuote> 'x' String` etc ?
     while (re.test( lexer.input ) && lexer.input[re.lastIndex] === "'")
       esc = ++re.lastIndex;
   }

package/lib/parsers/identifiers.js

@@ -15,17 +15,8 @@ const functionsWithoutParentheses = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-function isSimpleCdlIdentifier( id ) {
-  if (undelimitedIdentifierRegex.test(id))
-    return true;
-  const upperId = id.toUpperCase();
-  return !cdlKeywords.includes(upperId) &&
-    !functionsWithoutParentheses.includes(upperId);
-}
-
 module.exports = {
   undelimitedIdentifierRegex,
   cdlKeywords,
   functionsWithoutParentheses,
-  isSimpleCdlIdentifier,
 };

package/lib/render/toCdl.js

@@ -1123,7 +1123,6 @@ class CsnToCdl {
     result += env.indent;
     result += element.virtual ? 'virtual ' : '';
     result += element.key ? 'key ' : '';
-    result += element.masked ? 'masked ' : '';
     result += this.quoteNonIdentifierOrKeyword(elementName, env);
     if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${ element['#'] }`;
@@ -2001,50 +2000,52 @@ class CsnToCdl {
    * @param {any} annoValue
    * @param {CdlRenderEnvironment} env
    */
-  renderAnnotationValue( annoValue, env ) {
-    if (isAnnotationExpression(annoValue)) {
-      // Once inside an expression, we stay there.
-      const xpr = this.exprRenderer.renderExpr(annoValue, env);
-      return `( ${ xpr } )`;
-    }
-    else if (Array.isArray(annoValue)) {
+  renderAnnotationValue( annoValue, env, isTopLevel = false ) {
+    if (Array.isArray(annoValue))
       return this.renderAnnotationArrayValue( annoValue, env );
-    }
-    else if (typeof annoValue === 'object' && annoValue !== null) {
-      // Enum symbol
-      if (annoValue['#'] !== undefined) {
-        return `#${ annoValue['#'] }`;
-      }
-      // Shorthand for absolute path (as string)
-      else if (typeof annoValue['='] === 'string') {
-        if (annoValue['='].startsWith('@'))
-          return this.quoteAnnotationPathIfRequired(annoValue['='], env);
-        return this.quotePathIfRequired(annoValue['='], env);
-      }
-      // Shorthand for ellipsis: `... up to <val>`
-      else if (annoValue['...'] !== undefined) {
-        if (annoValue['...'] === true)
-          return '...';
-        return `... up to ${ this.renderAnnotationValue(annoValue['...'], env) }`;
-      }
 
-      // Struct value (can currently only occur within an array)
-      // Render as one-liner if there is at most one key.  Render as multi-line
-      // struct if there are more and use nicer indentation.
-      const keys = Object.keys(annoValue);
-      const childEnv = env.withIncreasedIndent();
-      const values = keys.map(key => `${ this.quoteAnnotationPathIfRequired(key, env) }: ${ this.renderAnnotationValue(annoValue[key], childEnv.withSubPath([ key ])) }`);
-      const result = joinDocuments(values, [ ',', line() ]);
-      return format(nestBy(env.indent.length, bracketBlock(INDENT_SIZE, '{', result, '}') ));
-    }
     // Null
-    else if (annoValue === null) {
+    if (annoValue === null)
       return 'null';
+
+    if (typeof annoValue !== 'object') {
+      // Primitive: string, number, boolean
+      // Quote strings, leave all others as they are
+      return (typeof annoValue === 'string') ? renderString(annoValue, env) : String(annoValue);
     }
-    // Primitive: string, number, boolean
+    // Enum symbol (is also annotation expression, but rendered without `(…)`
+    if (annoValue['#'] !== undefined)
+      return `#${ annoValue['#'] }`;
 
-    // Quote strings, leave all others as they are
-    return (typeof annoValue === 'string') ? renderString(annoValue, env) : String(annoValue);
+    if (isAnnotationExpression(annoValue)) {
+      // Once inside an expression, we stay there.
+      const xpr = this.exprRenderer.renderExpr(annoValue, env);
+      return `( ${ xpr } )`;
+    }
+    // Unchecked reference in `=` (with additional props: render as struct if not top-level)
+    if (typeof annoValue['='] === 'string' &&
+        (isTopLevel || Object.keys(annoValue).length === 1)) {
+      // TODO: the to.cdl backend could issue a warning if there are non-`=`
+      // properties in a structure outside an array (not representable in CDL)
+      return (annoValue['='].startsWith('@'))
+        ? this.quoteAnnotationPathIfRequired(annoValue['='], env)
+        : this.quotePathIfRequired(annoValue['='], env);
+    }
+    // Ellipsis: `... up to <val>`
+    if (annoValue['...'] !== undefined) {
+      return (annoValue['...'] === true)
+        ? '...'
+        : `... up to ${ this.renderAnnotationValue(annoValue['...'], env) }`;
+    }
+
+    // Struct value (TODO: issue warning if outside an array, possible via CSN input)
+    // Render as one-liner if there is at most one key.  Render as multi-line
+    // struct if there are more and use nicer indentation.
+    const keys = Object.keys(annoValue);
+    const childEnv = env.withIncreasedIndent();
+    const values = keys.map(key => `${ this.quoteAnnotationPathIfRequired(key, env) }: ${ this.renderAnnotationValue(annoValue[key], childEnv.withSubPath([ key ])) }`);
+    const result = joinDocuments(values, [ ',', line() ]);
+    return format(nestBy(env.indent.length, bracketBlock(INDENT_SIZE, '{', result, '}') ));
   }
 
   /**
@@ -2485,7 +2486,7 @@ class CsnToCdl {
       // nor multiple `#`, so we're back at simple paths that are possibly quoted.
       result += `#${ this.quotePathIfRequired(variant, env) }`;
     }
-    result += ` : ${ this.renderAnnotationValue(anno, env) }`;
+    result += ` : ${ this.renderAnnotationValue(anno, env, true) }`;
 
     if (parentheses)
       result += ')';

package/lib/render/toSql.js

@@ -1460,7 +1460,14 @@ function toSqlDdl( csn, options, messageFunctions ) {
    * @returns {string} Rendered type
    */
   function renderBuiltinType( typeName ) {
-    const types = cdsToSqlTypes[options.sqliteRealAffinityForDecimal && options.sqlDialect === 'sqlite' ? 'sqlitereal' : options.sqlDialect];
+    // Determine if we should use REAL affinity for decimal types
+    // Priority: 1) new decimal_affinity option, 2) old sqliteRealAffinityForDecimal option
+    const useRealAffinity = options.sqlDialect === 'sqlite' && (
+      options.decimal_affinity === 'real' ||
+      (options.decimal_affinity === undefined && options.sqliteRealAffinityForDecimal === true)
+    );
+
+    const types = cdsToSqlTypes[useRealAffinity ? 'sqlitereal' : options.sqlDialect];
     const result = types?.[typeName] || cdsToSqlTypes.standard[typeName];
     if (!result && options.testMode)
       throw new CompilerAssertion(`Expected to find a type mapping for ${ typeName }`);

package/lib/render/utils/common.js

@@ -37,7 +37,7 @@ function renderFunc( funcName, node, renderArgs, utils ) {
   const { sqlDialect } = options;
   if (funcWithoutParen( node, sqlDialect ))
     return funcName;
-  const rewriteStandardFunctions = options.transformation !== 'hdbcds' && sqlDialect !== 'plain' && options.standardDatabaseFunctions !== false;
+  const rewriteStandardFunctions = sqlDialect !== 'plain' && options.standardDatabaseFunctions !== false;
   if (rewriteStandardFunctions) {
     // we check function arguments for correctness
     const { error } = messageFunctions;

package/lib/render/utils/sql.js

@@ -29,8 +29,7 @@ function renderReferentialConstraint( constraint, indent, toUpperCase, csn, opti
     constraint.parentTable = constraint.parentTable.toUpperCase();
   }
 
-  const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
-                                options.src === 'hdi';
+  const renderAsHdbconstraint = options.src === 'hdi';
 
   const { sqlMapping, sqlDialect } = options;
   let result = '';
@@ -54,7 +53,7 @@ function renderReferentialConstraint( constraint, indent, toUpperCase, csn, opti
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
   // constraint enforcement / validation not supported by postgres
-  if (options.transformation === 'hdbcds' || (options.toSql && sqlDialect !== 'sqlite' && sqlDialect !== 'postgres')) {
+  if (options.toSql && sqlDialect !== 'sqlite' && sqlDialect !== 'postgres') {
     result += `${ indent }${ !constraint.validated ? 'NOT ' : '' }VALIDATED\n`;
     result += `${ indent }${ !constraint.enforced ? 'NOT ' : '' }ENFORCED\n`;
   }

package/lib/tool-lib/enrichCsn.js

@@ -142,9 +142,8 @@ function enrichCsn( csn, options = {} ) {
       obj.forEach( (n, i) => assignment( obj, i, n ) );
     }
     else {
-      // TODO: check obj['='] is only String|true ?
       const record = !isAnnotationExpression( obj ) && assignment;
-      // is record without `=` and other expression property
+      // is record without primary expression property
       for (const name of Object.getOwnPropertyNames( obj ) ) {
         const trans = record || transformers[name] || transformers[name.charAt(0)] || standard;
         trans( obj, name, obj[name] );

package/lib/transform/db/applyTransformations.js

@@ -358,30 +358,32 @@ function transformExpression( parent, parentName, transformers, path = [], ctx =
  * @param {string|number} propName Start at specific property of parent
  * @param {object} transformers Map of callback functions
  * @param {CSN.Path} path Path to parent
+ * @param {boolean} annoScope Is it annotation scope
  * @returns {object} transformed node
  */
-function transformAnnotationExpression( parent, propName, transformers, path = [] ) {
+function transformAnnotationExpression( parent, propName, transformers, path = [], annoScope = undefined ) {
   if (propName != null) {
     const child = parent[propName];
     if (!child || typeof child !== 'object' ||
         !{}.propertyIsEnumerable.call( parent, propName ))
       return parent;
 
-    if (isAnnotationExpression(child))
+    annoScope ||= propName[0] === '@';
+    if (annoScope && isAnnotationExpression(child))
       return transformExpression(parent, propName, transformers, path, { annoExpr: child });
 
     path = [ ...path, propName ];
     if (Array.isArray(child)) {
-      child.forEach( (n, i) => transformAnnotationExpression( child, i, transformers, path ) );
+      child.forEach( (n, i) => transformAnnotationExpression( child, i, transformers, path, annoScope ) );
     }
     else {
       for (const cpn of Object.getOwnPropertyNames( child ))
-        transformAnnotationExpression(child, cpn, transformers, path);
+        transformAnnotationExpression(child, cpn, transformers, path, annoScope);
     }
   }
   else {
     for (propName of Object.getOwnPropertyNames( parent ))
-      transformAnnotationExpression( parent, propName, transformers, path );
+      transformAnnotationExpression( parent, propName, transformers, path, annoScope );
   }
   return parent;
 }

package/lib/transform/db/assertUnique.js

@@ -254,11 +254,7 @@ function processAssertUnique( csn, options, messageFunctions ) {
  * If the output format is SQL, the toSql renderer is responsible
  * to render the table constraints from the constraint dictionary.
  *
- * If options.transformation === 'hdbcds', no path flattening is done and  association
- * paths are replaced with the foreign key paths by simply
- * concatenating the foreign key paths (available in element.keys).
- *
- * If options.toSql, all paths are flattened depending on the naming
+ * All paths are flattened depending on the naming
  * mode either with '_' or '.' as delimiter.
  * Each association is replaced by the respective foreign key elements
  * that are annotated with an appropriate '@odata.foreignKey4'.
@@ -275,47 +271,23 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
   function rewrite( artifact ) {
     if (artifact.$tableConstraints && artifact.$tableConstraints.unique) {
       const uniqueConstraints = artifact.$tableConstraints.unique;
-      // it's safe to add the tc here
-      if (options.transformation === 'hdbcds') {
-        if (!artifact.technicalConfig)
-          artifact.technicalConfig = Object.create(null);
-
-        if (!artifact.technicalConfig.hana) {
-          artifact.technicalConfig.hana = Object.create(null);
-          artifact.technicalConfig.hana.calculated = true;
-        }
-        if (!artifact.technicalConfig.hana.indexes)
-          artifact.technicalConfig.hana.indexes = Object.create(null);
-      }
       for (const uniqueConstraint in artifact.$tableConstraints.unique) {
         // iterate over each constraint
         const c = uniqueConstraints[uniqueConstraint].paths;
         const rewrittenPaths = [];
         // and inspect each path of the constraint
         c.forEach((cpath) => {
-          // If 'toSql' or 'toHana' and naming !== 'hdbcds'
           // concatenate path refs with appropriate delimiter
-          if (options.transformation !== 'hdbcds' || (options.transformation === 'hdbcds' && options.sqlMapping !== 'hdbcds'))
-            cpath.ref = [ cpath.ref.map(p => p.id).join( pathDelimiter ) ];
+          cpath.ref = [ cpath.ref.map(p => p.id).join( pathDelimiter ) ];
 
           // Foreign key substitution
           if (cpath._art.target) {
-            if (options.transformation !== 'hdbcds' || (options.transformation === 'hdbcds' && options.sqlMapping !== 'hdbcds')) {
-              // read out new association and use $generatedFieldName
-              // cpath._art still refers to the assoc definition
-              // before the A2J transformation. This assoc
-              // doesn't contain the correct $generatedFieldName(s)
-              const assoc = artifact.elements[cpath.ref[0]];
-              rewrittenPaths.push(...assoc.keys.map(k => ({ ref: [ k.$generatedFieldName ] })));
-            }
-            else {
-              // This is Classic HANA CDS toHana/hdbcds
-              // add foreign key ref path to association path
-              // ... for hanacds, the 'real' ref paths are used, and
-              // these have not changed before and after A2J transformation,
-              // so it's safe to use the original paths.
-              rewrittenPaths.push(...cpath._art.keys.map(k => ({ ref: cpath.ref.concat(k.ref) })));
-            }
+            // read out new association and use $generatedFieldName
+            // cpath._art still refers to the assoc definition
+            // before the A2J transformation. This assoc
+            // doesn't contain the correct $generatedFieldName(s)
+            const assoc = artifact.elements[cpath.ref[0]];
+            rewrittenPaths.push(...assoc.keys.map(k => ({ ref: [ k.$generatedFieldName ] })));
           }
           else {
             rewrittenPaths.push(cpath);
@@ -323,21 +295,6 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
         });
         // preserve the rewritten and filtered paths for toSql
         uniqueConstraints[uniqueConstraint] = { paths: rewrittenPaths, parentTable: uniqueConstraints[uniqueConstraint].parentTable };
-
-        // now add the index for HANA CDS
-        if (options.transformation === 'hdbcds') {
-          const cond = [];
-          let i = 0;
-          for (const constraint of rewrittenPaths) {
-            if (i > 0)
-              cond.push(',');
-            cond.push(constraint);
-            i++;
-          }
-          artifact.technicalConfig.hana.indexes[uniqueConstraint] = [
-            'unique', 'index', { ref: [ uniqueConstraint ] }, 'on', { xpr: cond },
-          ];
-        }
       }
       artifact.$tableConstraints.unique = uniqueConstraints;
     }

package/lib/transform/db/associations.js

@@ -136,7 +136,7 @@ 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)
+        if (annoBefore !== annoAfter && (options.transformation !== 'effective' || obj[anno]['=']))
           obj[anno]['='] = true;
       });
   }

package/lib/transform/db/cdsPersistence.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const {
-  forEachGeneric,
   forEachMemberRecursively,
   isPersistedOnDatabase,
   hasPersistenceSkipAnnotation,
@@ -42,7 +41,6 @@ function getAnnoProcessor() {
  */
 function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
   const { info } = messageFunctions;
-  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 
   const { isAssocOrComposition } = csnUtils;
 
@@ -53,21 +51,9 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
    *
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
-   * @param {string} prop
-   * @param {CSN.Path} path
    */
-  function ignoreAssociationToSkippedTarget( artifact, artifactName, prop, path ) {
+  function ignoreAssociationToSkippedTarget( artifact, artifactName, _prop, _path ) {
     if (isPersistedOnDatabase(artifact)) {
-      // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
-      if (artifact.query) {
-        // If we do A2J, we don't need to check the mixin. Either it is used -> a join
-        // or published -> handled via elements/members. Unused mixins are removed anyway.
-        if (!doA2J && artifact.query.SELECT && artifact.query.SELECT.mixin)
-          forEachGeneric(artifact.query.SELECT, 'mixin', ignore, path.concat([ 'query', 'SELECT' ]));
-
-        else if (!doA2J && artifact.query.SET && artifact.query.SET.mixin)
-          forEachGeneric(artifact.query.SET, 'mixin', ignore, path.concat([ 'query', 'SET' ]));
-      }
       forEachMemberRecursively(artifact, ignore, [ 'definitions', artifactName ]);
     }
   }

package/lib/transform/db/expansion.js

@@ -40,13 +40,11 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     columns: (parent, name, columns, path) => {
       const artifact = csn.definitions[path[1]];
       csnUtils.initDefinition(artifact); // potentially not initialized, yet
-      const root = csnUtils.get$combined({ SELECT: parent });
-      // TODO: replace with the correct options.transformation?
-      // Do not expand the * in OData for a moment, not to introduce changes
-      // while the OData CSN is still official
       const isComplexQuery = parent.from.join !== undefined;
-      if (!options.toOdata)
+      if (!options.toOdata && columns.includes('*')) {
+        const root = csnUtils.get$combined({ SELECT: parent });
         parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
+      }
       // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
       // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
       parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
@@ -63,7 +61,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
   };
 
   // To not have a whole model loop for such a "small" thing, we kill all non-sql-backend relevant annotations here
-  if (options.transformation === 'sql' || options.transformation === 'hdbcds')
+  if (options.transformation === 'sql')
     transformers['@'] = killNonrequiredAnno;
 
   applyTransformations(csn, transformers, [], iterateOptions);
@@ -362,7 +360,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
             if (sub.ref) {
               // Each expand/inline can introduce another layer of $self/$projection.  Since $self is
               // a path-breakout, we can simply use the ref without outer expand/inline-references.
-              subRef = (sub.$scope === '$self') ? sub.ref : currentRef.concat(sub.ref);
+              subRef = (sub.$scope === '$self' || sub.param) ? sub.ref : currentRef.concat(sub.ref);
             }
             else {
               subRef = currentRef;
@@ -456,7 +454,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     function rewriteOnCondition( on, currentRef, stack ) {
       for (let i = 0; i < on.length; i++) {
         const part = on[i];
-        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self' && part.$scope !== '$projection') {
+        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self' && part.$scope !== '$projection' && !part.param) {
           part.ref = currentRef[0] ? [ currentRef[0], ...part.ref ] : part.ref;
           on[i] = part;
           stack.push([ part, part.ref ]);
@@ -477,7 +475,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     function rewriteSingleExpressionArray( expressionArray, currentRef, stack ) {
       for (let i = 0; i < expressionArray.length; i++) {
         const part = expressionArray[i];
-        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self') {
+        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self' && !part.param) {
           part.ref = currentRef.concat(part.ref);
           expressionArray[i] = part;
           stack.push([ part, part.ref ]);
@@ -842,7 +840,7 @@ function expandWildcard( query, csnUtils, options ) {
 
 /**
  * Get all elements that are expanded by '*'.
- * Respects the query's 'excluding' clause and 'masked' elements.
+ * Respects the query's 'excluding' clause.
  * Elements that are replaced by columns have a `replacedByColumn` property.
  *
  * @param {object} query Query with SELECT/projection.
@@ -855,9 +853,8 @@ function wildcardElements( query, csnUtils ) {
   for (const excluded of SELECT.excluding ?? [])
     delete combined[excluded];
 
-  // Handle deprecated 'masked' keyword.
+  // TODO?: simplify
   for (const name in combined) {
-    combined[name] = combined[name].filter(sourceElement => !sourceElement.element?.masked);
     if (combined[name].length === 0)
       delete combined[name];
     else

package/lib/transform/db/flattening.js

@@ -80,7 +80,7 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
     iterateOptions.skipDict = { actions: true };
 
   const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
-  const stripItems = options.transformation === 'hdbcds' || options.transformation === 'sql';
+  const stripItems = options.transformation === 'sql';
   const removeItems = new Set();
   applyTransformations(csn, {
     type: (node, prop, type, path, parent, parentProp) => {

package/lib/transform/db/groupByOrderBy.js

@@ -24,14 +24,6 @@ function replaceAssociationsInGroupByOrderBy( inputQuery, options, inspectRef, e
         const { art } = inspectRef(groupByPath);
         if (art && art.target) {
           if (art.keys) {
-            // This is (or used to be before transformation) a managed assoc
-            // (230 c) If we keep associations as they are (hdbcds naming convention), we can't have associations in GROUP BY
-            if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
-              error(null, groupByPath,
-                    { $reviewed: true, keyword: 'GROUP BY', value: 'hdbcds' },
-                    'Unexpected managed association in $(KEYWORD) for naming mode $(VALUE)');
-              continue;
-            }
             const pathPrefix = query.groupBy[i].ref.slice(0, -1);
             getForeignKeyRefs(art)
               .map(fk => ({ ref: pathPrefix.concat(fk.ref) }))
@@ -57,14 +49,6 @@ function replaceAssociationsInGroupByOrderBy( inputQuery, options, inspectRef, e
         const { art } = inspectRef(orderByPath);
         if (art && art.target) {
           if (art.keys) {
-            // This is (or used to be before transformation) a managed assoc
-            // (230 d) If we keep associations as they are (hdbcds naming convention), we can't have associations in ORDER BY
-            if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
-              error(null, orderByPath,
-                    { $reviewed: true, keyword: 'ORDER BY', value: 'hdbcds' },
-                    'Unexpected managed association in $(KEYWORD) for naming mode $(VALUE)');
-              continue;
-            }
             const pathPrefix = query.orderBy[i].ref.slice(0, -1);
             getForeignKeyRefs(art)
               .map(fk => ({ ref: pathPrefix.concat(fk.ref) }))