@sap/cds-compiler 4.3.2 → 4.4.2

package/lib/model/enrichCsn.js

@@ -42,6 +42,7 @@
 const { csnRefs, artifactProperties } = require('./csnRefs');
 const { locationString } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
+const { isAnnotationExpression } = require('../compiler/builtins');
 const shuffleGen = require('../base/shuffle');
 
 function enrichCsn( csn, options = {} ) {
@@ -61,7 +62,8 @@ function enrichCsn( csn, options = {} ) {
     includes: simpleRef,
     $origin,
     // TODO: excluding
-    '@': () => { /* ignore annotations */ },
+    '@': assignment,
+    $: () => { /* ignore properties like $location for performance */ },
   };
   // options.enrichCsn = 'DEBUG';
   let $$cacheObjectNumber = 0;   // for debugging
@@ -131,9 +133,30 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
+  function assignment( parent, prop, obj ) {
+    if (!obj || typeof obj !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ))
+      return;
+
+    csnPath.push( prop );
+    if (Array.isArray(obj)) {
+      obj.forEach( (n, i) => assignment( obj, i, n ) );
+    }
+    else {
+      const record = !isAnnotationExpression( obj ) && assignment;
+      // is record without `=` and other expression property
+      for (const name of Object.getOwnPropertyNames( obj ) ) {
+        const trans = record || transformers[name] || transformers[name.charAt(0)] || standard;
+        trans( obj, name, obj[name] );
+      }
+      if (!record && obj.$parens)
+        reveal( obj, '$parens', obj.$parens );
+    }
+    csnPath.pop();
+  }
+
   function refLocation( art ) {
     if (!art || typeof art !== 'object' || Array.isArray( art )) {
-      if (!options.testMode) {
+      if (catchRefError()) {
         return (typeof art === 'string')
           ? `<illegal ref = ${ art }>`
           : `<illegal ref: ${ typeof art }>`;
@@ -144,14 +167,14 @@ function enrichCsn( csn, options = {} ) {
       return art.$location;
     }
 
-    if (!options.testMode)
+    if (catchRefError())
       return `<${ Object.keys( art ).join('+') }+!$location>`;
     throw new CompilerAssertion( 'Reference to object without $location' );
   }
 
   function simpleRef( parent, prop, ref ) {
     // try {
-    const notFound = (options.testMode) ? undefined : null;
+    const notFound = (catchRefError()) ? null : undefined;
     if (Array.isArray( ref )) {
       parent[`_${ prop }`] = ref.map( r => refLocation( artifactRef( r, notFound ) ) );
     }
@@ -220,7 +243,7 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function handleError( callback ) {
-    if (options.testMode)
+    if (!catchRefError())
       return callback();
     try {
       return callback();
@@ -335,6 +358,11 @@ function enrichCsn( csn, options = {} ) {
         setLocations( node[name], isMember || name, loc );
     }
   }
+
+  function catchRefError() {
+    return !options.testMode || // false &&
+      csnPath.some( p => typeof p === 'string' && p.charAt(0) === '@');
+  }
 }
 
 

package/lib/model/revealInternalProperties.js

@@ -104,6 +104,8 @@ function revealInternalProperties( model, nameOrPath ) {
     $messageFunctions: () => '‹some functions›',
     $functions: () => '‹some functions›',
     $builtins: nameOrPath === '++' ? builtinsDictionary : () => '‹reveal with -R ++›',
+    tokenStream: ts => `‹${ ts?.tokens?.length ?? '?' } tokens›`,
+    parseListener: _ => '‹parseListener›',
   };
   uniqueId = -1;
   return revealXsnPath(nameOrPath, model);
@@ -292,6 +294,7 @@ function revealInternalProperties( model, nameOrPath ) {
   }
 
   function targetAspect( node, parent ) {
+    // TODO: avoid repeated display of same target aspect (includes)
     if (node.elements && node.__unique_id__ == null && node.$effectiveSeqNo == null)
       Object.defineProperty( node, '__unique_id__', { value: uniqueId-- } );
     return reveal( node, parent );
@@ -339,6 +342,8 @@ function artifactIdentifier( node, parent ) {
   }
   switch (node.kind) {
     case undefined:
+      if (node.name.id === '$self' && node.location.file === '')
+        return `type:${ quoted( '$self' ) }##0`;
       return (node._artifact && node._artifact.kind)
         ? artifactIdentifier( node._artifact )
         : JSON.stringify(node.name);

package/lib/modelCompare/compare.js

@@ -7,8 +7,7 @@ const {
   isPersistedAsTable,
   isPersistedAsView
 } = require('../model/csnUtils');
-const { isBetaEnabled } = require('../base/model');
-const { forEachKey } = require('../utils/objectUtils');
+const { forEachKey, forEach } = require('../utils/objectUtils');
 
 // used to mark a view as changed so we know to drop-create it
 const isChanged = Symbol('Marks a view as changed');
@@ -33,6 +32,7 @@ function compareModels(beforeModel, afterModel, options) {
   returnObj.extensions = [];
   returnObj.migrations = []; // element changes/removals or changes of entity properties
   returnObj.unchangedConstraints = new Set();
+  returnObj.changedPrimaryKeys = [];
 
   // There is currently no use in knowing the added entities only. If this changes, hand in `addedEntities` to `getArtifactComparator` below.
   forEachDefinition(afterModel, getExtensionAndMigrations(beforeModel, options, returnObj));
@@ -74,21 +74,43 @@ function validateCsnVersions(beforeModel, afterModel, options) {
  * @param {object} returnObj 
  * @returns {function}
  */
-function getExtensionAndMigrations(beforeModel, options, { extensions, migrations, unchangedConstraints }) {
+function getExtensionAndMigrations(beforeModel, options, { extensions, migrations, unchangedConstraints, changedPrimaryKeys }) {
   return function compareArtifacts(artifact, name) {
+    let hasPrimaryKeyChange = false;
+
     function addElements() {
       const elements = {};
-      forEachMember(artifact, getElementComparator(otherArtifact, elements), [ 'definitions', name ], true, { elementsOnly: true });
+      const keysNow = [];
+      forEachMember(artifact, (element, eName) => {
+        getElementComparator(otherArtifact, elements)(element, eName);
+        if(element.key)
+          keysNow.push(eName);
+      }, [ 'definitions', name ], true, { elementsOnly: true });
+
+      // Only do this check for to.hdi.migration - the order only "bites" us when doing .hdbmigrationtable as the end-check against the intended
+      // create-table will fail. TODO: Does a mismatched order of the primary key hurt us for postgres and others?
+      if(!hasPrimaryKeyChange && options.sqlDialect === 'hana' && options.src === 'hdi') {
+        const keysOther = [];
+        forEachMember(otherArtifact, (element, eName) => {
+          if(element.key)
+            keysOther.push(eName);
+        }, [ 'definitions', name ], true, { elementsOnly: true });
+
+        if(keysNow.join(',') !== keysOther.join(','))
+          hasPrimaryKeyChange = true;
+      }
+
       if (Object.keys(elements).length > 0) {
-        extensions.push(addedElements(name, elements));
+        const added = addedElements(name, elements);
+        if(!hasPrimaryKeyChange)
+          forEach(added.elements, (_name, element) => {
+            if(element.key && !element.target)
+              hasPrimaryKeyChange = true;
+          });    
+        extensions.push(added);
       }
     }
     function changePropsOrRemoveOrChangeElements() {
-      const relevantProperties = [
-        { name: 'doc' },
-        { name: '@sql.prepend' },
-        { name: '@sql.append' },
-      ];
       const changedProperties = {};
 
       const removedElements = {};
@@ -96,9 +118,9 @@ function getExtensionAndMigrations(beforeModel, options, { extensions, migration
 
       const migration = { migrate: name };
 
-      relevantProperties.forEach(prop => {
-        if (artifact[prop.name] !== otherArtifact[prop.name] && (!prop.beta || isBetaEnabled(options, prop.beta))) {
-          changedProperties[prop.name] = changedElement(artifact[prop.name], otherArtifact[prop.name] || null);
+      Object.keys(relevantProperties).forEach(prop => {
+        if (artifact[prop] !== otherArtifact[prop]) {
+          changedProperties[prop] = changedElement(artifact[prop], otherArtifact[prop] || null);
         }
       });
 
@@ -156,11 +178,25 @@ function getExtensionAndMigrations(beforeModel, options, { extensions, migration
       forEachMember(otherArtifact, getElementComparator(artifact, removedElements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(removedElements).length > 0) {
         migration.remove = removedElements;
+        if(!hasPrimaryKeyChange)
+          forEach(removedElements, (_name, change) => {
+            if(change.key && !change.target)
+              hasPrimaryKeyChange = true;
+          });
       }
 
       forEachMember(artifact, getElementComparator(otherArtifact, null, changedElements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(changedElements).length > 0) {
         migration.change = changedElements;
+        if(!hasPrimaryKeyChange)
+          forEach(changedElements, (_name, change) => {
+            if((change.old.key || change.new.key) && !change.new.target && !change.old.target) {
+              // For to.hdi.migration: Just drop-create (commented out), for to.sql.migration: Handle case where we add/remove "key" keyword, no drop-create otherwise
+              if(options.sqlDialect === 'hana' && options.src === 'hdi' || (!change.old.key || !change.new.key)) {
+                hasPrimaryKeyChange = true;
+              }
+            }
+          });
       }
 
       if (migration.properties || migration.remove || migration.change || migration.removeConstraints) {
@@ -193,6 +229,9 @@ function getExtensionAndMigrations(beforeModel, options, { extensions, migration
 
     addElements();
     changePropsOrRemoveOrChangeElements();
+    if(hasPrimaryKeyChange) {
+      changedPrimaryKeys.push(name);
+    }
   };
 }
 /**
@@ -317,6 +356,13 @@ function deepEqual(a, b, include = () => true, depth = 0) {
       : a === b;
 }
 
+
+const relevantProperties = {
+  'doc': true,
+  '@sql.prepend': true,
+  '@sql.append': true
+};
+
 /**
  * Returns whether any type parameters differ between two given elements. Ignores whether types themselves differ (`type` property).
  * @param element {object} an element
@@ -324,7 +370,23 @@ function deepEqual(a, b, include = () => true, depth = 0) {
  * @returns {boolean}
  */
 function typeParametersChanged(element, otherElement) {
-  return !deepEqual(element, otherElement, (key, depth) => !(depth === 0 && key === 'type'));
+  const checked = new Set();
+  for (const key in element) {
+    if (Object.prototype.hasOwnProperty.call(element, key))
+      if((!key.startsWith('@') || relevantProperties[key]) && key !== 'type') {
+        checked.add(key);
+        if(!deepEqual(element[key], otherElement[key]))
+          return true;
+      }  
+  }
+
+  for (const key in otherElement) {
+    if (Object.prototype.hasOwnProperty.call(otherElement, key))
+      if((!key.startsWith('@') || relevantProperties[key]) && key !== 'type' && !checked.has(key))
+        return true;
+  }
+
+  return false;
 }
 
 function addedElements(entity, elements) {

package/lib/modelCompare/utils/filter.js

@@ -38,6 +38,9 @@ module.exports = {
       warning('def-unsupported-constraint-drop', [ 'definitions', constraint.parentTable, 'elements', constraint.paths ? name : name.slice(constraint.parentTable.length + 1) ], { id: constraint.identifier || name, name: 'sqlite' },
               'Ignoring drop of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
       delete constraintRemovals[name];
+    },
+    function primaryKey() {
+      return false;
     }
   ),
   postgres: getFilterObject('postgres'),
@@ -46,7 +49,7 @@ module.exports = {
   csn: filterCsn,
 };
 
-function getFilterObject( dialect, extensionCallback, migrationCallback, removeConstraintsCallback ) {
+function getFilterObject( dialect, extensionCallback, migrationCallback, removeConstraintsCallback, primaryKeyCallback ) {
   return {
     // will be called with a simple Array.filter, as we need to filter constraint `ADD` for SQLite
     extension: ({
@@ -66,14 +69,12 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
       return returnValue;
     },
     // will be called with a Array.forEach
-    migration: ({
-      change, migrate, remove, removeConstraints,
-    }, { error, warning, message }) => {
-      forEach(remove, (name) => {
-        error('def-unsupported-element-drop', [ 'definitions', migrate, 'elements', name ], {}, 'Dropping elements is not supported');
+    migration: (migrations, { error, warning, message }) => {
+      forEach(migrations.remove, (name) => {
+        error('def-unsupported-element-drop', [ 'definitions', migrations.migrate, 'elements', name ], {}, 'Dropping elements is not supported');
       });
-      forEach(change, (name, migration) => {
-        const loc = [ 'definitions', migrate, 'elements', name ];
+      forEach(migrations.change, (name, migration) => {
+        const loc = [ 'definitions', migrations.migrate, 'elements', name ];
         if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
           error('type-unsupported-length-change', loc, { id: name }, 'Changed element $(ID) is a length reduction and is not supported');
         else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale)
@@ -83,9 +84,9 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
         else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
           error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported');
         else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
-          message('type-unsupported-key-change', [ 'definitions', migrate, 'elements', name ], { id: name, '#': 'changed' } );
+          message('type-unsupported-key-change', [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } );
         else if (migrationCallback)
-          migrationCallback(migrate, name, migration, change, error);
+          migrationCallback(migrations.migrate, name, migration, migrations.change, error);
 
         // TODO: precision/scale growth
       });
@@ -93,8 +94,8 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
       if (removeConstraintsCallback) {
         const constraintTypes = [ 'unique', 'referential' ];
         constraintTypes.forEach((constraintType) => {
-          forEach(removeConstraints?.[constraintType], (name, constraint) => {
-            removeConstraintsCallback(removeConstraints[constraintType], name, constraint, warning);
+          forEach(migrations.removeConstraints?.[constraintType], (name, constraint) => {
+            removeConstraintsCallback(migrations.removeConstraints[constraintType], name, constraint, warning);
           });
         });
       }
@@ -103,6 +104,12 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
       if (isPersistedAsTable(artifact))
         error('def-unsupported-table-drop', [ 'definitions', artifactName ], 'Dropping tables is not supported');
     },
+    changedPrimaryKeys: (changedPrimaryKeyArtifactName) => {
+      if (primaryKeyCallback)
+        return primaryKeyCallback(changedPrimaryKeyArtifactName);
+
+      return true;
+    },
   };
 }
 

package/lib/optionProcessor.js

@@ -227,6 +227,7 @@ 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' ] })
@@ -259,6 +260,7 @@ 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

package/lib/render/.eslintrc.json

@@ -2,6 +2,7 @@
   "plugins": ["sonarjs"],
   "extends": ["../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
+    "cds-compiler/message-no-quotes": "off",
     "prefer-const": "error",
     "quotes": ["error", "single", "avoid-escape"],
     "prefer-template": "error",
@@ -11,7 +12,6 @@
     "sonarjs/no-nested-template-literals": "off",
     "template-curly-spacing":["error", "never"],
     "class-methods-use-this": "off",
-    // Who cares - just very whiny and in the way
     "complexity": "off",
     "max-len": "off",
     "no-shadow": "warn"

package/lib/render/manageConstraints.js

@@ -67,6 +67,7 @@ function _transformSqlOptions( model, options ) {
   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') {

package/lib/render/toHdbcds.js

@@ -1336,6 +1336,9 @@ function toHdbcdsSource( csn, options ) {
 
         else if (x.ref[1] === 'locale')
           return 'SESSION_CONTEXT(\'LOCALE\')';
+
+        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')

package/lib/render/toRename.js

@@ -34,7 +34,9 @@ function toRename( inputCsn, options ) {
   options = Object.assign({ sqlMapping: 'hdbcds', sqlDialect: 'hana' }, options);
 
   // Verify options
-  optionProcessor.verifyOptions(options, 'toRename').forEach(complaint => warning(null, null, `${complaint}`));
+  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

package/lib/render/toSql.js

@@ -10,6 +10,7 @@ const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
 const {
   renderFunc, cdsToSqlTypes, getHanaComment, hasHanaComment,
   getSqlSnippets, createExpressionRenderer, withoutCast,
+  variableForDialect,
 } = require('./utils/common');
 const {
   getDeltaRenderer,
@@ -106,7 +107,7 @@ function toSqlDdl( csn, options ) {
     error, warning, info, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.sql');
   const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options);
-  let reportedMissingUserReplacement = false;
+  const reportedMissingReplacements = Object.create(null);
 
   const exprRenderer = createExpressionRenderer({
     // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
@@ -157,6 +158,7 @@ function toSqlDdl( csn, options ) {
     renderStringForSql,
     activateAlterMode,
     getHanaComment,
+    renderExpr,
   });
 
   // FIXME: Currently requires 'options.forHana', because it can only render HANA-ish SQL dialect
@@ -197,6 +199,15 @@ function toSqlDdl( csn, options ) {
   for (const artifactName in csn.deletions)
     renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], mainResultObj);
 
+
+  if (csn.changedPrimaryKeys && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
+    csn.changedPrimaryKeys = options.testMode ? sortCsn(csn.changedPrimaryKeys) : csn.changedPrimaryKeys;
+    csn.changedPrimaryKeys.forEach((artifactName) => {
+      const drop = render.dropKey(artifactName);
+      addMigration(mainResultObj, artifactName, true, render.concat(...drop));
+    });
+  }
+
   // Render each artifact extension
   // Only SAP HANA SQL is currently supported.
   // Note that extensions may contain new elements referenced in migrations, thus should be compiled first.
@@ -223,11 +234,19 @@ function toSqlDdl( csn, options ) {
         // There is no "migrations" property in client CSN, so for better locations, use
         // a path to the definition.
         const env = new SqlRenderEnvironment({ path: [ 'definitions', artifactName ] });
-        renderArtifactMigrationInto(artifactName, migration, mainResultObj, env);
+        renderArtifactMigrationInto(artifactName, csn.definitions[artifactName], migration, mainResultObj, env);
       }
     }
   }
 
+  if (csn.changedPrimaryKeys && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
+    csn.changedPrimaryKeys = options.testMode ? sortCsn(csn.changedPrimaryKeys) : csn.changedPrimaryKeys;
+    csn.changedPrimaryKeys.forEach((artifactName) => {
+      const add = render.addKey(artifactName, csn.definitions[artifactName].elements);
+      addMigration(mainResultObj, artifactName, true, render.concat(...add));
+    });
+  }
+
   // trigger artifact and element name checks
   definitionsDuplicateChecker.check(error, options);
   extensionsDuplicateChecker.check(error);
@@ -360,7 +379,7 @@ function toSqlDdl( csn, options ) {
 
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
   // Only SAP HANA SQL is currently supported.
-  function renderArtifactMigrationInto( artifactName, migration, resultObj, env ) {
+  function renderArtifactMigrationInto( artifactName, artifact, migration, resultObj, env ) {
     function reducesTypeSize( def ) {
       // HANA does not allow decreasing the value of any of those type parameters.
       return def.old.type === def.new.type &&
@@ -501,9 +520,8 @@ function toSqlDdl( csn, options ) {
             : render.addColumnsFromElementsObj(artifactName, { [eltName]: def.new }, env);
           addMigration(resultObj, artifactName, true, render.concat(...drop, ...add));
         }
-        else {
-          // Lossless change: no associations directly affected, no size reduction.
-          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew));
+        else { // Lossless change: no associations directly affected, no size reduction.
+          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')));
         }
       }
     }
@@ -649,12 +667,6 @@ function toSqlDdl( csn, options ) {
     const associations = render.addAssociations(artifactName, extElements, env);
     if (elements.length + associations.length > 0)
       addMigration(resultObj, artifactName, false, [ ...elements, ...associations ]);
-
-    if (Object.values(extElements).some(elt => elt.key)) {
-      const drop = render.dropKey(artifactName);
-      const add = render.addKey(artifactName, artifactElements);
-      addMigration(resultObj, artifactName, true, render.concat(...drop, ...add));
-    }
   }
 
   function addMigration( resultObj, artifactName, drop, sqlArray, description ) {
@@ -1529,95 +1541,37 @@ function toSqlDdl( csn, options ) {
    * @returns {string|null} Null in case of an invalid second path step
    */
   function render$user( x ) {
-    // FIXME: this is all not enough: we might need an explicit select item alias (?)
-    if (x.ref[1] === 'id') {
-      if (options.sqlDialect === 'hana')
-        return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
-      else if (options.sqlDialect === 'postgres')
-        return 'current_setting(\'cap.applicationuser\')';
-      else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
-        return 'session_context( \'$user.id\' )';
-      else if (options.sqlDialect === 'h2')
-        return '@applicationuser';
-
-      if (!reportedMissingUserReplacement) {
-        warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
-        reportedMissingUserReplacement = true;
-      }
-      return '\'$user.id\'';
-    }
-    else if (x.ref[1] === 'locale') {
-      if (options.sqlDialect === 'hana')
-        return 'SESSION_CONTEXT(\'LOCALE\')';
-      else if (options.sqlDialect === 'postgres')
-        return 'current_setting(\'cap.locale\')';
-      else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
-        return 'session_context( \'$user.locale\' )';
-      else if (options.sqlDialect === 'h2')
-        return '@locale';
-
-      return '\'en\''; // default language
+    if (x.ref.length > 2 || typeof x.ref[1] !== 'string')
+      return null; // `$user` can only have two path steps
+
+    const name = `$user.${x.ref[1]}`;
+    const result = variableForDialect(options, name);
+    if (result)
+      return result;
+
+    if (!reportedMissingReplacements[name]) {
+      reportedMissingReplacements[name] = true;
+      warning('ref-unsupported-variable', null, { name, option: 'variableReplacements' },
+              'Variable $(NAME) is not supported. Use option $(OPTION) to specify a value for $(NAME)');
     }
-    // Basically: Second path step was invalid, do nothing - should not happen.
-    return null;
+    return `'${name}'`;
   }
 
   /**
-   * For a given reference starting with $at, render a 'current_timestamp' literal for plain.
-   * For the sql-dialect hana, we render the TO_TIMESTAMP(SESSION_CONTEXT(..)) function.
-   *
-   *
-   * For sqlite, we render the string-format-time (strftime) function.
-   * Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
-   * the format for TimeStamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
-   * --> Therefore the comparison in the temporal where clause doesn't work properly.
-   *
    * @param {object} x
    * @returns {string|null} Null in case of an invalid second path step
    */
   function render$at( x ) {
-    if (x.ref[1] === 'from') {
-      switch (options.sqlDialect) {
-        case 'sqlite': {
-          if (options.betterSqliteSessionVariables)
-            return 'session_context( \'$valid.from\' )';
-          const dateFromFormat = '%Y-%m-%dT%H:%M:%S.000Z';
-          return `strftime('${dateFromFormat}', 'now')`;
-        }
-        case 'hana':
-          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
-        case 'postgres':
-          return 'current_setting(\'cap.valid_from\')::timestamp';
-        case 'h2':
-          return '@valid_from';
-        case 'plain':
-          return 'current_timestamp';
-        default:
-          break;
-      }
-    }
+    if (x.ref.length > 2 || typeof x.ref[1] !== 'string')
+      return null; // `$at` can only have two path steps
 
-    if (x.ref[1] === 'to') {
-      switch (options.sqlDialect) {
-        case 'sqlite': {
-          if (options.betterSqliteSessionVariables)
-            return 'session_context( \'$valid.to\' )';
-          // + 1ms compared to $at.from
-          const dateToFormat = '%Y-%m-%dT%H:%M:%S.001Z';
-          return `strftime('${dateToFormat}', 'now')`;
-        }
-        case 'hana':
-          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
-        case 'postgres':
-          return 'current_setting(\'cap.valid_to\')::timestamp';
-        case 'h2':
-          return '@valid_to';
-        case 'plain':
-          return 'current_timestamp';
-        default:
-          break;
-      }
-    }
+    const name = `$at.${x.ref[1]}`;
+    const config = variableForDialect(options, name);
+    if (config)
+      return config;
+
+    if (options.testMode)
+      throw new CompilerAssertion(`render$at: unhandled sqlDialect '${options.sqlDialect}' when rendering ${x.ref.join('.')}`);
     return null;
   }