@sap/cds-compiler 4.4.4 → 4.6.0

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')
@@ -227,10 +229,9 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-foreign-keys')
   .option('    --odata-v2-partial-constr')
   .option('    --odata-vocabularies <list>')
-  .option('    --odata-open-type')
   .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(`
@@ -260,7 +261,6 @@ optionProcessor.command('O, toOdata')
                                    (Not spec compliant and V2 only)
        --odata-vocabularies <list> JSON array of adhoc vocabulary definitions
                                    { prefix: { alias, ns, uri }, ... }
-       --odata-open-type        Renders all structured types as OpenType=true, if not annotated otherwise.
    -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toHana or "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores
@@ -287,24 +287,25 @@ 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')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables')
   .option('    --fewer-localized-views')
+  .option('    --without-hana-associations')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -360,12 +361,12 @@ optionProcessor.command('Q, toSql')
                               active if sqlDialect is \`sqlite\`
    --fewer-localized-views    If set, the backends will not create localized convenience views for
                               those views, that only have an association to a localized entity/view.
-
+   --without-hana-associations   If set, the backend will not render a "WITH ASSOCIATIONS" for sqlDialect 'hana'
 `);
 
 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...>
 
@@ -387,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...>
 
@@ -433,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 } = 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;
 
@@ -589,11 +582,11 @@ function csnToCdl( csn, options ) {
    * @param {CdlRenderEnvironment} env
    */
   function renderElement( elementName, element, env ) {
+    const isCalcElement = (element.value !== undefined);
     let result = renderAnnotationAssignmentsAndDocComment(element, env);
     result += env.indent;
     result += element.virtual ? 'virtual ' : '';
     result += element.key ? 'key ' : '';
-    // TODO(v5): Remove once deprecated flag for `masked` is removed.
     result += element.masked ? 'masked ' : '';
     result += quoteNonIdentifierOrKeyword(elementName, env);
     if (element.val !== undefined) { // enum value
@@ -602,13 +595,16 @@ function csnToCdl( csn, options ) {
     else if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${element['#']}`;
     }
-    else {
+    else if (!isCalcElement || !isDirectAssocOrComp(element.type)) {
+      // If the element is a calculated element _and_ a direct association or
+      // composition, we'd render `Association to F on (cond) = calcValue;` which
+      // would alter the ON-condition.
       const props = renderTypeReferenceAndProps(element, env);
       if (props !== '')
         result += ` : ${props}`;
     }
 
-    if (element.value !== undefined) { // calculated element // @ts-ignore
+    if (isCalcElement) { // calculated element // @ts-ignore
       result += ' = ';
       if (element.value.xpr && xprContainsCondition(element.value.xpr))
         result += exprRenderer.renderSubExpr(element.value, env.withSubPath([ 'value' ]));
@@ -873,7 +869,7 @@ function csnToCdl( csn, options ) {
       //       of an `annotate` statement.  That may change in the future.
       result += renderDocComment(element, env);
     }
-    // Note: parentheses are a workaround for #9015
+    // Note: parentheses are a workaround for #9015; TODO: Check & Update
     result += renderAnnotationAssignmentsAndDocComment(col, env, { parentheses: true });
     result += env.indent;
 
@@ -1316,7 +1312,7 @@ function csnToCdl( csn, options ) {
     }
 
     // Association type
-    if (type === 'cds.Association' || type === 'cds.Composition') {
+    if (isDirectAssocOrComp(type)) {
       const isComp = type === 'cds.Composition';
       // Type, cardinality and target; CAPire uses CamelCase
       result += isComp ? 'Composition' : 'Association';
@@ -1350,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;
     }
 
@@ -1383,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;
   }
@@ -1460,11 +1456,7 @@ function csnToCdl( csn, options ) {
    * @param {CdlRenderEnvironment} env
    */
   function renderAnnotationValue( annoValue, env ) {
-    // TODO: There must be at least one known expression property, otherwise
-    //       it could be `type: 'unchecked'`.
-    const isXpr = annoValue?.['='] !== undefined && (Object.keys(annoValue).length > 1) &&
-        isBetaEnabled(options, 'annotationExpressions');
-    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) {
@@ -1852,7 +1855,7 @@ function csnToCdl( csn, options ) {
     name = name.substring(1);
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
-    const nameBeforeVariant = parts[0];
+    let nameBeforeVariant = parts[0];
     const variant = parts.length > 1 ? parts.slice(1).join('#') : undefined;
     const { parentheses } = config;
 
@@ -1860,8 +1863,13 @@ function csnToCdl( csn, options ) {
     if (parentheses)
       result += '(';
 
+    // if the variant is empty, render '#' as part of the name, e.g `variant !== undefined`.
+    if (variant === '')
+      nameBeforeVariant += '#';
+
     result += quoteAnnotationPathIfRequired(nameBeforeVariant, env);
-    if (variant !== undefined) {
+
+    if (variant !== undefined && variant !== '') {
       // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
       // nor multiple `#`, so we're back at simple paths that are possibly quoted.
       result += `#${quotePathIfRequired(variant, env)}`;
@@ -1939,7 +1947,7 @@ function csnToCdl( csn, options ) {
       aliasOnly: x => x.as,
       enum: x => `#${x['#']}`,
       ref(x) {
-        return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
+        return `${x.param ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
       },
       windowFunction(x) {
         const funcDef = this.func(x);
@@ -2182,6 +2190,19 @@ function requiresQuotingForCdl( id, additionalKeywords ) {
     additionalKeywords.includes(id.toUpperCase());
 }
 
+/**
+ * Returns true if the given type is an association or composition,
+ * without type indirection.
+ *
+ * @param {string|string[]} type
+ * @return {boolean}
+ */
+
+function isDirectAssocOrComp( type ) {
+  type = normalizeTypeRef(type);
+  return (type === 'cds.Association' || type === 'cds.Composition');
+}
+
 const conditionOperators = [
   // Antlr rule 'condition', 'conditionAnd'
   'AND', 'OR',

package/lib/render/toHdbcds.js

@@ -4,12 +4,14 @@ const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
   getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
+  pathName, isMagicVariable,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
   renderFunc, createExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
   hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
-  cdsToSqlTypes, cdsToHdbcdsTypes, withoutCast,
+  cdsToSqlTypes, cdsToHdbcdsTypes, withoutCast, variableForDialect,
+  isVariableReplacementRequired,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -17,11 +19,11 @@ const {
 const DuplicateChecker = require('./DuplicateChecker');
 const { isDeprecatedEnabled, forEachDefinition } = require('../base/model');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { makeMessageFunction } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
 const { ModelError, CompilerAssertion } = require('../base/error');
+const { pathId } = require('../model/csnRefs');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';
@@ -89,9 +91,10 @@ function renderStringForHdbcds( str ) {
  *
  * @param {CSN.Model} csn HANA transformed CSN
  * @param {CSN.Options} [options] Transformation options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} Dictionary of filename: content
  */
-function toHdbcdsSource( csn, options ) {
+function toHdbcdsSource( csn, options, messageFunctions ) {
   timetrace.start('HDBCDS rendering');
   const plainNames = options.sqlMapping === 'plain';
   const quotedNames = options.sqlMapping === 'quoted';
@@ -99,7 +102,13 @@ function toHdbcdsSource( csn, options ) {
 
   const {
     info, warning, error, throwWithAnyError, message,
-  } = makeMessageFunction(csn, options, 'to.hdbcds');
+  } = messageFunctions;
+  if (options.tenantAsColumn) {
+    error('api-unexpected-option', null, { option: 'tenantAsColumn', module: 'to.hdbcds' });
+    throwWithAnyError();
+  }
+
+  const reportedMissingReplacements = Object.create(null);
 
   const exprRenderer = createExpressionRenderer({
     finalize: x => x,
@@ -732,7 +741,7 @@ function toHdbcdsSource( csn, options ) {
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `.${renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `.${renderTypeRef({ ref: path.ref.slice(1) }, env)}`;
 
     return result;
   }
@@ -1209,11 +1218,10 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string|object} s Path step
    * @param {number} idx Path position
-   * @param {any[]} ref
    * @param {HdbcdsRenderEnvironment} env
    * @returns {string} Rendered path step
    */
-  function renderPathStep( s, idx, ref, env ) {
+  function renderPathStep( s, idx, env ) {
     // Simple id or absolute name
     if (typeof s === 'string') {
       // HANA-specific extra magic (should actually be in forRelationalDB)
@@ -1227,12 +1235,6 @@ function toHdbcdsSource( csn, options ) {
         return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
           : renderAbsoluteNameWithQuotes(env.currentArtifactName, env);
       }
-      // HANA-specific translation of '$now' and '$user'
-      if (s === '$now' && ref.length === 1)
-        return 'CURRENT_TIMESTAMP';
-
-      // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
-      // FIXME: We should rather explicitly recognize quoting somehow
 
       // TODO: quote $parameters if it doesn't reference a parameter, this requires knowledge about the kind
       // Example: both views are correct in HANA CDS
@@ -1316,42 +1318,61 @@ function toHdbcdsSource( csn, options ) {
     return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', this.env));
   }
 
+
   /**
-   * @param {object} x Expression with a ref property
-   * @returns {string} Rendered expression
-   * @todo no extra magic with x.param or x.global
+   * Render a magic variable.  Values are determined in following order:
+   *   1. User defined replacement in options.variableReplacements
+   *   2. Predefined fallback values
+   *   3. Rendering of the variable as a string (i.e. its name) + warning
+   *
+   * @param {CSN.Path} ref
+   * @param {object} env
+   * @return {string}
    */
-  function renderExpressionRef( x ) {
-    if (!x.param && !x.global) {
-      const magicReplacement = getVariableReplacement(x.ref, options);
-      if (x.ref[0] === '$user') {
-        if (magicReplacement !== null)
-          return renderStringForHdbcds(magicReplacement);
+  function renderMagicVariable( ref, env ) {
+    const magicReplacement = getVariableReplacement(ref, options);
+    if (magicReplacement !== null)
+      return renderStringForHdbcds(magicReplacement);
+
+    const name = pathName(ref);
+    const result = variableForDialect(options, name);
+    if (result)
+      return result;
 
-        // Note: The compiler already transforms $user into $user.id.
+    if (isVariableReplacementRequired(name)) {
+      reportedMissingReplacements[name] = true;
+      error('ref-undefined-var', env.path, { '#': 'value', id: name, option: 'variableReplacements' });
+    }
+    else if (!reportedMissingReplacements[name]) {
+      reportedMissingReplacements[name] = true;
+      warning('ref-unsupported-variable', env.path, { name, option: 'variableReplacements' },
+              'Variable $(NAME) is not supported. Use option $(OPTION) to specify a value for $(NAME)');
+    }
 
-        // FIXME: this is all not enough: we might need an explicit select item alias (?)
-        if (x.ref[1] === 'id')
-          return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
+    return renderStringForHdbcds(name);
+  }
 
-        else if (x.ref[1] === 'locale')
-          return 'SESSION_CONTEXT(\'LOCALE\')';
+  /**
+   * Must not be used for type refs, as something like `$user` will be interpreted as a magic
+   * variable and not definition name.
+   *
+   * @param {object} x Expression with a ref property
+   * @returns {string} Rendered expression
+   * @todo no extra magic with x.param
+   */
+  function renderExpressionRef( x ) {
+    if (!x.param && isMagicVariable(pathId(x.ref[0])))
+      return renderMagicVariable(x.ref, this.env);
 
-        else if (x.ref[1] === 'tenant')
-          return 'SESSION_CONTEXT(\'TENANT\')';
-      }
-      else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
-        if (x.ref[1] === 'from')
-          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
+    const prefix = x.param ? ':' : '';
+    const ref = x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.');
+    return `${prefix}${ref}`;
+  }
 
-        else if (x.ref[1] === 'to')
-          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
-      }
-      else if (x.ref[0] === '$session' && magicReplacement !== null) {
-        return renderStringForHdbcds(magicReplacement);
-      }
-    }
-    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
+  function renderTypeRef( x, env ) {
+    const prefix = x.param ? ':' : '';
+    const ref = x.ref.map((step, index) => renderPathStep(step, index, env.withSubPath([ 'ref', index ]))).join('.');
+    return `${prefix}${ref}`;
   }
 
   /**

package/lib/render/toRename.js

@@ -1,10 +1,8 @@
 
 'use strict';
 
-const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { forEachDefinition } = require('../model/csnUtils');
-const { optionProcessor } = require('../optionProcessor');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 const { getIdentifierUtils } = require('./utils/sql');
 
@@ -25,25 +23,23 @@ const { getIdentifierUtils } = require('./utils/sql');
  * @todo clarify input parameters
  * @param {CSN.Model} inputCsn CSN?
  * @param {CSN.Options} options Transformation options
+ * @param {object} messageFunctions
  * @returns {object} A dictionary of name: rename statement
  */
-function toRename( inputCsn, options ) {
-  const { warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
+function toRename( inputCsn, options, messageFunctions ) {
+  const { warning, throwWithError } = messageFunctions;
 
   // Merge options with defaults.
+  // TODO: Use api/options.js if this ever becomes an official API.
   options = Object.assign({ sqlMapping: 'hdbcds', sqlDialect: 'hana' }, options);
-
-  // Verify options
-  optionProcessor.verifyOptions(options, 'toRename')
-    // eslint-disable-next-line cds-compiler/message-template-string
-    .forEach(complaint => warning(null, null, `${complaint}`));
   checkCSNVersion(inputCsn, options);
 
   // Let users know that this is internal
   warning(null, null, 'Generation of SQL rename statements is a beta feature and might change in the future');
 
   // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
-  const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
+  const csn = transformForRelationalDBWithCsn(inputCsn, options, messageFunctions);
+  messageFunctions.setModel(csn);
   const hdbcdsOrQuotedIdentifiers = getIdentifierUtils(csn, options);
   const plainIdentifiers = getIdentifierUtils(csn, { sqlDialect: 'hana', sqlMapping: 'plain' });