@sap/cds-compiler 4.5.0 → 4.6.2

package/lib/json/to-csn.js

@@ -206,6 +206,10 @@ const typeProperties = [
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
   '$typeArgs', // for unresolved type arguments, e.g. through parseCql
 ];
+// Properties which cause a `cast` property to be rendered
+const castProperties = [
+  'target', 'enum', 'items', 'type',
+];
 
 const csnDictionaries = [
   'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
@@ -1495,7 +1499,9 @@ function addElementAsColumn( elem, cols ) {
     // elements of sub queries (in expr) are hidden (not set via Object.assign):
     if (!expr.cast && expr.elements)
       setHidden( col, 'elements', expr.elements );
-    if (elem.type && !elem.type.$inferred || elem.target && !elem.target.$inferred)
+    // CDL-style cast with explicit type properties
+    if (castProperties.findIndex(prop => (elem[prop] &&
+        !elem[prop].$inferred && !elem[prop][$inferred])) > -1)
       cast( col, elem );
   }
   finally {

package/lib/language/antlrParser.js

@@ -78,9 +78,11 @@ class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
 function initTokenRewrite( recognizer, ts ) { // ts = tokenStream
   ts.DOTbeforeBRACE = Parser.DOTbeforeBRACE;
   ts.BRACE = tokenTypeOf( recognizer, "'{'" );
+  ts.BRACE_CLOSE = tokenTypeOf( recognizer, "'}'" );
   ts.DOT = tokenTypeOf( recognizer, "'.'" );
   ts.ASTERISK = tokenTypeOf( recognizer, "'*'" );
   ts.AT = tokenTypeOf( recognizer, "'@'" );
+  ts.SEMICOLON = tokenTypeOf( recognizer, "';'" );
   ts.NEW = Parser.NEW;
   ts.Identifier = Parser.Identifier;
   ts.PAREN = tokenTypeOf( recognizer, "'('" );
@@ -90,7 +92,22 @@ function initTokenRewrite( recognizer, ts ) { // ts = tokenStream
     if (ts.DOT && ts.DOTbeforeBRACE)
       recognizer.tokenRewrite[ts.DOTbeforeBRACE - Parser.Identifier] = ts.DOT;
   }
-  // console.log( ts.DOTbeforeBRACE, ts.BRACE, ts.DOT, recognizer.tokenRewrite );
+}
+
+function initCodeCompletionTokenArrays( parser ) {
+  // Set of top-level keywords used for code completion after token '}'
+  // belonging to a top-level definition
+  const startRuleIndex = parser.ruleNames.indexOf('start');
+  const startState = parser.atn.ruleToStartState[startRuleIndex].stateNumber;
+  const tokens = parser.atn.nextTokens(parser.atn.states[startState]);
+  tokens.removeOne(parser.symbolicNames.indexOf('NAMESPACE'));
+  tokens.removeOne(parser.symbolicNames.indexOf('HideAlternatives'));
+
+  parser.topLevelKeywords = [];
+  for (const interval of tokens.intervals) {
+    for (let i = interval.start; i < interval.stop; i++)
+      parser.topLevelKeywords.push(i);
+  }
 }
 
 function tokenTypeOf( recognizer, literalName ) {
@@ -123,6 +140,7 @@ function parse( source, filename = '<undefined>.cds',
   parser.$messageFunctions = messageFunctions;
 
   initTokenRewrite( parser, tokenStream );
+  initCodeCompletionTokenArrays(parser);
   // comment the following 2 lines if you want to output the parser errors directly:
   parser.messageErrorListener = errorListener;
   parser._errHandler = new errorStrategy.KeywordErrorStrategy();

package/lib/language/errorStrategy.js

@@ -447,16 +447,33 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
     for (let j = v.start; j < v.stop; j++) {
       // a generic keyword as such does not appear in messages, only its replacements,
       // which are function name and argument position dependent:
-      if (j === pc.GenericExpr)
+      if (j === pc.GenericExpr) {
         names.push( ...recognizer.$genericKeywords.expr );
-      else if (j === pc.GenericSeparator)
+      }
+      else if (j === pc.GenericSeparator) {
         names.push( ...recognizer.$genericKeywords.separator );
-      else if (j === pc.GenericIntro)
+      }
+      else if (j === pc.GenericIntro) {
         names.push( ...recognizer.$genericKeywords.introMsg );
+      }
+      else if (j === pc.SemicolonTopLevel) {
+        // We only insert a semikolon (i.e. make it optional) after a closing brace.
+        // If the previous token is not `}`, don't propose these keywords, as ';' is required.
+        if (recognizer._input.LA(-1) === recognizer._input.BRACE_CLOSE) {
+          const name = recognizer.topLevelKeywords.map(i => expected
+            .elementName(recognizer.literalNames, recognizer.symbolicNames, i));
+          names.push(...name);
+          if (recognizer._ctx.outer?.kind !== 'source') {
+            if (names.includes('<EOF>'))
+              names.splice(names.indexOf('<EOF>'), 1);
+          }
+        }
+      }
       // other expected tokens usually appear in messages, except the helper tokens
       // which are used to solve ambiguities via the parser method setLocalToken():
-      else if (j !== pc.HelperToken1 && j !== pc.HelperToken2)
+      else if (j !== pc.HelperToken1 && j !== pc.HelperToken2) {
         names.push( expected.elementName(recognizer.literalNames, recognizer.symbolicNames, j ) );
+      }
     }
   }
   // The parser method excludeExpected() additionally removes some tokens from the message:

package/lib/language/genericAntlrParser.js

@@ -1247,30 +1247,28 @@ function finalizeDictOrArray( dict ) {
 }
 
 function insertSemicolon() {
-  // hand-selected keyword list: first() set of `artifactDefOrExtend`
-  const allowedKeywords = [ this.constructor.ACTION, this.constructor.ABSTRACT,
-    this.constructor.ANNOTATE, this.constructor.ANNOTATION, this.constructor.ASPECT,
-    this.constructor.CONTEXT, this.constructor.DEFINE, this.constructor.ENTITY,
-    this.constructor.EOF, this.constructor.EVENT, this.constructor.EXTEND,
-    this.constructor.FUNCTION, this.constructor.SERVICE,
-    this.constructor.TYPE, this.constructor.VIEW, this.literalNames.indexOf( "'@'" ) ];
-
   const currentToken = this._input.tokens[this._input.index];
+  const requireSemicolon = this.topLevelKeywords.includes(currentToken.type);
 
-  if (allowedKeywords.includes(currentToken.type)) {
+  if (requireSemicolon) {
+    this.noAssignmentInSameLine();
     const prev = this._input.LT(-1);
     const t = CommonTokenFactory.create(
-      currentToken.source, this.literalNames.indexOf( "';'" ),
-      '', currentToken.channel,
+      currentToken.source,
+      this.literalNames.indexOf( "';'" ),
+      '', antlr4.Token.DEFAULT_CHANNEL,
       prev.stop, prev.stop,
       prev.line, prev.column
     );
+
     t.tokenIndex = prev.tokenIndex + 1;
+
     this._input.tokens.splice(t.tokenIndex, 0, t);
 
     // Update tokenIndex: There could have been comments between two non-hidden tokens.
     for (let tokenIndex = t.tokenIndex + 1; tokenIndex < this._input.tokens.length; tokenIndex++)
       this._input.tokens[tokenIndex].tokenIndex += 1;
+
     this._input.index = t.tokenIndex;
   }
 }

package/lib/main.d.ts

@@ -27,9 +27,9 @@ declare namespace compiler {
     messages?: object[]
     /**
      * Dictionary of message-ids and their reclassified severity.  This option
-     * can be used to increase the severity of messages.  The compiler will
-     * ignore decreased severities as this may lead to issues during
-     * compilation otherwise.
+     * can be used to increase the severity of messages.  The compiler may
+     * ignore decreased severities of error messages as this may lead to issues
+     * during compilation otherwise.
      */
     severities?: { [messageId: string]: MessageSeverity}
     /**
@@ -1023,6 +1023,31 @@ declare namespace compiler {
       function migration(csn: CSN, options: SqlOptions, beforeImage: CSN): SqlMigrationResult;
     }
 
+    /**
+     * Renders the given CSN into EDM in the JSON format _and_ XML format.
+     * That is, it is a combination of `to.edm()` and `to.edmx()`.
+     * Requires `options.service` to be set.
+     *
+     * Not to be confused with `for.odata()`, which returns an OData transformed CSN.
+     *
+     * @returns An object `'<protocol>': object` where the value is `'<serviceName>': object` entry
+     *          which consists of `{edmx: string, edm?: object}`.
+     * @since v4.6.0
+     */
+    function odata(csn: CSN, options?: ODataOptions): Record<string, object>;
+    namespace odata {
+      /**
+       * Renders the given CSN into EDM in JSON format _and_ XML format for each service.
+       * That is, it is a combination of `to.edm.all()` and `to.edmx.all()`.
+       * If `options.serviceNames` is not set, all services will be rendered.
+       *
+       * @returns A map of `'<protocol>': object` where each entry is `'<serviceName>': object` entries where
+       *          each entry consists of `{edmx: string, edm?: object}`.
+       * @since v4.6.0
+       */
+      function all(csn: CSN, options: ODataOptions): Record<string, object>;
+    }
+
     /**
      * Renders the given CSN into EDM (JSON format).  Requires `options.service` to be set.
      *

package/lib/main.js

@@ -158,6 +158,9 @@ module.exports = {
     edmx: Object.assign((...args) => snapi.edmx(...args), {
       all: (...args) => snapi.edmx.all(...args)
     }),
+    odata: Object.assign((...args) => snapi.odata2(...args), {
+      all: (...args) => snapi.odata2.all(...args)
+    }),
   },
   // Convenience for hdbtabledata calculation in @sap/cds
   getArtifactCdsPersistenceName: (...args) => csnUtils.getArtifactDatabaseNameOf(...args),

package/lib/model/csnRefs.js

@@ -613,7 +613,7 @@ function csnRefs( csn, universalReady ) {
           return resolvePath( path, alias._select || alias._ref, null,
                               'alias', ncache.$queryNumber );
         }
-        const mixin = ncache._select.mixin && ncache._select.mixin[head];
+        const mixin = ncache._select.mixin?.[head];
         if (mixin && {}.hasOwnProperty.call( ncache._select.mixin, head )) {
           setCache( mixin, '_parent', qcache._select );
           return resolvePath( path, mixin, null, 'mixin', ncache.$queryNumber );
@@ -818,6 +818,9 @@ function csnRefs( csn, universalReady ) {
       as = `$_column_${ colIndex + 1 }`;
     setCache( col, '$as', as );
     let type = parentElementOrQueryCache;
+    if (col.cast)
+      traverseType( col.cast, col, 'column', colIndex, initNode );
+
     while (type.items)
       type = type.items;
     const elem = setCache( col, '_element', type.elements[as] );

package/lib/model/csnUtils.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { csnRefs, implicitAs } = require('../model/csnRefs');
+const { csnRefs, implicitAs, pathId } = require('./csnRefs');
 const { applyTransformations, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary } = require('../transform/db/applyTransformations');
-const { isBuiltinType } = require('../compiler/builtins.js');
+const { isBuiltinType, isMagicVariable, isAnnotationExpression } = require('../compiler/builtins.js');
 const {
   sortCsn,
   cloneCsnDictionary: _cloneCsnDictionary,
@@ -1088,18 +1088,21 @@ function getLastPartOfRef( ref ) {
  * @param {object} toNode
  * @param {boolean} [overwrite]
  * @param {object} excludes
+ * @param {array} annoNames (copy only these annotations or all if undefined)
+ * @returns {array} copiedAnnoNames
  */
-function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {} ) {
+function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {}, annoNames = undefined ) {
   // Ignore if no toNode (in case of errors)
   if (!toNode)
     return;
 
-  const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
+  if (annoNames == null)
+    annoNames = Object.keys(fromNode).filter(key => key.startsWith('@'));
 
-  for (const anno of annotations) {
+  annoNames.forEach((anno) => {
     if ((toNode[anno] === undefined || overwrite) && !excludes[anno])
       toNode[anno] = cloneAnnotationValue(fromNode[anno]);
-  }
+  });
 }
 
 
@@ -1446,7 +1449,7 @@ function isAssociationOperand( arg, path, inspectRef ) {
 }
 
 function pathName( ref ) {
-  return ref ? ref.map( id => id?.id || id ).join( '.' ) : '';
+  return ref ? ref.map( pathId ).join( '.' ) : '';
 }
 
 module.exports = {
@@ -1456,6 +1459,8 @@ module.exports = {
   cloneCsnDictionary,
   cloneAnnotationValue,
   isBuiltinType,
+  isMagicVariable,
+  isAnnotationExpression,
   applyAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,

package/lib/optionProcessor.js

@@ -13,12 +13,12 @@ optionProcessor
   .option('-h, --help')
   .option('-v, --version')
   .option('    --options <file>')
-  .option('-w, --warning <level>', ['0', '1', '2', '3'])
+  .option('-w, --warning <level>', { valid: ['0', '1', '2', '3'] })
   .option('    --quiet')
   .option('    --show-message-id')
   .option('    --no-message-id')
   .option('    --no-message-context')
-  .option('    --color <mode>', ['auto', 'always', 'never'])
+  .option('    --color <mode>', { valid: ['auto', 'always', 'never'] })
   .option('-o, --out <dir>')
   .option('    --cds-home <dir>')
   .option('    --module-lookup-directories <list>')
@@ -34,13 +34,14 @@ optionProcessor
   .option('    --beta <list>')
   .option('    --deprecated <list>')
   .option('    --direct-backend')
-  .option('    --fallback-parser <type>', ['cdl', 'csn', 'csn!'])
+  .option('    --fallback-parser <type>', { valid: ['cdl', 'csn', 'csn!'] })
   .option('    --shuffle <seed>') // 0 | 1..4294967296
   .option('    --test-mode')
   .option('    --test-sort-csn')
   .option('    --doc-comment')
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
+  .option('    --tenant-as-column')
   .option('    --default-binary-length <length>')
   .option('    --default-string-length <length>')
   .option('    --no-recompile')
@@ -100,6 +101,7 @@ optionProcessor
    -E, --enrich-csn         Show non-enumerable CSN properties and locations of references
    -R, --raw-output <name>  Write XSN for definition "name" and error output to <stdout>,
                             with name = "+", write complete XSN, long!
+       --tenant-as-column   Add tenant fields to entities
        --internal-msg       Write raw messages with call stack to <stdout>/<stderr>
        --beta-mode          Enable all unsupported, incomplete (beta) features
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
@@ -164,7 +166,7 @@ optionProcessor
 // ----------- toHana -----------
 optionProcessor.command('H, toHana')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: ['--names'] })
+  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: ['--names'] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
@@ -172,8 +174,8 @@ optionProcessor.command('H, toHana')
   .option('-c, --csn')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
-  .option('    --assert-integrity <mode>', ['true', 'false', 'individual'])
-  .option('    --assert-integrity-type <type>', ['RT', 'DB'], { ignoreCase: true })
+  .option('    --assert-integrity <mode>', { valid: ['true', 'false', 'individual'] })
+  .option('    --assert-integrity-type <type>', { valid: ['RT', 'DB'], ignoreCase: true })
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
   .help(`
@@ -216,7 +218,7 @@ optionProcessor.command('H, toHana')
 
 optionProcessor.command('O, toOdata')
   .option('-h, --help')
-  .option('-v, --odata-version <version>', ['v2', 'v4', 'v4x'], { aliases: ['--version'] })
+  .option('-v, --odata-version <version>', { valid: ['v2', 'v4', 'v4x'], aliases: ['--version'] })
   .option('-x, --xml')
   .option('-j, --json')
   .option('    --odata-containment')
@@ -228,8 +230,8 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-v2-partial-constr')
   .option('    --odata-vocabularies <list>')
   .option('-c, --csn')
-  .option('-f, --odata-format <format>', ['flat', 'structured'])
-  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
+  .option('-f, --odata-format <format>', { valid: ['flat', 'structured'] })
+  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: [ '--names' ] })
   .option('-s, --service-names <list>')
   .option('    --fewer-localized-views')
   .help(`
@@ -285,18 +287,18 @@ optionProcessor.command('C, toCdl')
 
 optionProcessor.command('Q, toSql')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
-  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres', 'h2'], { aliases: [ '--dialect' ] })
+  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: [ '--names' ] })
+  .option('-d, --sql-dialect <dialect>', { valid: ['hana', 'sqlite', 'plain', 'postgres', 'h2'], aliases: [ '--dialect' ] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
   .option('-l, --locale <locale>')
-  .option('-s, --src <style>', ['sql', 'hdi'])
+  .option('-s, --src <style>', { valid: ['sql', 'hdi'] })
   .option('-c, --csn')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
-  .option('    --assert-integrity <mode>', ['true', 'false', 'individual'])
-  .option('    --assert-integrity-type <type>', ['RT', 'DB'], { ignoreCase: true })
+  .option('    --assert-integrity <mode>', { valid: ['true', 'false', 'individual'] })
+  .option('    --assert-integrity-type <type>', { valid: ['RT', 'DB'], ignoreCase: true })
   .option('    --constraints-in-create-table')
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
@@ -364,7 +366,7 @@ optionProcessor.command('Q, toSql')
 
 optionProcessor.command('toRename')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', ['quoted', 'hdbcds'], { aliases: ['--names'] })
+  .option('-n, --sql-mapping <style>', { valid: ['quoted', 'hdbcds'], aliases: ['--names'] })
   .help(`
   Usage: cdsc toRename [options] <files...>
 
@@ -386,14 +388,14 @@ optionProcessor.command('toRename')
 
 optionProcessor.command('manageConstraints')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: ['--names'] })
-  .option('-s, --src <style>', ['sql', 'hdi'])
+  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: ['--names'] })
+  .option('-s, --src <style>', { valid: ['sql', 'hdi'] })
   .option('    --drop')
   .option('    --alter')
   .option('    --violations')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
-  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres', 'h2'], { aliases: [ '--dialect' ] })
+  .option('-d, --sql-dialect <dialect>', { valid: ['hana', 'sqlite', 'plain', 'postgres', 'h2'], aliases: [ '--dialect' ] })
   .help(`
   Usage: cdsc manageConstraints [options] <files...>
 
@@ -432,7 +434,7 @@ optionProcessor.command('manageConstraints')
 
 optionProcessor.command('toCsn')
   .option('-h, --help')
-  .option('-f, --csn-flavor <flavor>', ['client', 'gensrc', 'universal'], { aliases: ['--flavor'] })
+  .option('-f, --csn-flavor <flavor>', { valid: ['client', 'gensrc', 'universal'], aliases: ['--flavor'] })
   .option('    --with-localized')
   .option('    --with-locations')
   .option('    --struct-xpr')

package/lib/render/manageConstraints.js

@@ -6,8 +6,6 @@ const {
   getResultingName,
 } = require('../model/csnUtils');
 const { forEach } = require('../utils/objectUtils');
-const { makeMessageFunction } = require('../base/messages');
-const { optionProcessor } = require('../optionProcessor');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 
 const {
@@ -20,14 +18,15 @@ const { sortCsn } = require('../json/to-csn');
  * Not part of our API, yet.
  *
  * @param {CSN.Model} csn
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {CSN.Options} options
  */
-function alterConstraintsWithCsn( csn, options ) {
-  const { error, warning } = makeMessageFunction(csn, options, 'manageConstraints');
+function alterConstraintsWithCsn( csn, options, messageFunctions ) {
+  const { error, warning } = messageFunctions;
 
   const {
     drop, alter, src, violations, sqlDialect,
-  } = options || {};
+  } = options;
 
   if (!sqlDialect || sqlDialect === 'h2' || sqlDialect === 'plain')
     warning(null, null, { prop: sqlDialect || 'plain' }, 'Referential Constraints are not available for sql dialect $(PROP)');
@@ -35,12 +34,11 @@ function alterConstraintsWithCsn( csn, options ) {
   if (drop && alter)
     error(null, null, 'Option “--drop” can\'t be combined with “--alter”');
 
-
-  // Of course we want the database constraints
+  // Of course, we want the database constraints
   options.assertIntegrityType = options.assertIntegrityType || 'DB';
 
   const transformedOptions = _transformSqlOptions(csn, options);
-  const forSqlCsn = transformForRelationalDBWithCsn(csn, transformedOptions, 'to.sql');
+  const forSqlCsn = transformForRelationalDBWithCsn(csn, transformedOptions, messageFunctions);
 
   if (violations && src && src !== 'sql') {
     error(null, null, { value: '--violations', othervalue: src },
@@ -56,32 +54,18 @@ function alterConstraintsWithCsn( csn, options ) {
   return intermediateResult;
 }
 
-function _transformSqlOptions( model, options ) {
+// TODO: Remove / Move to api/options.js once alterConstraintsWithCsn is available outside bin/cdsc
+function _transformSqlOptions( csn, options ) {
+  const { src } = options;
+  // eslint-disable-next-line global-require
+  const prepareOptions = require('../api/options');
+  options = prepareOptions.to.sql(options);
+  options.src = src;
   // Merge options with defaults.
   options = Object.assign({ sqlMapping: 'plain', sqlDialect: 'plain' }, options);
   options.toSql = true;
-
   if (!options.src && !options.csn)
     options.src = 'sql';
-
-  const { warning, error } = makeMessageFunction(model, options, 'to.sql');
-
-  optionProcessor.verifyOptions(options, 'toSql', true)
-    // eslint-disable-next-line cds-compiler/message-template-string
-    .forEach(complaint => warning(null, null, `${complaint}`));
-
-  if (options.sqlDialect !== 'hana') {
-    // CDXCORE-465, 'quoted' and 'hdbcds' are to be used in combination with dialect 'hana' only
-    if (options.sqlMapping === 'quoted' || options.sqlMapping === 'hdbcds') {
-      error(null, null, { value: options.sqlDialect, othervalue: options.sqlMapping },
-            'Option sqlDialect: $(VALUE) can\'t be combined with sqlMapping: $(OTHERVALUE)');
-    }
-
-    // No non-HANA SQL for HDI
-    if (options.src === 'hdi')
-      error(null, null, { value: options.sqlDialect }, 'Option sqlDialect: $(VALUE) can\'t be used for SAP HANA HDI');
-  }
-
   return options;
 }
 

package/lib/render/toCdl.js

@@ -5,13 +5,11 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { timetrace } = require('../utils/timetrace');
 const { forEachDefinition, normalizeTypeRef } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
-const { makeMessageFunction } = require('../base/messages.js');
-const { typeParameters, specialFunctions, xprInAnnoProperties } = require('../compiler/builtins');
+const { typeParameters, specialFunctions, isAnnotationExpression } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
 const {
   isBuiltinType,
@@ -30,14 +28,11 @@ const specialFunctionKeywords = Object.create(null);
  *  - `namespace`: Namespace statement + `using from './model.cds'.
  *
  * @param {CSN.Model} csn
- * @param {CSN.Options} [options]
+ * @param {CSN.Options} options
+ * @param {object} msg Message Functions
  */
-function csnToCdl( csn, options ) {
+function csnToCdl( csn, options, msg ) {
   const special$self = !csn?.definitions?.$self && '$self';
-  timetrace.start('CDL rendering');
-
-  const msg = makeMessageFunction(csn, options, 'to.cdl');
-
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn')) {
     // Since the expander modifies the CSN, we need to clone it first or
     // toCdl can't guarantee that the input CSN is not modified.
@@ -91,8 +86,6 @@ function csnToCdl( csn, options ) {
     cdlResult.model = usingsStr + cdlResult.model;
   }
 
-  timetrace.stop('CDL rendering');
-
   msg.throwWithError();
   return cdlResult;
 
@@ -1353,7 +1346,7 @@ function csnToCdl( csn, options ) {
         result += renderNullability(artifact);
 
       if (artifact.default && !artifact.on)
-        result += ` default ${exprRenderer.renderExpr(artifact.default, env.withSubPath([ 'default' ]))}`;
+        result += renderDefaultExpr(artifact, env);
       return result;
     }
 
@@ -1386,7 +1379,7 @@ function csnToCdl( csn, options ) {
     // If there is a default value, and it's a calculated element, do not
     // render the default (because it's not supported for calc elements).
     if (artifact.default !== undefined && !artifact.value)
-      result += ` default ${exprRenderer.renderExpr(artifact.default, env.withSubPath([ 'default' ]))}`;
+      result += renderDefaultExpr(artifact, env);
 
     return result;
   }
@@ -1463,8 +1456,7 @@ function csnToCdl( csn, options ) {
    * @param {CdlRenderEnvironment} env
    */
   function renderAnnotationValue( annoValue, env ) {
-    const isXpr = annoValue?.['='] !== undefined && xprInAnnoProperties.some(xProp => annoValue[xProp] !== undefined);
-    if (isXpr) {
+    if (isAnnotationExpression(annoValue)) {
       // Once inside an expression, we stay there.
       const xpr = exprRenderer.renderExpr(annoValue, env);
       return `( ${xpr} )`;
@@ -1758,6 +1750,17 @@ function csnToCdl( csn, options ) {
     return result;
   }
 
+  function renderDefaultExpr( art, env ) {
+    if (!art.default)
+      return '';
+    let result = ' default ';
+    if ( art.default.xpr && xprContainsCondition( art.default.xpr))
+      result += exprRenderer.renderSubExpr(withoutCast( art.default), env.withSubPath([ 'default' ]));
+    else
+      result += exprRenderer.renderExpr(withoutCast( art.default), env.withSubPath([ 'default' ]));
+    return result;
+  }
+
   // Render the nullability of an element or parameter (can be unset, true, or false)
   function renderNullability( obj /* , env */) {
     if (obj.notNull === undefined) {