@sap/cds-compiler 4.6.2 → 4.7.4

package/lib/model/csnUtils.js

@@ -1,17 +1,18 @@
 'use strict';
 
 const { csnRefs, implicitAs, pathId } = require('./csnRefs');
-const { applyTransformations, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary } = require('../transform/db/applyTransformations');
-const { isBuiltinType, isMagicVariable, isAnnotationExpression } = require('../compiler/builtins.js');
 const {
-  sortCsn,
-  cloneCsnDictionary: _cloneCsnDictionary,
-  cloneAnnotationValue: _cloneAnnotationValue,
-} = require('../json/to-csn');
+  transformExpression,
+  applyTransformations,
+  applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
+} = require('../transform/db/applyTransformations');
+const { isBuiltinType, isMagicVariable, isAnnotationExpression } = require('../compiler/builtins.js');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
 const { version } = require('../../package.json');
+const { cloneAnnotationValue } = require('./cloneCsn');
 
 // Low-level utility functions to work with compact CSN.
 
@@ -442,52 +443,6 @@ function getUtils( model, universalReady ) {
   }
 }
 
-/**
- * Deeply clone the given CSN model and return it.
- * In testMode (or with testSortCsn), definitions are sorted.
- *
- * This function is CSN aware! Don't put annotation values into it, or
- * keys such as "elements" will be interpreted according to CSN rules!
- *
- * @see cloneAnnotationValue
- * @see cloneCsnDictionary
- *
- * @param {object} csn Top-level CSN.  You can pass non-dictionary values.
- * @param {CSN.Options} options CSN Options, only used for `dictionaryPrototype`, `testMode`, and `testSortCsn`
- */
-function cloneCsnNonDict( csn, options ) {
-  return sortCsn(csn, options);
-}
-
-/**
- * Deeply clone the given CSN dictionary and return it.
- * This function does _not_ sort the given dictionary.
- * See cloneCsnNonDict() if you want sorted definitions.
- *
- * This function is CSN aware! Don't put annotation values into it, or
- * keys such as "elements" will be interpreted according to CSN rules!
- *
- * @see cloneAnnotationValue
- * @see cloneCsnNonDict
- *
- * @param {object} csn
- * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
- *                              used and cloneOptions are passed to sortCsn().
- */
-function cloneCsnDictionary( csn, options ) {
-  return _cloneCsnDictionary(csn, options);
-}
-
-/**
- * Clones the given annotation _value_.  `value` must not be an object with annotations,
- * but the annotation value itself, e.g. `[ { a: 1 } ]`, not `@anno: [...]`.
- *
- * @param {any} value
- * @returns {any}
- */
-function cloneAnnotationValue( value ) {
-  return _cloneAnnotationValue( value );
-}
 
 /**
  * Apply function `callback` to all artifacts in dictionary
@@ -1092,17 +1047,19 @@ function getLastPartOfRef( ref ) {
  * @returns {array} copiedAnnoNames
  */
 function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {}, annoNames = undefined ) {
-  // Ignore if no toNode (in case of errors)
-  if (!toNode)
-    return;
-
-  if (annoNames == null)
-    annoNames = Object.keys(fromNode).filter(key => key.startsWith('@'));
-
-  annoNames.forEach((anno) => {
-    if ((toNode[anno] === undefined || overwrite) && !excludes[anno])
-      toNode[anno] = cloneAnnotationValue(fromNode[anno]);
-  });
+  const copiedAnnoNames = [];
+  if (toNode) {
+    if (annoNames == null)
+      annoNames = Object.keys(fromNode).filter(key => key.startsWith('@'));
+
+    annoNames.forEach((anno) => {
+      if ((toNode[anno] === undefined || overwrite) && !excludes[anno]) {
+        toNode[anno] = cloneAnnotationValue(fromNode[anno]);
+        copiedAnnoNames.push(anno);
+      }
+    });
+  }
+  return copiedAnnoNames;
 }
 
 
@@ -1275,23 +1232,6 @@ function getNamespace( csn, name, ns = undefined ) {
   return ns;
 }
 
-
-/**
- * Sorts the definition dictionary in tests mode.
- *
- * @param {CSN.Model} csn
- * @param {CSN.Options} options
- */
-function sortCsnDefinitionsForTests( csn, options ) {
-  if (!options.testMode && !options.testSortCsn)
-    return;
-  const sorted = Object.create(null);
-  Object.keys(csn.definitions || {}).sort().forEach((name) => {
-    sorted[name] = csn.definitions[name];
-  });
-  csn.definitions = sorted;
-}
-
 /**
  * Return an array of non-abstract service names contained in CSN
  *
@@ -1452,12 +1392,28 @@ function pathName( ref ) {
   return ref ? ref.map( pathId ).join( '.' ) : '';
 }
 
+/**
+ * Return true if prop is an annotation and the annotation value has an expression
+ *
+ * @param {object} node
+ * @param {string} prop
+ * @returns {boolean}
+ */
+function findAnnotationExpression( node, prop ) {
+  let isExpr = false;
+  if (prop[0] === '@') {
+    transformExpression(node, prop, {
+      '=': (p) => {
+        isExpr ||= isAnnotationExpression(p);
+      },
+    });
+  }
+
+  return isExpr;
+}
+
 module.exports = {
   getUtils,
-  cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
-  cloneCsnNonDict,
-  cloneCsnDictionary,
-  cloneAnnotationValue,
   isBuiltinType,
   isMagicVariable,
   isAnnotationExpression,
@@ -1473,6 +1429,7 @@ module.exports = {
   getResultingName,
   getUnderscoredName,
   getElementDatabaseNameOf,
+  transformExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
@@ -1491,7 +1448,6 @@ module.exports = {
   isAspect,
   hasValidSkipOrExists,
   getNamespace,
-  sortCsnDefinitionsForTests,
   getServiceNames,
   walkCsnPath,
   getVariableReplacement,
@@ -1502,4 +1458,5 @@ module.exports = {
   isAssociationOperand,
   isDollarSelfOrProjectionOperand,
   pathName,
+  findAnnotationExpression,
 };

package/lib/optionProcessor.js

@@ -41,7 +41,7 @@ optionProcessor
   .option('    --doc-comment')
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
-  .option('    --tenant-as-column')
+  .option('    --tenant-discriminator')
   .option('    --default-binary-length <length>')
   .option('    --default-string-length <length>')
   .option('    --no-recompile')
@@ -101,7 +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
+       --tenant-discriminator  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.

package/lib/render/manageConstraints.js

@@ -11,7 +11,7 @@ const { transformForRelationalDBWithCsn } = require('../transform/forRelationalD
 const {
   renderReferentialConstraint, getIdentifierUtils,
 } = require('./utils/sql');
-const { sortCsn } = require('../json/to-csn');
+const { sortCsn } = require('../model/cloneCsn');
 
 /**
  * Used only by `cdsc manageConstraints`.

package/lib/render/toCdl.js

@@ -15,8 +15,8 @@ const {
   isBuiltinType,
   generatedByCompilerVersion,
   getNormalizedQuery,
-  cloneCsnNonDict,
 } = require('../model/csnUtils');
+const { cloneFullCsn } = require('../model/cloneCsn');
 
 const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
 const specialFunctionKeywords = Object.create(null);
@@ -36,7 +36,7 @@ function csnToCdl( csn, options, msg ) {
   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.
-    csn = cloneCsnNonDict(csn, options);
+    csn = cloneFullCsn(csn, options);
     enrichUniversalCsn(csn, options);
   }
 
@@ -319,29 +319,38 @@ function csnToCdl( csn, options, msg ) {
       result += renderAnnotateParamsInParentheses(ext, env);
 
     // Element extensions and annotations (possibly nested)
-    // TODO: Deduplicate coding, see renderAnnotateStatementElements()
-    if (ext.elements)
-      result += ` ${renderAnnotateStatementElements(ext.elements, env.withSubPath([ 'elements' ]))}`;
-    else if (ext.enum)
-      result += ` ${renderAnnotateStatementElements(ext.enum, env.withSubPath([ 'enum' ]))}`;
-    else if (ext.returns)
+    if (ext.elements) {
+      env.path.push('elements');
+      result += ` ${renderAnnotateStatementElements(ext.elements, env)}`;
+      env.path.length -= 1;
+    }
+    else if (ext.enum) {
+      env.path.push('enum');
+      result += ` ${renderAnnotateStatementElements(ext.enum, env)}`;
+      env.path.length -= 1;
+    }
+    else if (ext.returns) {
       result += renderAnnotateReturns(ext, env);
+    }
 
     if (ext.actions) { // Bound action annotations
       result += ' actions {\n';
+      env.increaseIndent();
+      env.path.push('actions', '');
       for (const name in ext.actions) {
-        const childEnv = env.withIncreasedIndent().withSubPath([ 'actions', name ]);
+        env.path[env.path.length - 1] = name;
         const action = ext.actions[name];
-        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(name, childEnv);
+        result += renderAnnotationAssignmentsAndDocComment(action, env) + env.indent + quoteNonIdentifierOrKeyword(name, env);
         // Action parameter annotations
         if (action.params)
-          result += renderAnnotateParamsInParentheses(action, childEnv);
+          result += renderAnnotateParamsInParentheses(action, env);
         if (action.returns)
-          result += renderAnnotateReturns(action, childEnv);
+          result += renderAnnotateReturns(action, env);
 
         result = removeTrailingNewline(result);
         result += ';\n';
       }
+      env.decreaseIndent();
       result += `${env.indent}}`;
     }
 
@@ -361,18 +370,28 @@ function csnToCdl( csn, options, msg ) {
    */
   function renderAnnotateStatementElements( elements, env ) {
     let result = '{\n';
+    env.increaseIndent();
+    env.path.push('');
     for (const name in elements) {
-      const childEnv = env.withIncreasedIndent().withSubPath([ name ]);
+      env.path[env.path.length - 1] = name;
       const elem = elements[name];
-      result += renderAnnotationAssignmentsAndDocComment(elem, childEnv);
-      result += childEnv.indent + quoteNonIdentifierOrKeyword(name, env);
-      if (elem.elements)
-        result += ` ${renderAnnotateStatementElements(elem.elements, childEnv.withSubPath([ 'elements' ]))}`;
-      else if (elem.enum)
-        result += ` ${renderAnnotateStatementElements(elem.enum, childEnv.withSubPath([ 'enum' ]))}`;
+      result += renderAnnotationAssignmentsAndDocComment(elem, env);
+      result += env.indent + quoteNonIdentifierOrKeyword(name, env);
+      if (elem.elements) {
+        env.path.push('elements');
+        result += ` ${renderAnnotateStatementElements(elem.elements, env)}`;
+        env.path.pop();
+      }
+      else if (elem.enum) {
+        env.path.push('enum');
+        result += ` ${renderAnnotateStatementElements(elem.enum, env)}`;
+        env.path.pop();
+      }
 
       result += ';\n';
     }
+    env.path.length -= 1;
+    env.decreaseIndent();
     result += `${env.indent}}`;
     return result;
   }
@@ -456,8 +475,7 @@ function csnToCdl( csn, options, msg ) {
         return renderEvent(artifactName, art, env);
 
       default:
-        // TODO: Make it a error message.
-        throw new ModelError(`to.cdl: Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`to.cdl: Unknown artifact kind: '${art.kind}' at ${JSON.stringify(env.path)}`);
     }
   }
 
@@ -606,12 +624,14 @@ function csnToCdl( csn, options, msg ) {
 
     if (isCalcElement) { // calculated element // @ts-ignore
       result += ' = ';
-      if (element.value.xpr && xprContainsCondition(element.value.xpr))
-        result += exprRenderer.renderSubExpr(element.value, env.withSubPath([ 'value' ]));
-      else
-        result += exprRenderer.renderExpr(element.value, env.withSubPath([ 'value' ]));
+      env.path.push('value');
+      const isSubExpr = (element.value.xpr && xprContainsCondition(element.value.xpr));
+      result += isSubExpr
+        ? exprRenderer.renderSubExpr(element.value, env)
+        : exprRenderer.renderExpr(element.value, env);
       if (element.value.stored === true)
         result += ' stored';
+      env.path.length -= 1;
     }
 
     return `${result};\n`;
@@ -660,7 +680,6 @@ function csnToCdl( csn, options, msg ) {
 
     // Based on the current path, create a correctly nested structure
     // of elements for which we collect annotations.
-    // TODO: More properties?
     let obj = annotate;
     for (let i = 2; i < env.path.length; ++i) {
       const key = env.path[i];
@@ -746,13 +765,19 @@ function csnToCdl( csn, options, msg ) {
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `(${renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
+      env.path.push('args', 0);
+      let result = `(${renderViewSource(source.args[0], env)}`;
       for (let i = 1; i < source.args.length; i++) {
+        env.path[env.path.length - 1] = i;
         result += ` ${source.join} `;
         result += renderJoinCardinality(source.cardinality);
-        result += `join ${renderViewSource(source.args[i], env.withSubPath([ 'args', i ]))}`;
-        if (source.on)
-          result += ` on ${exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
+        result += `join ${renderViewSource(source.args[i], env)}`;
+      }
+      env.path.length -= 2;
+      if (source.on) {
+        env.path.push('on');
+        result += ` on ${exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
+        env.path.length -= 1;
       }
       result += ')';
       return result;
@@ -798,18 +823,12 @@ function csnToCdl( csn, options, msg ) {
     let result = renderDefinitionReference(firstArtifactName, env);
 
     // Even the first step might have parameters and/or a filter
+    env.path.push('ref', 0);
     if (path.ref[0].args)
-      result += `(${renderArguments(path.ref[0], ':', env.withSubPath([ 'ref', 0 ]))})`;
-
-    if (path.ref[0].where) {
-      // TODO: Unify with other filter rendering
-      const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
-      const expr = exprRenderer.renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ]));
-      if (expr.endsWith(']')) // for cases such as [… ![id] ]
-        result += `[ ${cardinality}${expr} ]`;
-      else
-        result += `[${cardinality}${expr}]`;
-    }
+      result += `(${renderArguments(path.ref[0], ':', env)})`;
+    if (path.ref[0].where)
+      result += renderFilterAndCardinality(path.ref[0], env);
+    env.path.length -= 2;
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
@@ -847,8 +866,12 @@ function csnToCdl( csn, options, msg ) {
    * @return {string}
    */
   function renderViewColumns( art, env, elements = Object.create(null) ) {
-    const result = art.columns.map((col, i) => renderViewColumn(col, env.withSubPath([ 'columns', i ]), findElement(elements, col)))
-      .join(',\n');
+    env.path.push( 'columns', -1 );
+    const result = art.columns.map((col, i) => {
+      env.path[env.path.length - 1] = i;
+      return renderViewColumn(col, env, findElement(elements, col));
+    }).join(',\n');
+    env.path.length -= 2;
     return `${result}\n`;
   }
 
@@ -869,8 +892,7 @@ function csnToCdl( csn, options, msg ) {
       //       of an `annotate` statement.  That may change in the future.
       result += renderDocComment(element, env);
     }
-    // Note: parentheses are a workaround for #9015; TODO: Check & Update
-    result += renderAnnotationAssignmentsAndDocComment(col, env, { parentheses: true });
+    result += renderAnnotationAssignmentsAndDocComment(col, env);
     result += env.indent;
 
     // only if column is virtual, keyword virtual was present in the source text
@@ -893,11 +915,13 @@ function csnToCdl( csn, options, msg ) {
 
     // Explicit type provided for the view element?
     if (col.cast) {
+      env.path.push('cast');
       // Special case: Explicit association type is actually a redirect
       if (col.cast.target && !col.cast.type)
-        result += ` : ${renderRedirectedTo(col.cast, env.withSubPath([ 'cast' ]))}`;
+        result += ` : ${renderRedirectedTo(col.cast, env)}`;
       else
-        result += ` : ${renderTypeReferenceAndProps(col.cast, env.withSubPath([ 'cast' ]), { typeRefOnly: true, noAnnoCollect: true })}`;
+        result += ` : ${renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
+      env.path.length -= 1;
     }
     return result;
   }
@@ -920,10 +944,12 @@ function csnToCdl( csn, options, msg ) {
 
     // We found a leaf - no further drilling
     if (!obj.inline && !obj.expand) {
+      env.path.push('cast');
       if (obj.cast && obj.cast.type)
-        result += ` : ${renderTypeReferenceAndProps(obj.cast, env.withSubPath([ 'cast' ]), { noAnnoCollect: true })}`;
+        result += ` : ${renderTypeReferenceAndProps(obj.cast, env, { noAnnoCollect: true })}`;
       else if (obj.cast && obj.cast.target) // test tbd
-        result += ` : ${renderRedirectedTo(obj.cast, env.withSubPath([ 'cast' ]))}`;
+        result += ` : ${renderRedirectedTo(obj.cast, env)}`;
+      env.path.length -= 1;
       return result;
     }
 
@@ -1023,17 +1049,24 @@ function csnToCdl( csn, options, msg ) {
 
     let result = '';
     const select = query.SELECT;
-    const childEnv = env.withIncreasedIndent();
 
     // If not a projection, must be view/entity.
     result += (syntax === 'projection') ? 'projection on ' : 'select from ';
-    result += renderViewSource(select.from, env.withSubPath([ 'from' ]));
+
+    env.path.push('from');
+    result += renderViewSource(select.from, env);
+    env.path.length -= 1;
 
     if (select.mixin) {
       let elems = '';
+      env.path.push('mixin', '');
+      env.increaseIndent();
       forEach(select.mixin, (name, mixin) => {
-        elems += renderElement(name, mixin, childEnv.withSubPath([ 'mixin', name ]));
+        env.path[env.path.length - 1] = name;
+        elems += renderElement(name, mixin, env);
       });
+      env.decreaseIndent();
+      env.path.length -= 2;
       if (elems) {
         result += ' mixin {\n';
         result += elems;
@@ -1043,10 +1076,13 @@ function csnToCdl( csn, options, msg ) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += renderViewColumns(select, env.withIncreasedIndent(), elements);
+      env.increaseIndent();
+      result += renderViewColumns(select, env, elements);
+      env.decreaseIndent();
       result += `${env.indent}}`;
     }
 
+    const childEnv = env.withIncreasedIndent();
     if (select.excluding) {
       const excludes = select.excluding.map(id => `${childEnv.indent}${quoteNonIdentifierOrKeyword(id, env)}`).join(',\n');
       result += ` excluding {\n${excludes}\n`;
@@ -1568,35 +1604,7 @@ function csnToCdl( csn, options, msg ) {
         result += `(${renderArguments(s, ':', env)})`;
       }
 
-      const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
-      let filter = '';
-
-      // TODO: Unify with other filter rendering for SELECT
-      if (s.groupBy)
-        filter += ` group by ${s.groupBy.map((expr, i) => exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
-      if (s.having)
-        filter += ` having ${exprRenderer.renderExpr(s.having, env.withSubPath([ 'having' ]))}`;
-      if (s.orderBy)
-        filter += ` order by ${s.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
-      if (s.limit)
-        filter += ` ${renderLimit(s.limit, env.withSubPath([ 'limit' ]))}`;
-
-      if (s.where) {
-        let where = exprRenderer.renderExpr(s.where, env.withSubPath([ 'where' ]));
-        // Special rules in CDS parser: If filter starts with one of these SQL keywords, WHERE is mandatory.
-        if (filter || /^(?:group|having|order|limit)\s/i.test(where))
-          where = ` where ${where}`;
-        filter = `${where} ${filter}`;
-      }
-
-      filter = filter.trim();
-
-      if (cardinality || filter) {
-        if (filter.endsWith(']')) // for cases such as [… ![id] ]
-          result += `[ ${cardinality}${filter} ]`;
-        else
-          result += `[${cardinality}${filter}]`;
-      }
+      result += renderFilterAndCardinality(s, env);
 
       return result;
     }
@@ -1690,8 +1698,6 @@ function csnToCdl( csn, options, msg ) {
   /**
    * Render a cardinality (only those parts that were actually provided)
    *
-   * TODO: Check srcmin as well?
-   *
    * @param {CSN.Artifact} art
    * @return {string}
    */
@@ -1706,13 +1712,11 @@ function csnToCdl( csn, options, msg ) {
     let result = '[';
     if (card.src !== undefined)
       result += `${card.src}, `;
-
     if (card.min !== undefined)
       result += `${card.min}..`;
-
     if (card.max !== undefined)
       result += card.max;
-
+    // srcmin can't be represented in CDL
     return `${result}]${suffix}`;
   }
 
@@ -1750,6 +1754,41 @@ function csnToCdl( csn, options, msg ) {
     return result;
   }
 
+
+  function renderFilterAndCardinality( s, env ) {
+    let result = '';
+    const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+    let filter = '';
+
+    // TODO: Unify with other filter rendering for SELECT
+    if (s.groupBy)
+      filter += ` group by ${s.groupBy.map((expr, i) => exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
+    if (s.having)
+      filter += ` having ${exprRenderer.renderExpr(s.having, env.withSubPath([ 'having' ]))}`;
+    if (s.orderBy)
+      filter += ` order by ${s.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
+    if (s.limit)
+      filter += ` ${renderLimit(s.limit, env.withSubPath([ 'limit' ]))}`;
+
+    if (s.where) {
+      let where = exprRenderer.renderExpr(s.where, env.withSubPath([ 'where' ]));
+      // Special rules in CDS parser: If filter starts with one of these SQL keywords, WHERE is mandatory.
+      if (filter || /^(?:group|having|order|limit)\s/i.test(where))
+        where = ` where ${where}`;
+      filter = `${where} ${filter}`;
+    }
+
+    filter = filter.trim();
+
+    if (cardinality || filter) {
+      if (filter.endsWith(']')) // for cases such as [… ![id] ]
+        result += `[ ${cardinality}${filter} ]`;
+      else
+        result += `[${cardinality}${filter}]`;
+    }
+    return result;
+  }
+
   function renderDefaultExpr( art, env ) {
     if (!art.default)
       return '';
@@ -1977,7 +2016,7 @@ function csnToCdl( csn, options, msg ) {
       SELECT(x) {
         return `(${renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
       },
-    }, true);
+    });
   }
 
   // checks -------------------------------------------------------------------
@@ -2135,6 +2174,12 @@ class CdlRenderEnvironment {
     Object.assign(this, values);
   }
 
+  increaseIndent() {
+    this.indent = `  ${this.indent}`;
+  }
+  decreaseIndent() {
+    this.indent = this.indent.substring(0, this.indent.length - 2);
+  }
   withIncreasedIndent() {
     return new CdlRenderEnvironment({ ...this, indent: `  ${this.indent}` });
   }

package/lib/render/toHdbcds.js

@@ -103,10 +103,6 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
   const {
     info, warning, error, throwWithAnyError, message,
   } = messageFunctions;
-  if (options.tenantAsColumn) {
-    error('api-unexpected-option', null, { option: 'tenantAsColumn', module: 'to.hdbcds' });
-    throwWithAnyError();
-  }
 
   const reportedMissingReplacements = Object.create(null);
 
@@ -140,7 +136,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     SET(x) {
       return `${renderQuery(x, false, this.env.withIncreasedIndent())}`;
     },
-  }, true);
+  });
 
   function renderExpr( x, env ) {
     return exprRenderer.renderExpr(x, env);