@sap/cds-compiler 5.7.4 → 5.8.2

package/lib/parsers/XprTree.js

@@ -0,0 +1,206 @@
+// Create a hierarchical expression tree from an `xpr` array
+
+// See ./CdlGrammar.js for the operator precedences.
+
+
+'use strict';
+
+
+const prefixOperators = {     // see <prec=…,prefix> in `expression` of CdlGrammar
+  __proto__: null,
+  new: 33,                  // special in CDL (only before ref), clarify with `.`
+  exists: 33,               // special in CDL
+  '+': 30,                  // note: binary `.` and `over` have higher precedence!
+  '-': 30,
+  not: 8,
+};
+
+const binaryOperators = {
+  __proto__: null,
+  '.': 37,                      // nary
+  over: 35,                     // TODO: only after ref with arg?
+  '*': 24,                      // nary
+  '/': 24,
+  '+': 22,
+  '-': 22,
+  '||': 20,
+  '=': 10,                      // with ANY/SOME/ALL
+  '<>': 10,
+  '>': 10,
+  '>=': 10,
+  '<': 10,
+  '<=': 10,
+  '!=': 10,
+  '==': 10,                     // not supported yet in CDL or backends
+  and: 4,
+  or: 2,
+  // with second token or ternary (in the grammar, these ops have prec=10, but
+  // also assoc=none, i.e. could not be used without parens together):
+  is: 11,                       // is binary op here, not postfix
+  in: 13,
+  between: 13,
+  like: 13,
+  not: 15,                      // specially handled
+};
+
+const secondTokens = {
+  // the value is the precedence of the first token listed in `binaryOperators`
+  __proto__: null,
+  any: 10,                      // for `=` etc
+  some: 10,
+  all: 10,
+  not: 11,                      // for `is`
+  between: 15,                  // for `not`
+  in: 15,
+  like: 15,
+};
+
+const naryOperators = {
+  __proto__: null,
+  '.': true,                    // CSN-tree really as left-assoc binary?
+  '*': true,
+  '/': true,
+  '+': true,
+  '-': true,
+  '||': true,
+  and: true,
+  or: true,
+  between: 'and',
+  like: 'escape',
+};
+
+
+class XprTree {
+  nodes;                        // array value of CSN property `xpr`/`where`/…
+  nodeIdx = 0;
+  args;        // corresponding XSN array, with already tree-like sub expressions
+  location;
+
+  constructor( nodes, args, location ) {
+    this.nodes = nodes;
+    this.args = args;
+    this.location = location;
+  }
+
+  tree() {
+    const args = [];
+    const { length } = this.args;
+    while (this.nodeIdx < length) {
+      const expr = this.expression( -1 );
+      if (expr)
+        args.push( expr );
+    }
+    return (args.length === 1) ? args[0] : this.create( args );
+  }
+
+  expression( parentPrec ) {
+    let append;
+    let naryOp;
+    let args;
+
+    // Term = ref/val or unary operator with expression as operand
+    let expr = this.args[this.nodeIdx];
+    if (!expr)
+      return expr;
+    let node = this.nodes[this.nodeIdx++];
+    if (typeof node === 'string') {
+      const prec = prefixOperators[node]; // <prec=…,prefix> in CdlGrammar
+      if (prec) {
+        const right = this.expression( prec - 1 );
+        if (!right)
+          return expr;
+        expr = this.create( [ expr, right ] );
+      }
+      else if (node === 'case') {
+        expr = this.caseWhen( [ expr ] );
+      }
+      else {             // unknown token (keyword in CDL):
+        return expr;            // …from fns with irregular syntax?
+        // also handles `null` as right side of `is` in `is null`
+        // TODO: `(` from CSN v0.x ?
+        // It is important not to handle binary ops after this, because otherwise
+        // we would not properly parse functions with irregular syntax
+      }
+    }
+
+    node = this.nodes[this.nodeIdx];
+    while (typeof node === 'string') {
+      const prec = binaryOperators[node]; // <prec=…> in CdlGrammar
+      if (!prec || parentPrec >= prec)
+        return expr;
+
+      // handle n-ary operators including ternary
+      append = (typeof naryOp === 'string')
+        ? !append && naryOp     // `and` after `between`, `escape` after `like`˛
+        : naryOp && node;       // nary operators like `+`
+      if (node === append) {
+        args.push( this.args[this.nodeIdx++] );
+      }
+      else {
+        naryOp = naryOperators[node];
+        append = false;
+        args = [ expr, this.args[this.nodeIdx++] ];
+        expr = this.create( args, naryOp === true );
+      }
+
+      // handle second token of operator:
+      const second = this.nodes[this.nodeIdx];
+      if (typeof second === 'string' && secondTokens[second] === prec && !append) {
+        args.push( this.args[this.nodeIdx++] );
+        if (node === 'not')
+          naryOp = naryOperators[second];
+      }
+
+      // the right side
+      const right = this.expression( prec );
+      if (!right)                   // incomplete
+        return expr;
+      args.push( right );
+      node = this.nodes[this.nodeIdx];
+      // TODO: simplyfy between-and and like-escape with pushTokenAndExpression()
+    }
+    return expr;
+  }
+
+  caseWhen( args ) {
+    const expr = this.create( args );
+    let node = this.nodes[this.nodeIdx];
+    if (node !== 'when') {
+      const value = this.expression( -1 );
+      if (value)
+        args.push( value );
+      node = this.nodes[this.nodeIdx];
+    }
+    while (node === 'when') {
+      node = this.pushTokenAndExpression( args );
+      if (node === 'then')
+        node = this.pushTokenAndExpression( args );
+    }
+    if (node === 'else')
+      node = this.pushTokenAndExpression( args );
+    if (node === 'end')
+      args.push( this.args[this.nodeIdx++] );
+    return expr;
+  }
+
+  pushTokenAndExpression( args ) {
+    args.push( this.args[this.nodeIdx++] );
+    const value = this.expression( -1 );
+    if (value)
+      args.push( value );
+    return this.nodes[this.nodeIdx];
+  }
+
+  create( args, isNary = false ) {
+    // could be adopted for CSN expression tree
+    return {
+      op: { val: (isNary ? 'nary' : 'ixpr'), location: this.location },
+      location: this.location,
+      args,
+    };
+  }
+}
+
+module.exports = {
+  xprAsTree: ( nodes, args, location ) => (new XprTree( nodes, args, location )).tree(),
+};

package/lib/render/toCdl.js

@@ -124,7 +124,7 @@ function csnToCdl( csn, options, msg ) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
         const env = createEnv({ path: [ 'vocabularies', name ] });
-        const sourceStr = renderTypeOrAnnotation(name, anno, env, 'annotation');
+        const sourceStr = renderArtifact(name, anno, env, 'annotation');
         result += `${sourceStr}\n`;
       }
     }
@@ -452,7 +452,7 @@ function csnToCdl( csn, options, msg ) {
       case 'entity':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
-        return renderEntity(artifactName, art, env);
+        return renderArtifact(artifactName, art, env);
       case 'aspect':
         return renderAspect(artifactName, art, env);
 
@@ -460,16 +460,16 @@ function csnToCdl( csn, options, msg ) {
       case 'service':
         return renderContextOrService(artifactName, art, env);
 
-      case 'type':
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
-        return renderTypeOrAnnotation(artifactName, art, env);
+        return renderArtifact(artifactName, art, env, 'annotation');
 
       case 'action':
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
 
+      case 'type':
       case 'event':
-        return renderEvent(artifactName, art, env);
+        return renderArtifact(artifactName, art, env);
 
       default:
         throw new ModelError(`to.cdl: Unknown artifact kind: '${art.kind}' at ${JSON.stringify(env.path)}`);
@@ -477,30 +477,70 @@ function csnToCdl( csn, options, msg ) {
   }
 
   /**
+   * TODO: Also use this function for other kinds such as entities, aspects and views.
+   *
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
+   * @param {string} [overrideKind] If set, override the artifact kind.
    */
-  function renderEvent( artifactName, art, env ) {
+  function renderArtifact( artifactName, art, env, overrideKind ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    let kind = overrideKind || art.$syntax === 'aspect' && 'aspect' || art.kind;
+    if (art.abstract)
+      kind = `abstract ${ kind }`;
     const normalizedArtifactName = renderArtifactName(artifactName, env);
-    result += `${env.indent}event ${normalizedArtifactName}`;
-    if (art.includes)
-      result += renderIncludes(art.includes, env);
-    if (art.query || art.projection) {
+    result += `${env.indent}${kind} ${normalizedArtifactName}`;
+
+    if (art.params)
+      result += renderParameters(art, env);
+
+    let isDirectStruct = false;
+    const isQuery = art.query || art.projection;
+    if (isQuery) {
       result += ' : ';
-      // events (should) only support "projections"
+      // types/events (should) only support "projections"
       result += renderQuery(getNormalizedQuery(art).query, true, 'projection',
                             env.withSubPath([ art.projection ? 'projection' : 'query' ]));
-      result += ';\n';
     }
-    else if (art.type) {
-      // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
+    else {
+      const type = renderTypeReferenceAndProps(art, env);
+      if (type) {
+        isDirectStruct = type.startsWith('{');
+
+        if (art.includes?.length && isDirectStruct) {
+          // We can only render includes, if the type is directly structured. Otherwise, we would
+          // render e.g. `type T : Include : T2;`, which is invalid.  We use `extend` in such cases.
+          result += renderIncludes(art.includes, env);
+        }
+
+        // For nicer output, no colon if unnamed structure is used.
+        result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
+      }
+      else {
+        msg.warning('syntax-missing-type', env.path, { '#': art.kind, name: artifactName }, {
+          std: 'Missing type for definition $(NAME); can\'t be represented in CDL',
+          entity: 'Missing elements for entity $(NAME); can\'t be represented in CDL',
+        });
+      }
     }
-    else if (art.elements) {
-      result += ` ${renderElements(art, env)};\n`;
+
+    if (art.actions) {
+      if (!isQuery && !isDirectStruct) {
+        // If there are no elements nor query, but actions, CDL syntax requires braces.
+        result += ' { }';
+      }
+      result += renderActionsAndFunctions(art, env);
     }
+
+    result += ';\n';
+
+    if (art.includes?.length && !isDirectStruct) {
+      // If we're not a directly structured type, render the `includes` as `extend`
+      // statements directly below the type definition.
+      result += renderExtendStatement(artifactName, { includes: art.includes }, env);
+    }
+
     return result;
   }
 
@@ -516,35 +556,6 @@ function csnToCdl( csn, options, msg ) {
     return `${result} {};\n`;
   }
 
-  /**
-   * Render a (non-projection, non-view) entity. Return the resulting source string.
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderEntity( artifactName, art, env ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += env.indent + (art.abstract ? 'abstract ' : '');
-    result += `entity ${renderArtifactName(artifactName, env)}`;
-
-    if (art.params)
-      result += renderParameters(art, env);
-    if (art.includes)
-      result += renderIncludes(art.includes, env);
-
-    if (art.elements)
-      result += ` ${renderElements(art, env)}`;
-    else if (art.actions)
-      // if there are no elements, but actions, CDL syntax requires braces.
-      result += ' { }';
-
-    result += `${renderActionsAndFunctions(art, env)};\n`;
-
-    return result;
-  }
-
   /**
    * Render an aspect. Return the resulting source string.
    * Behaves very similar to renderEntity, _except_ that aspects are
@@ -938,8 +949,10 @@ function csnToCdl( csn, options, msg ) {
     // No expression to render for { * } as alias
     let result = (obj.as && obj.expand && !obj.ref) ? '' : exprRenderer.renderExpr(withoutCast(obj), env);
 
+    const isAnonymousExpand = (obj.expand && !obj.ref);
+
     // s as alias { * }
-    if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
+    if (obj.as && !isAnonymousExpand)
       result += renderAlias(obj.as, env);
 
     // We found a leaf - no further drilling
@@ -971,7 +984,7 @@ function csnToCdl( csn, options, msg ) {
       result += ` excluding { ${obj.excluding.join(',')} }`;
 
     // { * } as expand
-    if (!obj.ref && obj.as)
+    if (obj.as && isAnonymousExpand)
       result += renderAlias(obj.as, env);
 
     return result;
@@ -1268,47 +1281,6 @@ function csnToCdl( csn, options, msg ) {
     return result;
   }
 
-  /**
-   * Render a type (derived or structured) or an annotation decl with name 'artifactName'.
-   * Return the resulting source string.
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @param {String} [artType] Used for rendering `csn.vocabularies`, as the annotations there do not have a kind.
-   * @return {string}
-   */
-  function renderTypeOrAnnotation( artifactName, art, env, artType ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName, env)}`;
-
-    const type = renderTypeReferenceAndProps(art, env);
-    const isDirectStruct = type?.startsWith('{');
-    if (art.includes?.length && isDirectStruct)
-      // We can only render includes, if the type is directly structured. Otherwise,  we would
-      // render e.g. `type T : Include : T2;`, which is invalid.  We use `extend` in such cases.
-      result += renderIncludes(art.includes, env);
-
-    if (type) {
-      // For nicer output, no colon if unnamed structure is used.
-      result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
-    }
-    else {
-      msg.warning('syntax-missing-type', env.path, { name: artifactName },
-                  'Missing type for definition $(NAME); can\'t be represented in CDL');
-    }
-
-    result += ';\n';
-
-    if (art.includes?.length && !isDirectStruct) {
-      // If we're not a directly structured type, render the `includes` as `extend`
-      // statements directly below the type definition.
-      result += renderExtendStatement(artifactName, { includes: art.includes }, env);
-    }
-
-    return result;
-  }
-
   /**
    * Render a reference to a type used by 'artifact' (named or inline) and (element) properties
    * such as `not null` and `default <xpr>`.

package/lib/render/toSql.js

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