@sap/cds-compiler 5.9.4 → 6.0.12

package/lib/render/toHdbcds.js

@@ -3,8 +3,8 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, getNormalizedQuery,
-  getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
-  pathName,
+  getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement,
+  pathName, hasPersistenceSkipAnnotation,
 } = require('../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const keywords = require('../base/keywords');
@@ -18,7 +18,7 @@ const {
   renderReferentialConstraint,
 } = require('./utils/sql');
 const DuplicateChecker = require('./DuplicateChecker');
-const { isDeprecatedEnabled, forEachDefinition } = require('../base/model');
+const { forEachDefinition, isDeprecatedEnabled } = require('../base/model');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
 
@@ -55,7 +55,7 @@ class HdbcdsRenderEnvironment {
   }
 
   withIncreasedIndent() {
-    return new HdbcdsRenderEnvironment({ ...this, namePrefix: '', indent: `  ${this.indent}` });
+    return new HdbcdsRenderEnvironment({ ...this, namePrefix: '', indent: `  ${ this.indent }` });
   }
   withSubPath(path) {
     return new HdbcdsRenderEnvironment({ ...this, path: [ ...this.path, ...path ] });
@@ -84,7 +84,7 @@ function getEscapedHanaComment( obj ) {
  * @returns {string}
  */
 function renderStringForHdbcds( str ) {
-  return `'${str.replace(/'/g, '\'\'')}'`;
+  return `'${ str.replace(/'/g, '\'\'') }'`;
 }
 
 /**
@@ -117,25 +117,24 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
         const typeRefWithoutParams = typeRef.substring(0, typeRef.indexOf('(')) || typeRef;
         typeRef = typeRef.replace(typeRefWithoutParams, hanaSqlType);
       }
-      return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
+      return `CAST(${ this.renderExpr(withoutCast(x)) } AS ${ typeRef })`;
     },
     val: renderExpressionLiteral,
-    enum: x => `#${x['#']}`,
+    enum: x => `#${ x['#'] }`,
     ref: renderExpressionRef,
-    aliasOnly: x => x.as,
     windowFunction: renderExpressionFunc,
     func: renderExpressionFunc,
     xpr(x) {
       const xprEnv = this.env.withSubPath([ 'xpr' ]);
       if (this.isNestedXpr && !x.cast)
-        return `(${this.renderSubExpr(x.xpr, xprEnv)})`;
+        return `(${ this.renderSubExpr(x.xpr, xprEnv) })`;
       return this.renderSubExpr(x.xpr, xprEnv);
     },
     SELECT(x) {
-      return `(${renderQuery(x, false, this.env.withIncreasedIndent())})`;
+      return `(${ renderQuery(x, false, this.env.withIncreasedIndent()) })`;
     },
     SET(x) {
-      return `${renderQuery(x, false, this.env.withIncreasedIndent())}`;
+      return `${ renderQuery(x, false, this.env.withIncreasedIndent()) }`;
     },
   });
 
@@ -259,7 +258,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       case 'event':
         return '';
       default:
-        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${ art.kind }`);
     }
   }
 
@@ -270,7 +269,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    * @returns {object} Dictionary with direct sub-artifacts
    */
   function getSubArtifacts( artifactName ) {
-    const prefix = `${artifactName}.`;
+    const prefix = `${ artifactName }.`;
     const result = Object.create(null);
     for (const name in csn.definitions) {
       // We have a direct child if its name starts with prefix and contains no more dots
@@ -334,23 +333,23 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (isShadowed) {
       const subArtifacts = getSubArtifacts(artifactName);
       for (const name in subArtifacts)
-        result += renderDefinition(`${artifactName}.${name}`, subArtifacts[name], env);
+        result += renderDefinition(`${ artifactName }.${ name }`, subArtifacts[name], env);
 
-      return `${result}\n`;
+      return `${ result }\n`;
     }
 
     const childEnv = env.withIncreasedIndent();
-    result += `${env.indent}context ${renderArtifactName(artifactName, env, true)}`;
+    result += `${ env.indent }context ${ renderArtifactName(artifactName, env, true) }`;
     result += ' {\n';
     const subArtifacts = getSubArtifacts(artifactName);
     let renderedSubArtifacts = '';
     for (const name in subArtifacts)
-      renderedSubArtifacts += renderDefinition(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
+      renderedSubArtifacts += renderDefinition(`${ artifactName }.${ name }`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
 
     if (renderedSubArtifacts === '')
       return '';
 
-    return `${result + renderedSubArtifacts + env.indent}};\n`;
+    return `${ result + renderedSubArtifacts + env.indent }};\n`;
   }
 
   /**
@@ -411,7 +410,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     const childEnv = addNamePrefix(env, getLastPartOf(artifactName));
     const subArtifacts = getSubArtifacts(artifactName);
     for (const name in subArtifacts)
-      result += renderDefinition(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
+      result += renderDefinition(`${ artifactName }.${ name }`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
 
     return result;
   }
@@ -432,7 +431,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], env.path, artifactName);
 
     if (hasHanaComment(art, options))
-      result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
+      result += `${ env.indent }@Comment: '${ getEscapedHanaComment(art) }'\n`;
 
     // tables can have @sql.prepend and @sql.append
     const { front, back } = getSqlSnippets(options, art);
@@ -440,10 +439,10 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (front) // attach @sql.prepend after adding @Comment annotation
       result += front;
 
-    result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
+    result += `${ env.indent + (art.abstract ? 'abstract ' : '') }entity ${ normalizedArtifactName }`;
     if (art.includes) {
       // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map((name, i) => renderAbsoluteNameWithQuotes(name, env.withSubPath([ 'includes', i ]))).join(', ')}`;
+      result += ` : ${ art.includes.map((name, i) => renderAbsoluteNameWithQuotes(name, env.withSubPath([ 'includes', i ]))).join(', ') }`;
     }
     result += ' {\n';
     const duplicateChecker = new DuplicateChecker(); // registry for all artifact names and element names
@@ -455,13 +454,13 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       result += renderElement(name, art.elements[name], childEnv.withSubPath([ 'elements', name ]), duplicateChecker);
 
     duplicateChecker.check(error);
-    result += `${env.indent}}`;
-    result += `${renderTechnicalConfiguration(art.technicalConfig, env)}`;
+    result += `${ env.indent }}`;
+    result += `${ renderTechnicalConfiguration(art.technicalConfig, env) }`;
 
     if (back)
       result += back;
 
-    return `${result};\n`;
+    return `${ result };\n`;
   }
 
   /**
@@ -510,11 +509,11 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (!tc)
       throw new ModelError('Expecting a SAP HANA technical configuration');
 
-    result += `\n${env.indent}technical ${tc.calculated ? '' : 'hana '}configuration {\n`;
+    result += `\n${ env.indent }technical ${ tc.calculated ? '' : 'hana ' }configuration {\n`;
 
     // Store type (must be separate because SQL wants it between 'CREATE' and 'TABLE')
     if (tc.storeType)
-      result += `${tc.storeType} store;\n`;
+      result += `${ tc.storeType } store;\n`;
 
     // Fixed parts belonging to the table (includes migration, unload prio, extended storage,
     // auto merge, partitioning, ...)
@@ -527,7 +526,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       // object. Semantically equivalent because a "trivial" SQL renderer would just
       // concatenate them.
       for (const xpr of tc.tableSuffix)
-        result += `${childEnv.indent + renderExpr(xpr, childEnv)};\n`;
+        result += `${ childEnv.indent + renderExpr(xpr, childEnv) };\n`;
     }
 
     // Indices and full-text indices
@@ -535,10 +534,10 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       if (Array.isArray(tc.indexes[idxName][0])) {
         // FIXME: Should we allow multiple indices with the same name at all?
         for (const index of tc.indexes[idxName])
-          result += `${childEnv.indent + renderExpr(index, childEnv)};\n`;
+          result += `${ childEnv.indent + renderExpr(index, childEnv) };\n`;
       }
       else {
-        result += `${childEnv.indent + renderExpr(tc.indexes[idxName], childEnv)};\n`;
+        result += `${ childEnv.indent + renderExpr(tc.indexes[idxName], childEnv) };\n`;
       }
     }
     // Fuzzy search indices
@@ -547,13 +546,13 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
         // FIXME: Should we allow multiple fuzzy search indices on the same column at all?
         // And if not, why do we wrap this into an array?
         for (const index of tc.fzindexes[columnName])
-          result += `${childEnv.indent + renderExpr(fixFuzzyIndex(index, columnName), childEnv)};\n`;
+          result += `${ childEnv.indent + renderExpr(fixFuzzyIndex(index, columnName), childEnv) };\n`;
       }
       else {
-        result += `${childEnv.indent + renderExpr(fixFuzzyIndex(tc.fzindexes[columnName], columnName), childEnv)};\n`;
+        result += `${ childEnv.indent + renderExpr(fixFuzzyIndex(tc.fzindexes[columnName], columnName), childEnv) };\n`;
       }
     }
-    result += `${env.indent}}`;
+    result += `${ env.indent }}`;
     return result;
 
 
@@ -599,7 +598,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       duplicateChecker.addElement(quotedElementName, env.path, elementName);
 
     if (hasHanaComment(elm, options))
-      result += `${env.indent}@Comment: '${getEscapedHanaComment(elm)}'\n`;
+      result += `${ env.indent }@Comment: '${ getEscapedHanaComment(elm) }'\n`;
 
     result += env.indent + (elm.key && !isSubElement ? 'key ' : '') +
       (elm.masked ? 'masked ' : '') +
@@ -610,7 +609,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (!elm.value?.stored) {
       result += renderNullability(elm);
       if (elm.default && !elm.target)
-        result += ` default ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
+        result += ` default ${ renderExpr(elm.default, env.withSubPath([ 'default' ])) }`;
     }
 
     // (table) elements can only have a @sql.append
@@ -619,7 +618,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (back)
       result += back;
 
-    return `${result};\n`;
+    return `${ result };\n`;
   }
 
   /**
@@ -634,20 +633,20 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
   function renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      let result = `(${renderQuery(source, false, env.withIncreasedIndent())})`;
+      let result = `(${ renderQuery(source, false, env.withIncreasedIndent()) })`;
       if (source.as)
-        result += ` as ${formatIdentifier(source.as)}`;
+        result += ` as ${ formatIdentifier(source.as) }`;
       return result;
     }
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
+      let result = `${ renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ])) }`;
       for (let i = 1; i < source.args.length; i++) {
-        result = `(${result} ${source.join} `;
-        result += `join ${renderViewSource(source.args[i], env.withSubPath([ 'args', i ]))}`;
+        result = `(${ result } ${ source.join } `;
+        result += `join ${ renderViewSource(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' ])) }`;
 
         result += ')';
       }
@@ -670,7 +669,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
   function renderAbsolutePath( path, env ) {
     // Sanity checks
     if (!path.ref)
-      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${ JSON.stringify(path) }`);
 
 
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
@@ -685,16 +684,16 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
-      result += `(${renderArgs(path.ref[0], ':', env.withSubPath([ 'ref', 0 ]))})`;
+      result += `(${ renderArgs(path.ref[0], ':', env.withSubPath([ 'ref', 0 ])) })`;
 
     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' ]))}]`;
+      const cardinality = path.ref[0].cardinality ? (`${ path.ref[0].cardinality.max }: `) : '';
+      result += `[${ cardinality }${ renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ])) }]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `.${renderTypeRef({ ref: path.ref.slice(1) }, env)}`;
+      result += `.${ renderTypeRef({ ref: path.ref.slice(1) }, env) }`;
 
     return result;
   }
@@ -716,11 +715,11 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.sqlMapping, path.ref[0])) : getLastPartOfRef(path.ref);
     if (path.as) {
       // Source had an alias - render it
-      result += ` as ${formatIdentifier(path.as)}`;
+      result += ` as ${ formatIdentifier(path.as) }`;
     }
     else if (getLastPartOf(result) !== formatIdentifier(implicitAlias)) {
       // Render an artificial alias if the result would produce a different one
-      result += ` as ${formatIdentifier(implicitAlias)}`;
+      result += ` as ${ formatIdentifier(implicitAlias) }`;
     }
     return result;
   }
@@ -742,10 +741,9 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // Render 'null as <alias>' only for database and if element is virtual
     if (element?.virtual) {
       if (isDeprecatedEnabled(options, '_renderVirtualElements'))
-        return `${env.indent}null as ${formatIdentifier(leaf)}`;
+        return `${ env.indent }null as ${ formatIdentifier(leaf) }`;
       return '';
     }
-
     return renderNonVirtualColumn();
 
 
@@ -769,15 +767,15 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
         alias = leaf;
 
       if (alias)
-        result += ` as ${formatIdentifier(alias)}`;
+        result += ` as ${ formatIdentifier(alias) }`;
 
       // Explicit type provided for the view element?
       if (col.cast?.target) {
         // Special case: Explicit association type is actually a redirect
         // Redirections are never flattened (don't exist in HANA)
-        result += ` : redirected to ${renderAbsoluteNameWithQuotes(col.cast.target, env.withSubPath([ 'cast', 'target' ]))}`;
+        result += ` : redirected to ${ renderAbsoluteNameWithQuotes(col.cast.target, env.withSubPath([ 'cast', 'target' ])) }`;
         if (col.cast.on)
-          result += ` on ${renderExpr(col.cast.on, env.withSubPath([ 'cast', 'on' ]))}`;
+          result += ` on ${ renderExpr(col.cast.on, env.withSubPath([ 'cast', 'on' ])) }`;
       }
 
       return result;
@@ -800,16 +798,16 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], artifactPath, artifactName);
 
     if (hasHanaComment(art, options))
-      result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
+      result += `${ env.indent }@Comment: '${ getEscapedHanaComment(art) }'\n`;
 
-    result += `${env.indent}${art.abstract ? 'abstract ' : ''}view ${renderArtifactName(artifactName, env)}`;
+    result += `${ env.indent }${ art.abstract ? 'abstract ' : '' }view ${ renderArtifactName(artifactName, env) }`;
     if (art.params) {
       const childEnv = env.withIncreasedIndent();
       const parameters = Object.keys(art.params)
         .map(name => renderParameter(name, art.params[name], childEnv.withSubPath([ 'params', name ])))
         .join(',\n');
       // SAP HANA only understands the 'with parameters' syntax'
-      result += ` with parameters\n${parameters}\n${env.indent}as `;
+      result += ` with parameters\n${ parameters }\n${ env.indent }as `;
     }
     else {
       result += ' as ';
@@ -846,34 +844,34 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
       // First arg may be leading query
-      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env.withSubPath([ 'SET', 'args', 0 ]), elements || query.SET.elements)}`;
+      result += `(${ renderQuery(query.SET.args[0], isLeadingQuery, env.withSubPath([ 'SET', 'args', 0 ]), elements || query.SET.elements) }`;
       // FIXME: Clarify if set operators can be n-ary (assuming binary here)
       if (query.SET.op) {
         // Loop over all other arguments, i.e. for A UNION B UNION C UNION D ...
         for (let i = 1; i < query.SET.args.length; i++)
-          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, env.withSubPath([ 'SET', 'args', i ]), elements || query.SET.elements)}`;
+          result += `\n${ env.indent }${ query.SET.op }${ query.SET.all ? ' all' : '' } ${ renderQuery(query.SET.args[i], false, env.withSubPath([ 'SET', 'args', i ]), elements || query.SET.elements) }`;
       }
       result += ')';
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
       if (query.SET.orderBy)
-        result += `${continueIndent(result, env)}order by ${query.SET.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'SET', 'orderBy', i ]))).join(', ')}`;
+        result += `${ continueIndent(result, env) }order by ${ query.SET.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'SET', 'orderBy', i ]))).join(', ') }`;
 
       if (query.SET.limit)
-        result += `${continueIndent(result, env)}${renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ]))}`;
+        result += `${ continueIndent(result, env) }${ renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ])) }`;
 
       return result;
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)} at ${JSON.stringify(env.path)}`);
+      throw new ModelError(`Unexpected query operation ${ JSON.stringify(query) } at ${ JSON.stringify(env.path) }`);
     }
 
     if (!isProjection)
       env = env.withSubPath([ 'SELECT' ]);
 
     const select = query.SELECT;
-    result += `select from ${renderViewSource(select.from, env.withSubPath([ 'from' ]))}`;
+    result += `select from ${ renderViewSource(select.from, env.withSubPath([ 'from' ])) }`;
 
     const childEnv = env.withIncreasedIndent();
     childEnv.currentArtifactName = $PROJECTION; // $self to be replaced by $projection
@@ -885,7 +883,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       if (elems) {
         result += ' mixin {\n';
         result += elems;
-        result += `${env.indent}} into`;
+        result += `${ env.indent }} into`;
       }
     }
     result += select.distinct ? ' distinct' : '';
@@ -895,12 +893,12 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
         .map((col, i) => renderViewColumn(col, elements || select.elements, childEnv.withSubPath([ 'columns', i ])))
         .filter(s => s !== '')
         .join(',\n');
-      result += `\n${env.indent}}`;
+      result += `\n${ env.indent }}`;
     }
     if (select.excluding) {
-      const excludingList = select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n');
-      result += ` excluding {\n${excludingList}\n`;
-      result += `${env.indent}}`;
+      const excludingList = select.excluding.map(id => `${ childEnv.indent }${ formatIdentifier(id) }`).join(',\n');
+      result += ` excluding {\n${ excludingList }\n`;
+      result += `${ env.indent }}`;
     }
 
     return renderSelectProperties(select, result, env);
@@ -916,19 +914,19 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    */
   function renderSelectProperties( select, alreadyRendered, env ) {
     if (select.where)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
+      alreadyRendered += `${ continueIndent(alreadyRendered, env) }where ${ renderExpr(select.where, env.withSubPath([ 'where' ])) }`;
 
     if (select.groupBy)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
+      alreadyRendered += `${ continueIndent(alreadyRendered, env) }group by ${ select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ') }`;
 
     if (select.having)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
+      alreadyRendered += `${ continueIndent(alreadyRendered, env) }having ${ renderExpr(select.having, env.withSubPath([ 'having' ])) }`;
 
     if (select.orderBy)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}order by ${select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
+      alreadyRendered += `${ continueIndent(alreadyRendered, env) }order by ${ select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ') }`;
 
     if (select.limit)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}${renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
+      alreadyRendered += `${ continueIndent(alreadyRendered, env) }${ renderLimit(select.limit, env.withSubPath([ 'limit' ])) }`;
 
     return alreadyRendered;
   }
@@ -946,7 +944,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       return ' ';
     }
     // Otherwise, start new line and indent normally
-    return `\n${env.withIncreasedIndent().indent}`;
+    return `\n${ env.withIncreasedIndent().indent }`;
   }
 
   /**
@@ -959,11 +957,11 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
   function renderLimit( limit, env ) {
     let result = '';
     if (limit.rows !== undefined)
-      result += `limit ${renderExpr(limit.rows, env.withSubPath([ 'rows' ]))}`;
+      result += `limit ${ renderExpr(limit.rows, env.withSubPath([ 'rows' ])) }`;
 
     if (limit.offset !== undefined) {
-      const indent = result !== '' ? `\n${env.withIncreasedIndent().indent}` : '';
-      result += `${indent}offset ${renderExpr(limit.offset, env.withSubPath([ 'offset' ]))}`;
+      const indent = result !== '' ? `\n${ env.withIncreasedIndent().indent }` : '';
+      result += `${ indent }offset ${ renderExpr(limit.offset, env.withSubPath([ 'offset' ])) }`;
     }
 
     return result;
@@ -980,10 +978,10 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
   function renderOrderByEntry( entry, env ) {
     let result = renderExpr(entry, env);
     if (entry.sort)
-      result += ` ${entry.sort}`;
+      result += ` ${ entry.sort }`;
 
     if (entry.nulls)
-      result += ` nulls ${entry.nulls}`;
+      result += ` nulls ${ entry.nulls }`;
 
     return result;
   }
@@ -999,7 +997,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
   function renderParameter( parName, par, env ) {
     if (par.notNull === true || par.notNull === false)
       info('query-ignoring-param-nullability', env.path, { '#': 'std' });
-    return `${env.indent + formatParamIdentifier(parName, env.path)} : ${renderTypeReference(par, env)}`;
+    return `${ env.indent + formatParamIdentifier(parName, env.path) } : ${ renderTypeReference(par, env) }`;
   }
 
   /**
@@ -1015,10 +1013,10 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (art.kind === 'aspect' || art.kind === 'type' && !hdbcdsNames || art.kind === 'type' && hdbcdsNames && !art.elements)
       return '';
     let result = '';
-    result += `${env.indent + (art.kind)} ${renderArtifactName(artifactName, env, true)}`;
+    result += `${ env.indent + (art.kind) } ${ renderArtifactName(artifactName, env, true) }`;
     if (art.includes) {
       // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name, env)).join(', ')}`;
+      result += ` : ${ art.includes.map(name => renderAbsoluteNameWithQuotes(name, env)).join(', ') }`;
     }
     if (art.elements && !art.type) {
       const childEnv = env.withIncreasedIndent();
@@ -1027,11 +1025,11 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       for (const name in art.elements)
         result += renderElement(name, art.elements[name], childEnv.withSubPath([ 'elements', name ]));
 
-      result += `${env.indent}};\n`;
+      result += `${ env.indent }};\n`;
     }
     else {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env)};\n`;
+      result += ` : ${ renderTypeReference(art, env) };\n`;
     }
     return result;
   }
@@ -1050,7 +1048,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // Array type: Render items instead
     if (elm.items && !elm.type) {
       // HANA CDS does not support keyword many
-      let rc = `array of ${renderTypeReference(elm.items, env.withSubPath([ 'items' ]))}`;
+      let rc = `array of ${ renderTypeReference(elm.items, env.withSubPath([ 'items' ])) }`;
       if (elm.items.notNull != null)
         rc += elm.items.notNull ? ' not null' : ' null';
       return rc;
@@ -1062,7 +1060,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // Anonymous structured type
     if (!elm.type && !elm.value) {
       if (!elm.elements)
-        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
+        throw new ModelError(`Missing type of: ${ JSON.stringify(elm) }`);
 
       result += '{\n';
       const childEnv = env.withIncreasedIndent();
@@ -1071,7 +1069,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       for (const name in elm.elements)
         result += renderElement(name, elm.elements[name], childEnv.withSubPath([ 'elements', name ]), null, dontRenderKeyForNestedElement);
 
-      result += `${env.indent}}`;
+      result += `${ env.indent }}`;
       return result;
     }
 
@@ -1082,7 +1080,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (elm.type?.ref) {
       // Reference to another element
       // For HANA CDS, we need a 'type of'
-      result += `type of ${renderAbsolutePath(elm.type, env.withSubPath([ 'type' ]))}`;
+      result += `type of ${ renderAbsolutePath(elm.type, env.withSubPath([ 'type' ])) }`;
     }
     else if (isBuiltinType(elm.type)) {
       // If we get here, it must be a named type
@@ -1098,7 +1096,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       if (!elm.value.stored)
         throw new CompilerAssertion('Found calculated element on-read in rendering; should have been replaced!');
       message('def-unsupported-calc-elem', env.path, { '#': 'hdbcds' });
-      result += ` GENERATED ALWAYS AS ${renderExpr(elm.value, env.withSubPath([ 'value' ]))}`;
+      result += ` GENERATED ALWAYS AS ${ renderExpr(elm.value, env.withSubPath([ 'value' ])) }`;
       return result;
     }
 
@@ -1112,7 +1110,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    */
   function renderAssociationType( elm, env ) {
     // Type, cardinality and target
-    let result = `association${renderCardinality(elm.cardinality)} to `;
+    let result = `association${ renderCardinality(elm.cardinality) } to `;
 
     // normal target or named aspect
     if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {
@@ -1131,7 +1129,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
 
     // ON-condition (if any)
     if (elm.on) {
-      result += ` on ${renderExpr(elm.on, env.withSubPath([ 'on' ]))}`;
+      result += ` on ${ renderExpr(elm.on, env.withSubPath([ 'on' ])) }`;
     }
     else if (elm.targetAspect?.elements) { // anonymous aspect
       const childEnv = env.withIncreasedIndent();
@@ -1139,12 +1137,12 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       for (const name in elm.targetAspect.elements)
         result += renderElement(name, elm.targetAspect.elements[name], childEnv.withSubPath([ 'targetAspect', 'elements', name ]));
 
-      result += `${env.indent}}`;
+      result += `${ env.indent }}`;
     }
 
     // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
     if (elm.keys && !elm.on)
-      result += ` { ${Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env.withSubPath([ 'keys', name ]))).join(', ')} }`;
+      result += ` { ${ Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env.withSubPath([ 'keys', name ]))).join(', ') } }`;
 
     return result;
   }
@@ -1203,27 +1201,27 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     else if (typeof s === 'object') {
       // Sanity check
       if (!s.func && !s.id)
-        throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
+        throw new ModelError(`Unknown path step object: ${ JSON.stringify(s) }`);
 
       // Not really a path step but an object-like function call
       if (s.func)
-        return `${s.func}(${renderArgs(s, '=>', env)})`;
+        return `${ s.func }(${ renderArgs(s, '=>', env) })`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${formatIdentifier(s.id)}`;
+      let result = `${ formatIdentifier(s.id) }`;
       if (s.args) {
         // View parameters
-        result += `(${renderArgs(s, ':', env)})`;
+        result += `(${ renderArgs(s, ':', env) })`;
       }
       if (s.where) {
         // Filter, possibly with cardinality
-        const cardinality = s.cardinality ? `${s.cardinality.max}: ` : '';
-        result += `[${cardinality}${renderExpr(s.where, env.withSubPath([ 'where' ]))}]`;
+        const cardinality = s.cardinality ? `${ s.cardinality.max }: ` : '';
+        result += `[${ cardinality }${ renderExpr(s.where, env.withSubPath([ 'where' ])) }]`;
       }
       return result;
     }
 
-    throw new ModelError(`Unknown path step: ${JSON.stringify(s)} at ${JSON.stringify(env.path)}`);
+    throw new ModelError(`Unknown path step: ${ JSON.stringify(s) } at ${ JSON.stringify(env.path) }`);
   }
 
   /**
@@ -1241,7 +1239,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       case 'date':
       case 'time':
       case 'timestamp':
-        return `${x.literal}'${x.val}'`;
+        return `${ x.literal }'${ x.val }'`;
       case 'string':
         return renderStringForHdbcds(x.val);
       case 'object':
@@ -1250,7 +1248,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
 
         // otherwise fall through to
       default:
-        throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+        throw new ModelError(`Unknown literal or type: ${ JSON.stringify(x) }`);
     }
   }
 
@@ -1317,13 +1315,13 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
 
     const prefix = x.param ? ':' : '';
     const ref = x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.');
-    return `${prefix}${ref}`;
+    return `${ prefix }${ ref }`;
   }
 
   function renderTypeRef( x, env ) {
     const prefix = x.param ? ':' : '';
     const ref = x.ref.map((step, index) => renderPathStep(step, index, env.withSubPath([ 'ref', index ]))).join('.');
-    return `${prefix}${ref}`;
+    return `${ prefix }${ ref }`;
   }
 
   /**
@@ -1345,12 +1343,12 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     else if (typeof args === 'object') {
       // if this is a function param which is not a reference to the model, we must not quote it
       return Object.keys(args)
-        .map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env.withSubPath([ 'args', key ]))}`)
+        .map(key => `${ node.func ? key : formatIdentifier(key) } ${ sep } ${ renderExpr(args[key], env.withSubPath([ 'args', key ])) }`)
         .join(', ');
     }
 
 
-    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
+    throw new ModelError(`Unknown args: ${ JSON.stringify(args) }`);
   }
 
   /**
@@ -1365,15 +1363,15 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
 
     let result = '[';
     if (card.src !== undefined)
-      result += `${card.src}, `;
+      result += `${ card.src }, `;
 
     if (card.min !== undefined)
-      result += `${card.min}..`;
+      result += `${ card.min }..`;
 
     if (card.max !== undefined)
       result += card.max;
 
-    return `${result}]`;
+    return `${ result }]`;
   }
 
   /**
@@ -1400,8 +1398,8 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    * @returns {string} Rendered foreign key
    */
   function renderForeignKey( fKey, env ) {
-    const alias = fKey.as ? (` as ${formatIdentifier(fKey.as)}`) : '';
-    return `${renderExpr(fKey, env)}${alias}`;
+    const alias = fKey.as ? (` as ${ formatIdentifier(fKey.as) }`) : '';
+    return `${ renderExpr(fKey, env) }${ alias }`;
   }
 
   /**
@@ -1426,7 +1424,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (elm.srid !== undefined)
       params.push(elm.srid);
 
-    return params.length === 0 ? '' : `(${params.join(', ')})`;
+    return params.length === 0 ? '' : `(${ params.join(', ') })`;
   }
 
   /**
@@ -1471,7 +1469,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
 
     // Another special case: If we are rendering for HANA, and if the first path step is an artifact that is
     // 'implemented in' something, we need to treat the whole name like a top-level id.
-    if (csn.definitions[absName] && csn.definitions[absName]['@cds.persistence.exists']) {
+    if (csn.definitions[absName]?.['@cds.persistence.exists']) {
       env.topLevelAliases[absName] = {
         quotedName: quoteAbsoluteNameAsId(absName),
         quotedAlias: quoteId(createTopLevelAliasName(absName)),
@@ -1499,11 +1497,11 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       const prefix = absName.slice(0, absName.length - realName.length);
       const nonTopLevelPrefix = prefix.slice(topLevelName.length + 1, -1); // also trim off .
       if (nonTopLevelPrefix)
-        return `${topLevelAlias.quotedAlias}.${quotePathString(nonTopLevelPrefix)}.${quotePathString(realName)}`;
+        return `${ topLevelAlias.quotedAlias }.${ quotePathString(nonTopLevelPrefix) }.${ quotePathString(realName) }`;
 
-      return `${topLevelAlias.quotedAlias}.${quotePathString(realName)}`;
+      return `${ topLevelAlias.quotedAlias }.${ quotePathString(realName) }`;
     }
-    return `${topLevelAlias.quotedAlias}.${quotePathString(realName)}`;
+    return `${ topLevelAlias.quotedAlias }.${ quotePathString(realName) }`;
   }
 
   /**
@@ -1516,7 +1514,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    */
   function createTopLevelAliasName( topLevelName ) {
     // FIXME: We should rather check for conflicts than just using something obscure like this ...
-    return `__${topLevelName.replace(/::/g, '__').replace(/\./g, '_')}`;
+    return `__${ topLevelName.replace(/::/g, '__').replace(/\./g, '_') }`;
   }
 
   /**
@@ -1531,10 +1529,10 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     Object.keys(env.topLevelAliases)
       .filter(name => env.topLevelAliases[name].quotedAlias !== formatIdentifier(uppercaseAndUnderscore(artifactName))) // avoid "using FOO as FOO" in FOO.cds
       .forEach((name) => {
-        const nativeObjectExists = csn.definitions[name] && hasAnnotationValue(csn.definitions[name], '@cds.persistence.exists');
+        const nativeObjectExists = csn.definitions[name]?.['@cds.persistence.exists'];
         if (!plainNames && nativeObjectExists)
           checkForNameClashesWithNativeObject(name);
-        distinct[`using ${env.topLevelAliases[name].quotedName} as ${env.topLevelAliases[name].quotedAlias};\n`] = '';
+        distinct[`using ${ env.topLevelAliases[name].quotedName } as ${ env.topLevelAliases[name].quotedAlias };\n`] = '';
       });
     /**
      * If we generate a `using <native object> from <bar>` clause,
@@ -1560,7 +1558,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
         return isContextRendered(artName);
       if ([ 'action', 'function', 'event' ].includes(art.kind) || options.sqlMapping !== 'hdbcds' && art.kind === 'type')
         return false;
-      return !(hasAnnotationValue(art, '@cds.persistence.exists') || hasAnnotationValue(art, '@cds.persistence.skip'));
+      return !(art['@cds.persistence.exists'] || hasPersistenceSkipAnnotation(art));
     }
 
     /**
@@ -1575,7 +1573,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       const subArtifacts = getSubArtifacts(contextName);
       return Object.entries(subArtifacts).some(([ artName, art ]) => {
         if (art.kind === 'context')
-          return isContextRendered(`${contextName}.${artName}`);
+          return isContextRendered(`${ contextName }.${ artName }`);
         return isArtifactRendered(art, artName);
       });
     }
@@ -1591,7 +1589,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       usingName = usingName.replace(/"/g, '');
       if (usingName.indexOf('::') !== -1) {
         const parts = usingName.split('::');
-        return `${parts[0]}.${parts[1].split('.')[0]}`;
+        return `${ parts[0] }.${ parts[1].split('.')[0] }`;
       }
       return usingName.split('.')[0];
     }
@@ -1617,7 +1615,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // The top-level artifact's parent would be the namespace (if any)
     const namespace = getNamespace(csn, topLevelName);
     if (namespace)
-      return `${env.indent}namespace ${quotePathString(namespace)};\n`;
+      return `${ env.indent }namespace ${ quotePathString(namespace) };\n`;
 
     return '';
   }
@@ -1666,7 +1664,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    * @returns {HdbcdsRenderEnvironment} New environment with added prefix
    */
   function addNamePrefix( env, id ) {
-    return env.cloneWith({ namePrefix: `${env.namePrefix + quoteId(id)}.` });
+    return env.cloneWith({ namePrefix: `${ env.namePrefix + quoteId(id) }.` });
   }
 
   /**
@@ -1692,7 +1690,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     const resultingName = getResultingName(csn, options.sqlMapping, absPath);
 
     if (hdbcdsNames && namespace)
-      return `${quotePathString(namespace)}::${quotePathString(resultingName.slice(namespace.length + 2))}`;
+      return `${ quotePathString(namespace) }::${ quotePathString(resultingName.slice(namespace.length + 2)) }`;
 
     return quotePathString(resultingName);
   }
@@ -1727,11 +1725,11 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (hdbcdsNames) {
       const namespace = getNamespace(csn, absName);
       if (namespace) {
-        const id = `${namespace}::${resultingName.substring(namespace.length + 2)}`;
-        return `"${id.replace(/"/g, '""')}"`;
+        const id = `${ namespace }::${ resultingName.substring(namespace.length + 2) }`;
+        return `"${ id.replace(/"/g, '""') }"`;
       }
     }
-    return `"${resultingName.replace(/"/g, '""')}"`;
+    return `"${ resultingName.replace(/"/g, '""') }"`;
   }
 
   /**