@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/render/toCdl.js

@@ -20,7 +20,6 @@ const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
  * Returned object has the following properties:
  *  - `model`: CSN model rendered as CDL (string).
  *  - `namespace`: Namespace statement + `using from './model.cds'.
- *  - `unappliedExtensions`: Annotations / Extensions from the `csn.extensions` array.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} [options]
@@ -45,17 +44,14 @@ function csnToCdl(csn, options) {
 
   if (csn.vocabularies)
     cdlResult.model += renderVocabularies(csn.vocabularies);
+  if (csn.extensions)
+    cdlResult.model += renderExtensions(csn.extensions, createEnv());
 
   if (csn.namespace) {
     cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace)};\n`;
     cdlResult.namespace += 'using from \'./model.cds\';';
   }
 
-  // If there are extensions, such as 'extend' and 'annotate' statements, render them separately.
-  // Used for e.g. parseCdl-style CSN or Universal CSN.
-  if (csn.extensions)
-    cdlResult.unappliedExtensions = renderExtensions(csn.extensions, createEnv());
-
   timetrace.stop();
   return cdlResult;
 
@@ -109,7 +105,9 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderExtensions(extensions, env) {
-    return extensions.map(ext => renderExtension(ext, env)).join('\n');
+    if (!env.path)
+      env = envNewPath(env, [ 'extensions' ]);
+    return extensions.map((ext, index) => renderExtension(ext, envAddPath(env, [ index ]))).join('\n');
   }
 
   /**
@@ -353,13 +351,14 @@ function csnToCdl(csn, options) {
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
         return renderEntity(artifactName, art, env);
+      case 'aspect':
+        return renderAspect(artifactName, art, env);
 
       case 'context':
       case 'service':
         return renderContextOrService(artifactName, art, env);
 
       case 'type':
-      case 'aspect':
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
         return renderTypeOrAnnotation(artifactName, art, env);
 
@@ -382,7 +381,6 @@ function csnToCdl(csn, options) {
    */
   function renderEvent(artifactName, art, env) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    const childEnv = increaseIndent(env);
     const normalizedArtifactName = renderArtifactName(artifactName);
     result += `${env.indent}event ${normalizedArtifactName}`;
     if (art.includes)
@@ -398,11 +396,7 @@ function csnToCdl(csn, options) {
       result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
     }
     else if (art.elements) {
-      result += ' {\n';
-      for (const name in art.elements)
-        result += renderElement(name, art.elements[name], childEnv);
-
-      result += `${env.indent}}`;
+      result += ` ${renderElements(art, env)};\n`;
     }
     return result;
   }
@@ -434,21 +428,57 @@ function csnToCdl(csn, options) {
 
     if (art.params)
       result += renderParameters(art, env);
+    if (art.includes)
+      result += renderIncludes(art.includes);
+    result += ` ${renderElements(art, env)}`;
+    result += `${renderActionsAndFunctions(art, env)};\n`;
+    return result;
+  }
 
+  /**
+   * Render an aspect. Return the resulting source string.
+   * Behaves very similar to renderEntity, _except_ that aspects are
+   * allowed to _not_ have elements, e.g. `aspect A;`.
+   *
+   * @param {string} artifactName
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderAspect(artifactName, art, env) {
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent}aspect ${renderArtifactName(artifactName)}`;
     if (art.includes)
       result += renderIncludes(art.includes);
-    result += ' {\n';
-    const childEnv = increaseIndent(env);
-    for (const name in art.elements) {
-      const element = art.elements[name];
-      result += renderElement(name, element, childEnv);
-    }
 
-    result += `${env.indent}}`;
+    if (art.elements)
+      result += ` ${renderElements(art, env)}`;
+    else if (art.actions)
+      // if there are no elements, but actions, CDL syntax requires braces.
+      result += ' { }';
+
     result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
   }
 
+  /**
+   * Render a list of elements enclosed in braces.  If the list is empty, returns `{ }`.
+   *
+   * @param {object} artifact Artifact with `elements` property.
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderElements(artifact, env) {
+    let elements = '';
+    const childEnv = increaseIndent(env);
+    for (const name in artifact.elements)
+      elements += renderElement(name, artifact.elements[name], childEnv, null);
+
+    if (elements === '')
+      return '{ }';
+    return `{\n${elements}${env.indent}}`;
+  }
+
   /**
    * Render an element (of an entity, type or annotation, not a projection or view).
    * Return the resulting source string.
@@ -471,27 +501,6 @@ function csnToCdl(csn, options) {
     return `${result};\n`;
   }
 
-  /**
-   * Render a query's actions and functions (if any) separately as extend-statements, so that actions
-   * work not only for projections but also for views, which have no syntax (yet) to directly specify
-   * actions and functions inline.
-   * Return the resulting 'extend' statement or '' if no actions or functions
-   * FIXME: Simplify once we have such a syntax
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderQueryActionsAndFunctions(artifactName, art, env) {
-    let result = renderActionsAndFunctions(art, env);
-    // Even if we have seen actions/functions, they might all have been ignored
-    if (result !== '')
-      result = `${env.indent}extend entity ${artifactName} with${result};`;
-
-    return result;
-  }
-
   /**
    * Render annotations that were extended to a query element of a view or projection (they only
    * appear in the view's 'elements', not in their 'columns' for client CSN, because the element
@@ -507,8 +516,8 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderQueryElementAnnotations(artifactName, art, env) {
-    const annotate = collectAnnotationsOfElements(art, { artifactName, path: env.path });
+  function renderQueryElementAndEnumAnnotations(artifactName, art, env) {
+    const annotate = collectAnnotationsOfElementsAndEnum(art, { artifactName, path: env.path });
     if (annotate)
       return renderExtensions([ annotate ], env);
     return '';
@@ -518,17 +527,20 @@ function csnToCdl(csn, options) {
    * Create an "annotate" statement as a CSN extension for all annotations of (sub-)elements.
    * If no annotation was found, we return `null`.
    *
-   * @param {CSN.Artifact} artWithElements
+   * @param {CSN.Artifact} artifact
    * @param {CdlRenderEnvironment} env
    * @return {CSN.Extension|null}
    */
-  function collectAnnotationsOfElements(artWithElements, env) {
-    // Array of structures, which may be annotated as well.
-    if (!artWithElements.elements && artWithElements.items) {
+  function collectAnnotationsOfElementsAndEnum(artifact, env) {
+    // Array, which may be annotated as well.
+    if (artifact.items) {
       env = envAddPath(env, [ 'items' ]);
-      artWithElements = artWithElements.items;
+      artifact = artifact.items;
     }
 
+    if (!artifact.elements && !artifact.enum)
+      return null;
+
     const annotate = { annotate: env.path[1] };
 
     // Based on the current path, create a correctly nested structure
@@ -551,22 +563,26 @@ function csnToCdl(csn, options) {
         // ignore others, e.g. 'items'
       }
     }
-    return collectAnnos(obj, artWithElements) ? annotate : null;
+    return collectAnnos(obj, artifact) ? annotate : null;
 
     /**
      * Recursive function to collect annotations. `annotateObj` will get an `elements`
-     * object with annotations only if there are annotations on `art`'s (sub-)elements.
+     * object with annotations only if there are annotations on `art`'s (sub-)elements or
+     * enums.  Returned object will use "elements" even for enums, since that is
+     * expected in extensions.
      *
      * @return {boolean} True, if there were annotations, false otherwise.
      */
     function collectAnnos(annotateObj, art) {
-      if (!art.elements)
+      if (!art.elements && !art.enum)
         return false;
 
+      const dictKey = art.elements ? 'elements' : 'enum';
+      // Use "elements" for both enums and elements. This is allowed in extensions.
       const collected = { elements: Object.create(null) };
       let hasAnnotation = false;
 
-      forEach(art.elements, (elemName, element) => {
+      forEach(art[dictKey], (elemName, element) => {
         if (!collected.elements[elemName])
           collected.elements[elemName] = { };
 
@@ -667,7 +683,7 @@ function csnToCdl(csn, options) {
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
-      result += `(${renderArgs(path.ref[0], ':', env)})`;
+      result += `(${renderArguments(path.ref[0], ':', env)})`;
 
     if (path.ref[0].where) {
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
@@ -848,14 +864,17 @@ function csnToCdl(csn, options) {
   function renderView(artifactName, art, env) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}${art.abstract ? 'abstract ' : ''}${syntax === 'projection' ? 'entity' : syntax} ${renderArtifactName(artifactName)}`;
+    result += `${env.indent}entity ${renderArtifactName(artifactName)}`;
     if (art.params)
       result += renderParameters(art, env);
     result += ' as ';
     result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
+    if (art.actions) // Views/Projections also allow actions. Just the VIEW keyword variant did not.
+      result += renderActionsAndFunctions(art, env);
     result += ';\n';
-    result += renderQueryElementAnnotations(artifactName, art, env);
-    result += renderQueryActionsAndFunctions(artifactName, art, env);
+    result += renderQueryElementAndEnumAnnotations(artifactName, art, env);
+    if (art.includes)
+      result += renderExtension({ extend: artifactName, includes: art.includes }, env);
     return result;
   }
 
@@ -1108,8 +1127,7 @@ function csnToCdl(csn, options) {
       result += ` ${renderTypeReferenceAndProps(art, env)}`;
     else
       result += ` : ${renderTypeReferenceAndProps(art, env)}`;
-    // for aspects, but since types don't have `actions` this does not hurt
-    result += `${renderActionsAndFunctions(art, env)};\n`;
+    result += ';\n';
     return result;
   }
 
@@ -1145,12 +1163,7 @@ function csnToCdl(csn, options) {
     }
 
     if (!artifact.type && artifact.elements) {
-      result += '{\n';
-      const childEnv = envAddPath(increaseIndent(env), 'items');
-      for (const name in artifact.elements)
-        result += renderElement(name, artifact.elements[name], childEnv, null);
-
-      result += `${env.indent}}`;
+      result += renderElements(artifact, env);
       if (!isTypeDef)
         result += renderNullability(artifact);
       // structured default not possible at the moment
@@ -1174,12 +1187,7 @@ function csnToCdl(csn, options) {
       }
       else if (elements) {
         // anonymous aspect, either parseCdl or client CSN.
-        const childEnv = increaseIndent(env);
-        result += '{\n';
-        for (const name in elements)
-          result += renderElement(name, elements[name], childEnv);
-
-        result += `${env.indent}}`;
+        result += renderElements({ elements }, env);
       }
       else {
         throw new ModelError('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
@@ -1205,10 +1213,12 @@ function csnToCdl(csn, options) {
 
     // If we have a type and elements, we may have sub-structure annotates that would
     // get lost if we only render the type name.
+    // We only extract annotations of enums, if "typeRefOnly" is true.  Otherwise, since
+    // the full enum is rendered below, we would have unnecessary annotations.
     // TODO: Can we annotate elements of targetAspect?
     //       If so, move this block before the composition rendering.
-    if (!noAnnoCollect && (artifact.elements || artifact.items?.elements)) {
-      const annotate = collectAnnotationsOfElements(artifact, env);
+    if (!noAnnoCollect && (!artifact.enum || typeRefOnly)) {
+      const annotate = collectAnnotationsOfElementsAndEnum(artifact, env);
       if (annotate)
         subelementAnnotates.push(annotate);
     }
@@ -1363,6 +1373,8 @@ function csnToCdl(csn, options) {
    *
    * @param {string|object} s
    * @param {number} idx
+   * @param {boolean} inline
+   * @param {object} env
    * @returns {string}
    */
   function renderPathStep(s, idx, inline, env) {
@@ -1370,12 +1382,9 @@ function csnToCdl(csn, options) {
     if (typeof s === 'string') {
       // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
       // FIXME: We should rather explicitly recognize quoting somehow
-
-      if (idx === 0 &&
-              s.startsWith('$'))
+      if (idx === 0 && s.startsWith('$'))
         return s;
-
-      return quoteIdIfRequired(s);
+      return quoteIdIfRequired(s, env.additionalKeywords);
     }
     // ID with filters or parameters
     else if (typeof s === 'object') {
@@ -1385,13 +1394,13 @@ function csnToCdl(csn, options) {
 
       // Not really a path step but an object-like function call
       if (s.func)
-        return `${s.func}(${renderArgs(s, '=>', env)})`;
+        return `${s.func}(${renderArguments(s, '=>', env)})`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${quoteIdIfRequired(s.id)}`;
+      let result = `${quoteIdIfRequired(s.id, env.additionalKeywords)}`;
       if (s.args) {
         // View parameters
-        result += `(${renderArgs(s, ':', env)})`;
+        result += `(${renderArguments(s, ':', env)})`;
       }
       if (s.where) {
         // Filter, possibly with cardinality
@@ -1415,24 +1424,48 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderArgs(node, sep, env) {
-    const args = node.args || [];
-
-    // Positional arguments
-    if (Array.isArray(args)) {
-      const func = node.func?.toUpperCase();
-      if (func)
-        return args.map((arg, i) => renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i))).join(', ');
+  function renderArguments(node, sep, env) {
+    if (!node.args)
+      return '';
+    else if (Array.isArray(node.args))
+      return renderPositionalArguments(node, env);
+    else if (typeof node.args === 'object')
+      return renderNamedArguments(node, sep, env);
+    throw new ModelError(`Unknown args: ${JSON.stringify(node.args)}; expected array/object`);
+  }
 
-      return args.map(arg => renderArgument(arg, env)).join(', ');
-    }
+  /**
+   * Render named function arguments or view parameters,
+   * using 'sep' as separator.
+   *
+   * @param {object} node with `args` to render
+   * @param {string} separator
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderNamedArguments(node, separator, env) {
+    return Object.keys(node.args).map(function renderNamedArgument(key) {
+      return `${quoteIdIfRequired(key, env.additionalKeywords)} ${separator} ${renderArgument(node.args[key], env)}`;
+    }).join(', ');
+  }
 
-    // Named arguments (object/dict)
-    else if (typeof args === 'object') {
-      return Object.keys(args).map(key => `${quoteIdIfRequired(key)} ${sep} ${renderArgument(args[key], env)}`).join(', ');
+  /**
+   * Render a comma separated list of positional function arguments.
+   *
+   * @param {object} node with `args` to render
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderPositionalArguments(node, env) {
+    if (!node.args)
+      return '';
+    const func = node.func?.toUpperCase();
+    if (func) {
+      return node.args.map(function renderFunctionArg(arg, i) {
+        return renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i));
+      }).join(', ');
     }
-
-    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
+    return node.args.map(arg => renderArgument(arg, env)).join(', ');
   }
 
   /**
@@ -1441,13 +1474,14 @@ function csnToCdl(csn, options) {
    *
    * @param {any} arg
    * @param {CdlRenderEnvironment} env
-   * @param {string[]} additionalAllowedKeywords
+   * @param {string[]} additionalKeywords
    * @return {string}
    */
-  function renderArgument(arg, env, additionalAllowedKeywords = []) {
+  function renderArgument(arg, env, additionalKeywords = []) {
     // If the argument is a xpr with e.g. `=`, it may require parentheses.
     // For nested xpr, `renderExpr()` will already add parentheses.
-    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalAllowedKeywords), true);
+    env = { ...env, additionalKeywords };
+    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords), true);
   }
 
   /**
@@ -1652,7 +1686,7 @@ function csnToCdl(csn, options) {
     if (keywords.cdl_functions.includes(obj.func.toUpperCase()))
       return obj.func;
     const name = identifierRegex.test(obj.func) ? obj.func : quote(obj.func);
-    return `${name}(${renderArgs( obj, '=>', env )})`;
+    return `${name}(${renderArguments( obj, '=>', env )})`;
   }
 
   /**
@@ -1775,27 +1809,33 @@ function increaseIndent(env) {
  * Quote the path steps with `![]` if necessary. For simple ids such as
  * `elem` use `quoteIdIfRequired` instead.
  *
+ * In contrast to quoteIdIfRequired, does not handle additional keywords,
+ * because it was not required, yet.
+ *
  * @param {string} path
  * @returns {string}
  *
  * @todo For paths such as `E.key`, `key` does not have to be in quotes.
  */
 function quotePathIfRequired(path) {
-  return path.split('.').map(quoteIdIfRequired).join('.');
+  return path.split('.').map(step => quoteIdIfRequired(step)).join('.');
 }
 
 /**
  * Quote the id with `![]` if necessary. For paths such as `E.key` use
  * `quotePathIfRequired` instead.
  *
+ * Set additionalKeywords to an array of UPPERCASE keywords
+ * that also need quoting, e.g. in special functions.
+ *
  * @param {string} id
+ * @param {string[]} [additionalKeywords]
  * @return {string}
  */
-function quoteIdIfRequired(id) {
+function quoteIdIfRequired(id, additionalKeywords) {
   // Quote if required for CDL
-  if (requiresQuotingForCdl(id))
+  if (requiresQuotingForCdl(id, additionalKeywords || []))
     return quote(id);
-
   return id;
 }
 
@@ -1831,13 +1871,18 @@ function quote(id) {
  * does not match the first part of the `Identifier` rule of `language.g4`
  * or if 'id' is a reserved keyword.
  *
+ * Set additionalKeywords to an array of UPPERCASE keywords
+ * that also need quoting, e.g. in special functions.
+ *
  * @param {string} id
+ * @param {string[]} [additionalKeywords]
  * @return {boolean}
  */
-function requiresQuotingForCdl(id) {
+function requiresQuotingForCdl(id, additionalKeywords) {
   return !identifierRegex.test(id) ||
     keywords.cdl.includes(id.toUpperCase()) ||
-    keywords.cdl_functions.includes(id.toUpperCase());
+    keywords.cdl_functions.includes(id.toUpperCase()) ||
+    additionalKeywords.includes(id.toUpperCase());
 }
 
 const functionExpressionOperatorsRequireParentheses = [

package/lib/render/toHdbcds.js

@@ -7,8 +7,9 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
   hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
+  cdsToSqlTypes, cdsToHdbcdsTypes,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -195,7 +196,7 @@ function toHdbcdsSource(csn, options) {
     switch (art.kind) {
       case 'entity':
         // FIXME: For HANA CDS, we need to replace $self at the beginning of paths in association ON-condition
-        // by the full name of the artifact we are rendering (should actually be done by forHana, but that is
+        // by the full name of the artifact we are rendering (should actually be done by forRelationalDB, but that is
         // somewhat difficult because this kind of absolute path is quite unusual). In order not to have to pass
         // the current artifact name down through the stack to renderExpr, we just put it into the env.
         env.currentArtifactName = artifactName;
@@ -763,7 +764,7 @@ function toHdbcdsSource(csn, options) {
       result += key + renderExpr(col, env, true);
       let alias = col.as || col.func;
       // HANA requires an alias for 'key' columns just for syntactical reasons
-      // FIXME: This will not complain for non-refs (but that should be checked in forHana)
+      // FIXME: This will not complain for non-refs (but that should be checked in forRelationalDB)
       // Explicit or implicit alias?
       // Shouldn't we simply generate an alias all the time?
       if ((key || col.cast) && !alias)
@@ -1147,7 +1148,8 @@ function toHdbcdsSource(csn, options) {
     if (elm.type === 'cds.Decimal' && elm.scale === undefined && elm.precision === undefined)
       return 'DecimalFloat';
 
-    return elm.type.replace(/^cds\./, '') + renderTypeParameters(elm);
+    const type = cdsToHdbcdsTypes[elm.type] || elm.type;
+    return type.replace(/^cds\./, '') + renderTypeParameters(elm);
   }
 
   /**
@@ -1160,7 +1162,7 @@ function toHdbcdsSource(csn, options) {
   function renderPathStep(s, idx, ref, env, inline) {
     // Simple id or absolute name
     if (typeof s === 'string') {
-      // HANA-specific extra magic (should actually be in forHana)
+      // HANA-specific extra magic (should actually be in forRelationalDB)
       // In HANA, we replace leading $self by the absolute name of the current artifact
       // (see FIXME at renderArtifact)
       if (idx === 0 && s === $SELF) {
@@ -1256,7 +1258,7 @@ function toHdbcdsSource(csn, options) {
     const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
     // we can't quote functions with parens, issue warning if it is a reserved keyword
     if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
-      warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
+      warning(null, x.$location, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
     return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
   }
 

package/lib/render/toRename.js

@@ -6,7 +6,7 @@ const { checkCSNVersion } = require('../json/csnVersion');
 const { getUtils, forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
 const { isBetaEnabled } = require('../base/model');
-const { transformForHanaWithCsn } = require('../transform/forHanaNew');
+const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 
 
 /**
@@ -44,9 +44,9 @@ function toRename(inputCsn, options) {
   if (!isBetaEnabled(options, 'toRename'))
     error(null, null, 'Generation of SQL rename statements is not supported yet (only in beta mode)');
 
-  // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forHana)
-  const csn = transformForHanaWithCsn(inputCsn, options, 'to.rename');
-  // forHanaCsn looses empty contexts and services, add them again so that toRename can calculate the namespaces
+  // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
+  const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
+  // forRelationalDB looses empty contexts and services, add them again so that toRename can calculate the namespaces
   forEachDefinition(csn, (artifact, artifactName) => {
     if ((artifact.kind === 'context' || artifact.kind === 'service') && csn.definitions[artifactName] === undefined)
       csn.definitions[artifactName] = artifact;

package/lib/render/toSql.js

@@ -157,7 +157,7 @@ function toSqlDdl(csn, options) {
       Render column removals as HANA SQL.
      */
     dropColumns(tableName, sqlIds) {
-      return [ `ALTER TABLE ${tableName} DROP (${sqlIds.join(', ')});` ];
+      return [ `ALTER TABLE ${tableName} DROP ${options.sqlDialect === 'hana' ? '(' : ''}${sqlIds.join(', ')}${options.sqlDialect === 'hana' ? ')' : ''};` ];
     },
     /*
       Render association removals as HANA SQL.
@@ -221,7 +221,7 @@ function toSqlDdl(csn, options) {
   };
 
   // FIXME: Currently requires 'options.forHana', because it can only render HANA-ish SQL dialect
-  if (!options.forHana)
+  if (!options.forHana && !isBetaEnabled(options, 'sqlExtensions'))
     throw new Error('toSql can currently only be used with HANA preprocessing');
 
   checkCSNVersion(csn, options);
@@ -325,7 +325,7 @@ function toSqlDdl(csn, options) {
   }
 
   // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana`
-  if (!options.constraintsInCreateTable && options.src === 'sql' && options.sqlDialect === 'hana') {
+  if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres')) {
     const alterStmts = manageConstraints(csn, options);
 
     for ( const constraintName of Object.keys(alterStmts))
@@ -352,7 +352,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    */
   function renderArtifactInto(artifactName, art, resultObj, env) {
-    // Ignore whole artifacts if forHana says so
+    // Ignore whole artifacts if forRelationalDB says so
     if (art.abstract || hasValidSkipOrExists(art))
       return;
 
@@ -605,8 +605,8 @@ function toSqlDdl(csn, options) {
     if (primaryKeys !== '')
       result += `,\n${childEnv.indent}${primaryKeys}`;
 
-    // for `to.sql` w/ dialect `hana` the constraints will be part of the
-    const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && options.sqlDialect === 'hana';
+    // for `to.sql` w/ dialect `hana` the constraints will be part of the alter statement
+    const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres');
     if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.src === 'hdi';
       const referentialConstraints = {};
@@ -1506,8 +1506,10 @@ function toSqlDdl(csn, options) {
           case 'sqlite':
           case 'hana':
             return 'CURRENT_TIMESTAMP';
-          case 'postgres':
+          case 'h2':
             return 'current_timestamp';
+          case 'postgres':
+            return '(current_timestamp at time zone \'UTC\')';
           default:
             return quoteSqlId(x.ref[0]);
         }
@@ -1534,12 +1536,16 @@ function toSqlDdl(csn, options) {
       if (x.ref[1] === 'id') {
         if (options.sqlDialect === 'hana')
           return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
+        else if (options.sqlDialect === 'postgres')
+          return 'current_setting(\'CAP.APPLICATIONUSER\')';
         warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
         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\')';
         return '\'en\''; // default language
       }
       // Basically: Second path step was invalid, do nothing - should not happen.
@@ -1567,6 +1573,8 @@ function toSqlDdl(csn, options) {
           case 'hana':
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
           case 'postgres':
+            return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          case 'h2':
           case 'plain':
             return 'current_timestamp';
           default:
@@ -1584,6 +1592,8 @@ function toSqlDdl(csn, options) {
           case 'hana':
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
           case 'postgres':
+            return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          case 'h2':
           case 'plain':
             return 'current_timestamp';
           default: