@sap/cds-compiler 3.5.4 → 3.6.2

package/lib/optionProcessor.js

@@ -15,6 +15,7 @@ optionProcessor
   .option('-w, --warning <level>', ['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('-o, --out <dir>')
@@ -33,6 +34,7 @@ optionProcessor
   .option('    --deprecated <list>')
   .option('    --direct-backend')
   .option('    --fallback-parser <type>', ['cdl', 'csn', 'csn!'])
+  .option('    --shuffle <seed>') // 0 | 1..4294967296
   .option('    --test-mode')
   .option('    --test-sort-csn')
   .option('    --doc-comment')
@@ -64,7 +66,8 @@ optionProcessor
        --options <file>     Use the given JSON file as input options.
                             The key 'cdsc' of 'cds' is used. If not present 'cdsc' is used.
                             Otherwise, the JSON as-is is used as options.
-       --show-message-id    Show message ID in error, warning and info messages
+       --no-message-id      Don't show message IDs in errors, warnings, info and debug messages
+       --show-message-id    DEPRECATED: Showing the message ID is now the default.
        --no-message-context Print messages as single lines without code context (useful for
                             redirecting output to other processes). Default is to print human-
                             readable text similar to Rust's compiler with a code excerpt.
@@ -106,7 +109,7 @@ optionProcessor
                               postgres
                               aspectWithoutElements
                               odataOpenType
-                              odtaTerms
+                              odataTerms
                               optionalActionFunctionParameters
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
@@ -121,6 +124,11 @@ optionProcessor
                             Can only be used with certain new CSN based backends. Combination with
                             other flags is limited, e.g. --test-mode will not run a consistency check.
                             No recompilation is triggered in case of errors. cdsc will dump.
+       --shuffle <seed>     If provided, some internal processing sequences are changed, most notably by
+                            using a shuffled version of ‹model›.definitions. <seed> should be a number
+                            between 1 and 4294967296, the compiler uses a random number in that range if the
+                            provided argument is 0 or not a number. The same number always produces the same
+                            shuffled version of ‹model›.definitions.  This option also enables --test-mode.
        --test-mode          Produce extra-stable output for automated tests (normalize filenames
                             in errors, sort properties in CSN, omit version in CSN)
        --test-sort-csn      Sort the generated CSN by definitions.  This impacts the order of EDMX,
@@ -150,7 +158,8 @@ optionProcessor
   Environment variables
     NO_COLOR                If set, compiler messages (/output) will not be colored.
                             Can be overwritten by '--color'
-    CDSC_TIMETRACING        If set, additional timing information is printed to stderr.
+    CDSC_TRACE_TIME         If set, additional timing information is printed to stderr.
+    CDSC_TRACE_API          If set, additional API calling information is printed to stderr.
 `);
 
 // ----------- toHana -----------
@@ -284,6 +293,7 @@ optionProcessor.command('Q, toSql')
   .option('    --constraints-in-create-table')
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
+  .option('    --generated-by-comment')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -334,6 +344,8 @@ optionProcessor.command('Q, toSql')
                                     "ALTER TABLE ADD CONSTRAINT" statements
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
+   --generated-by-comment     Enable rendering of the initial SQL comment for HDI-based artifacts
+
 `);
 
 optionProcessor.command('toRename')
@@ -367,6 +379,7 @@ optionProcessor.command('manageConstraints')
   .option('    --violations')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
+  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres', 'h2'], { aliases: [ '--dialect' ] })
   .help(`
   Usage: cdsc manageConstraints [options] <files...>
 
@@ -395,6 +408,12 @@ optionProcessor.command('manageConstraints')
                           referential integrity violations on the existing data
       --integrity-not-enforced   If this option is supplied, referential constraints are NOT ENFORCED.
       --integrity-not-validated  If this option is supplied, referential constraints are NOT VALIDATED.
+  -d, --sql-dialect <dialect>  SQL dialect to be generated:
+      plain    : (default) Common SQL - no assumptions about DB restrictions (constraints not supported in this dialect)
+      hana     : SQL with HANA specific language features
+      sqlite   : Common SQL for sqlite
+      postgres : Common SQL for postgres - beta-feature
+      h2       : Common SQL for h2 (constraints not supported in this dialect)
 `);
 
 optionProcessor.command('toCsn')

package/lib/render/manageConstraints.js

@@ -13,6 +13,7 @@ const { transformForRelationalDBWithCsn } = require('../transform/forRelationalD
 const {
   renderReferentialConstraint, getIdentifierUtils,
 } = require('./utils/sql');
+const { sortCsn } = require('../json/to-csn');
 
 /**
  * Used only by `cdsc manageConstraints`.
@@ -25,17 +26,15 @@ function alterConstraintsWithCsn( csn, options ) {
   const { error } = makeMessageFunction(csn, options, 'manageConstraints');
 
   const {
-    drop, alter, names, src, violations,
-  } = options.manageConstraints || {};
+    drop, alter, src, violations,
+  } = options || {};
 
   if (drop && alter)
     error(null, null, 'Option “--drop” can\'t be combined with “--alter”');
 
-  options.sqlDialect = 'hana';
-  options.sqlMapping = names || 'plain';
 
   // Of course we want the database constraints
-  options.assertIntegrityType = 'DB';
+  options.assertIntegrityType = options.assertIntegrityType || 'DB';
 
   const transformedOptions = _transformSqlOptions(csn, options);
   const forSqlCsn = transformForRelationalDBWithCsn(csn, transformedOptions, 'to.sql');
@@ -49,7 +48,7 @@ function alterConstraintsWithCsn( csn, options ) {
   if (violations)
     intermediateResult = listReferentialIntegrityViolations(forSqlCsn, transformedOptions);
   else
-    intermediateResult = manageConstraints(forSqlCsn, transformedOptions);
+    intermediateResult = manageConstraints(options.testMode ? sortCsn(forSqlCsn) : forSqlCsn, transformedOptions);
 
   return intermediateResult;
 }
@@ -92,19 +91,16 @@ function _transformSqlOptions( model, options ) {
  * @returns a map holding the constraint identifier as key and the corresponding, rendered SQL statement / hdbconstraint artifact as value.
  */
 function manageConstraints( csn, options ) {
-  const {
-    drop, alter, src,
-  } = options.manageConstraints || {};
-  const indent = '';
+  const indent = options.src === 'hdi' ? '  ' : ''; // indent `.hdbconstraint`
   // either ALTER TABLE statements or .hdbconstraint artifacts
   const resultArtifacts = {};
   const { quoteSqlId } = getIdentifierUtils(csn, options);
   forEachDefinition(csn, (artifact) => {
-    if (artifact.$tableConstraints && artifact.$tableConstraints.referential) {
+    if (artifact.$tableConstraints?.referential) {
       forEach(artifact.$tableConstraints.referential, (fileName, constraint) => {
-        const renderAlterConstraintStatement = alter && src !== 'hdi';
+        const renderAlterConstraintStatement = options.alter && options.src !== 'hdi';
         const renderedConstraint = renderReferentialConstraint(constraint, indent, false, csn, options, renderAlterConstraintStatement);
-        if (src === 'hdi') {
+        if (options.src === 'hdi' && !options.drop) {
           resultArtifacts[fileName] = renderedConstraint;
           return;
         }
@@ -112,7 +108,7 @@ function manageConstraints( csn, options ) {
         alterTableStatement += `${indent}ALTER TABLE ${quoteSqlId(getResultingName(csn, options.sqlMapping, constraint.dependentTable))}`;
         if (renderAlterConstraintStatement)
           alterTableStatement += `\n${indent}ALTER ${renderedConstraint};`;
-        else if (drop)
+        else if (options.drop)
           alterTableStatement += `${indent} DROP CONSTRAINT ${quoteSqlId(constraint.identifier)};`;
         else
           alterTableStatement += `\n${indent}ADD ${renderedConstraint};`;
@@ -121,7 +117,7 @@ function manageConstraints( csn, options ) {
       });
     }
   });
-  return resultArtifacts;
+  return options.src === 'hdi' ? resultArtifacts : Object.values(resultArtifacts);
 }
 
 /**

package/lib/render/toCdl.js

@@ -5,7 +5,7 @@ const { findElement, createExpressionRenderer, withoutCast } = require('./utils/
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
-const { forEachDefinition } = require('../model/csnUtils');
+const { forEachDefinition, normalizeTypeRef } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
@@ -19,6 +19,7 @@ const {
 } = require('../model/csnUtils');
 
 const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
+const specialFunctionKeywords = Object.create(null);
 
 /**
  * Render the CSN model 'model' to CDS source text.
@@ -30,6 +31,7 @@ const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
  * @param {CSN.Options} [options]
  */
 function csnToCdl( csn, options ) {
+  const special$self = !csn?.definitions?.$self && '$self';
   timetrace.start('CDL rendering');
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn')) {
@@ -48,7 +50,7 @@ function csnToCdl( csn, options ) {
     addIfRequired(name) {
       // RegEx is at least twice as fast as .split()[0]
       const first = name.match(/^[^.]+/)[0];
-      if (!this.available.includes(first) && !this.list.includes(first))
+      if (name !== special$self && !this.available.includes(first) && !this.list.includes(first))
         this.list.push(first);
     },
     renderUsings() {
@@ -197,11 +199,11 @@ function csnToCdl( csn, options ) {
     // The former one can not only extend (sub-)elements but also actions in the same statement whereas
     // the latter cannot.
     // If there are actions, check if there are also elements/columns, and if so, use the prefix notation.
-    const usePrefixNotation = isElementExtend || ext.actions && (ext.columns || ext.elements);
+    const usePrefixNotation = ext.actions && (ext.columns || ext.elements);
     if (usePrefixNotation)
       result += `${env.indent}extend ${getExtendPrefixVariant(ext)} ${extName} with {\n`;
     else
-      result += `${env.indent}extend ${extName} with ${getExtendPostfixVariant(ext)} {\n`;
+      result += `${env.indent}extend ${extName} with ${getExtendPostfixVariant(ext)}{\n`;
 
     if (ext.columns)
       result += renderViewColumns(ext.columns, increaseIndent(env));
@@ -252,13 +254,20 @@ function csnToCdl( csn, options ) {
    */
   function getExtendPostfixVariant( ext ) {
     if (ext.columns)
-      return 'columns';
+      return 'columns ';
     if (ext.actions)
-      return 'actions';
-    if (ext.elements)
-      return 'elements';
+      return 'actions ';
     if (ext.enum)
-      return 'enum';
+      return 'enum ';
+    if (ext.elements) { // enum/elements ambiguity -> look into elements
+      // TODO: Check for `type` as well once this is supported by the parser (and identified as elements):
+      //       `extend E with { a = 'string'; b: String }`
+      const isLikelyElement = Object.keys(ext.elements)
+        .find(name => ext.elements[name].value !== undefined);
+      if (isLikelyElement)
+        return 'elements ';
+    }
+    // ambiguity; no postfix, i.e. `extend … with { … }`.s
     return '';
   }
 
@@ -544,16 +553,25 @@ function csnToCdl( csn, options ) {
     // TODO(v4): Remove once deprecated flag for `masked` is removed.
     result += elm.masked ? 'masked ' : '';
     result += quoteIdIfRequired(elementName);
-    if (elm.val !== undefined) {
+    if (elm.val !== undefined) { // enum value
       result += ` = ${exprRenderer.renderExpr(elm, env)}`;
     }
-    else if (elm['#'] !== undefined) {
+    else if (elm['#'] !== undefined) { // enum symbol reference
       result += ` = #${elm['#']}`;
     }
     else {
-      const props = renderTypeReferenceAndProps(elm, env);
-      if (props !== '')
-        result += ` : ${props}`;
+      // TODO: Maybe push the .value check into renderTypeReferenceAndProps?
+      const type = normalizeTypeRef(elm.items?.type || elm.type);
+      const isAssoc = type === 'cds.Association' || type === 'cds.Composition';
+      if (!isAssoc || elm.value === undefined) {
+        const props = renderTypeReferenceAndProps(elm, env);
+        if (props !== '')
+          result += ` : ${props}`;
+      }
+    }
+
+    if (elm.value !== undefined) { // calculated element // @ts-ignore
+      result += ` = ${exprRenderer.renderExpr(elm.value, env)}`;
     }
 
     return `${result};\n`;
@@ -632,7 +650,8 @@ function csnToCdl( csn, options ) {
      * @return {boolean} True, if there were annotations, false otherwise.
      */
     function collectAnnos( annotateObj, art ) {
-      if (!art.elements && !art.enum)
+      if (!Object.hasOwnProperty.call(art, 'elements') &&
+          !Object.hasOwnProperty.call(art, 'enum'))
         return false;
 
       const dictKey = art.elements ? 'elements' : 'enum';
@@ -680,7 +699,7 @@ function csnToCdl( csn, options ) {
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(source, false, 'view', increaseIndent(env))})`;
       if (source.as)
-        result += ` as ${quoteIdIfRequired(source.as)}`;
+        result += renderAlias(source.as);
 
       return result;
     }
@@ -770,7 +789,7 @@ function csnToCdl( csn, options ) {
     let result = renderAbsolutePath(path, env);
     if (path.as) {
       // Source had an alias - render it
-      result += ` as ${quoteIdIfRequired(path.as)}`;
+      result += renderAlias(path.as);
     }
     return result;
   }
@@ -825,7 +844,7 @@ function csnToCdl( csn, options ) {
     // A new association (cast with `type` and `target`) uses `as` as its primary name, not alias.
     const isNewAssociation = col.cast?.type && col.cast.target;
     if (!isNewAssociation && col.as && !col.inline && !col.expand)
-      result += ` as ${quoteIdIfRequired(col.as)}`;
+      result += renderAlias(col.as);
 
     // Explicit type provided for the view element?
     if (col.cast) {
@@ -852,7 +871,7 @@ function csnToCdl( csn, options ) {
 
     // s as alias { * }
     if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
-      result += ` as ${obj.as}`;
+      result += renderAlias(obj.as);
 
     // We found a leaf - no further drilling
     if (!obj.inline && !obj.expand) {
@@ -882,7 +901,7 @@ function csnToCdl( csn, options ) {
 
     // { * } as expand
     if (!obj.ref && obj.as)
-      result += ` as ${obj.as}`;
+      result += renderAlias(obj.as);
 
     return result;
   }
@@ -900,12 +919,16 @@ function csnToCdl( csn, options ) {
     else if (obj && obj.doc === null) // empty doc comment needs to be rendered
       return `\n${env.indent}/** */\n`;
 
-    // Smaller comment for single-line comments.  If the comments starts or ends with whitespace
+    let { doc } = obj;
+    if (/[^\\][*]\//.test(doc))
+      doc = doc.replace(/([^\\])[*]\//g, '$1*\\/');
+
+    // Smaller comment for single-line comments.  If the comment starts or ends with whitespace
     // we must use a block comment, or it will be lost when compiling the source again.
-    if (!obj.doc.includes('\n') && !/^\s|\s$/.test(obj.doc))
-      return `${env.indent}/** ${obj.doc} */\n`;
+    if (!obj.doc.includes('\n') && !/(^\s)|(\s$)/.test(obj.doc))
+      return `${env.indent}/** ${doc} */\n`;
 
-    const comment = obj.doc.split('\n').map(line => `${env.indent} * ${line}`).join('\n');
+    const comment = doc.split('\n').map(line => `${env.indent} * ${line}`).join('\n');
     return `${env.indent}/**\n${comment}\n${env.indent} */\n`;
   }
 
@@ -984,8 +1007,7 @@ function csnToCdl( csn, options ) {
       result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteIdIfRequired(id)}`).join(',\n')}\n`;
       result += `${env.indent}}`;
     }
-    // FIXME: Currently, only projections can have actions and functions, but we cannot distinguish
-    // a projection from a view any more
+
     if (isLeadingQuery)
       result += renderActionsAndFunctions(query, env);
 
@@ -1215,7 +1237,9 @@ function csnToCdl( csn, options ) {
       // "many many" does not work in CDL, so we don't check for it.
     }
 
-    if (!artifact.type && artifact.elements) {
+    const type = normalizeTypeRef(artifact.type);
+
+    if (!type && artifact.elements) {
       result += renderElements(artifact, env);
       if (!isTypeDef)
         result += renderNullability(artifact);
@@ -1224,8 +1248,8 @@ function csnToCdl( csn, options ) {
     }
 
     // Association type
-    if (artifact.type === 'cds.Association' || artifact.type === 'cds.Composition') {
-      const isComp = artifact.type === 'cds.Composition';
+    if (type === 'cds.Association' || type === 'cds.Composition') {
+      const isComp = type === 'cds.Composition';
       // Type, cardinality and target; CAPire uses CamelCase
       result += isComp ? 'Composition' : 'Association';
       result += renderCardinality(artifact);
@@ -1276,11 +1300,11 @@ function csnToCdl( csn, options ) {
     }
 
     // Reference to another artifact
-    if (typeof artifact.type === 'string') {
+    if (typeof type === 'string') {
       // If we get here, it must be a named type
       result += renderNamedTypeWithParameters(artifact);
     }
-    else if (artifact.type?.ref) {
+    else if (type?.ref) {
       result += renderAbsolutePath(artifact.type, env);
     }
 
@@ -1316,21 +1340,22 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderNamedTypeWithParameters( artWithType ) {
+    const type = normalizeTypeRef(artWithType.type);
     let result = '';
 
-    if (isBuiltinType(artWithType.type)) {
+    if (isBuiltinType(type)) {
       // If there is a user-defined type that starts with the same short name
       // (cds.Integer -> Integer), we render the full name, including the leading "cds."
-      const shortHand = artWithType.type.slice(4);
+      const shortHand = type.slice(4);
       if (shortHand.startsWith('hana.') && hanaRequiresAbsolutePath)
-        result += artWithType.type;
+        result += type;
       else if (usings.available.includes(shortHand))
-        result += artWithType.type;
+        result += type;
       else
         result += shortHand;
     }
     else {
-      result += renderDefinitionReference(artWithType.type);
+      result += renderDefinitionReference(type);
     }
 
     result += renderTypeParameters(artWithType);
@@ -1341,7 +1366,7 @@ function csnToCdl( csn, options ) {
   /**
    * Render the 'enum { ... } part of a type declaration
    *
-   * @param {CSN.EnumElements} enumPart
+   * @param {CSN.EnumList} enumPart
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
@@ -1391,7 +1416,8 @@ function csnToCdl( csn, options ) {
       const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderAnnotationValue(x[key], childEnv)}`);
       if (values.length <= 1)
         return `{ ${values.join(', ')} }`;
-      return `{\n${childEnv.indent}${values.join(`,\n${childEnv.indent}`)}\n${env.indent}}`;
+      const valueList = values.join(`,\n${childEnv.indent}`);
+      return `{\n${childEnv.indent}${valueList}\n${env.indent}}`;
     }
     // Null
     else if (x === null) {
@@ -1539,7 +1565,7 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderBracketCardinality( art ) {
-    const isComp = art.type === 'cds.Composition';
+    const isComp = normalizeTypeRef(art.type) === 'cds.Composition';
     const suffix = (isComp ? ' of ' : ' to ');
     const card = art.cardinality;
 
@@ -1583,7 +1609,7 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderSimpleCardinality( elem ) {
-    let result = (elem.type === 'cds.Association' ? ' to ' : ' of ');
+    let result = (normalizeTypeRef(elem.type) === 'cds.Association' ? ' to ' : ' of ');
     if (!elem.cardinality)
       return result;
     if (elem.cardinality.max === '*')
@@ -1610,10 +1636,20 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderForeignKey( fKey, env ) {
-    const alias = fKey.as ? (` as ${fKey.as}`) : '';
+    const alias = fKey.as ? renderAlias(fKey.as) : '';
     return exprRenderer.renderExpr(fKey, env) + alias;
   }
 
+  /**
+   * Render an explicit alias, e.g. for columns.
+   *
+   * @param {string} alias
+   * @return {string}
+   */
+  function renderAlias( alias ) {
+    return ` as ${quoteIdIfRequired(alias)}`;
+  }
+
   /**
    * Render (primitive) type parameters of artifact 'artWithType', i.e.
    * length, precision and scale (even if incomplete), plus any other unknown ones.
@@ -1695,7 +1731,7 @@ function csnToCdl( csn, options ) {
       result += '(';
 
     if (annoRequiresQuoting || variantRequiresQuoting)
-      result += quote(name);
+      result += delimitedId(name);
     else
       result += name;
 
@@ -1775,9 +1811,9 @@ function csnToCdl( csn, options ) {
         return `${funcDef} ${this.renderExpr(x.xpr)}`; // xpr[0] is 'over'
       },
       func(x) {
-        if (keywords.cdl_functions.includes(x.func.toUpperCase()))
+        if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
           return x.func;
-        const name = identifierRegex.test(x.func) ? x.func : quote(x.func);
+        const name = smartFunctionId(x.func);
         return `${name}(${renderArguments( x, '=>', this.env )})`;
       },
       xpr(x) {
@@ -1863,7 +1899,7 @@ function quotePathIfRequired( path ) {
 function quoteIdIfRequired( id, additionalKeywords ) {
   // Quote if required for CDL
   if (requiresQuotingForCdl(id, additionalKeywords || []))
-    return quote(id);
+    return delimitedId(id);
   return id;
 }
 
@@ -1890,7 +1926,7 @@ function quoteAnnotationPathIfRequired( anno ) {
  * @param id
  * @returns {string}
  */
-function quote( id ) {
+function delimitedId( id ) {
   return `![${id.replace(/]/g, ']]')}]`;
 }
 
@@ -1980,6 +2016,31 @@ function getKeywordsForSpecialFunctionArgument( funcName, argumentIndex ) {
   return additionalKeywords;
 }
 
+/**
+ * Get a list of all special keywords for the given function.
+ *
+ * @param {string} funcName
+ * @return {undefined|string[]}
+ */
+function getAllKeywordsForSpecialFunction( funcName ) {
+  if (specialFunctionKeywords[funcName])
+    return specialFunctionKeywords[funcName];
+  else if (!specialFunctions[funcName])
+    return undefined;
+
+  const additionalKeywords = [];
+  for (const arg of specialFunctions[funcName]) {
+    if (arg.intro)
+      additionalKeywords.push(...arg.intro);
+    if (arg.expr)
+      additionalKeywords.push(...arg.expr);
+    if (arg.separator)
+      additionalKeywords.push(...arg.separator);
+  }
+  specialFunctionKeywords[funcName] = additionalKeywords;
+  return additionalKeywords;
+}
+
 /**
  * Render the given string.  Uses back-tick strings.
  * env is used for indentation of three-back-tick strings.
@@ -2068,6 +2129,37 @@ function availableFirstPathSteps( csn ) {
   return Array.from(unique);
 }
 
+/**
+ * Returns a delimited identifier if the given identifier needs quoting.
+ * Because "special functions" such as SAP HANA RegEx functions have local keywords that
+ * are not default CDL keywords, specify a function name to take care of that.
+ *
+ * @param {string} id
+ * @param {null|string} insideFunction
+ * @return {string}
+ */
+function smartId( id, insideFunction = null ) {
+  insideFunction = insideFunction?.toUpperCase();
+  if (!insideFunction || !specialFunctions[insideFunction])
+    return quoteIdIfRequired(id);
+  return quoteIdIfRequired(id, getAllKeywordsForSpecialFunction(insideFunction));
+}
+
+/**
+ * Quote the given function name if required.
+ *
+ * @param {string} funcName
+ * @return {string}
+ */
+function smartFunctionId( funcName ) {
+  const funcId = funcName.toUpperCase();
+  const requiresQuoting = !identifierRegex.test(funcName) ||
+    (keywords.cdl.includes(funcId) && !specialFunctions[funcId]);
+  if (requiresQuoting)
+    return delimitedId(funcName);
+  return funcName;
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
@@ -2078,4 +2170,9 @@ function availableFirstPathSteps( csn ) {
  * @property {string[]} [additionalKeywords] For function rendering: Words that are also keywords.
  */
 
-module.exports = { csnToCdl };
+module.exports = {
+  csnToCdl,
+  smartId,
+  smartFunctionId,
+  delimitedId,
+};