@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/render/utils/common.js

@@ -31,7 +31,7 @@ const { implicitAs } = require('../../model/csnRefs');
  * @param {(a: string) => string} renderArgs Function to render function arguments
  * @returns {string} Function string
  */
-function renderFunc( funcName, node, dialect, renderArgs) {
+function renderFunc( funcName, node, dialect, renderArgs ) {
   if (funcWithoutParen( node, dialect ))
     return funcName;
   return `${funcName}(${renderArgs( node )})`;
@@ -60,7 +60,7 @@ function funcWithoutParen( node, dialect ) {
  *
  * @returns {string} The rendered xpr
  */
-function beautifyExprArray(tokens) {
+function beautifyExprArray( tokens ) {
   // Simply concatenate array parts with spaces (with a tiny bit of beautification)
   let result = '';
   for (let i = 0; i < tokens.length; i++) {
@@ -72,7 +72,6 @@ function beautifyExprArray(tokens) {
   return result;
 }
 
-
 /**
  * Get the part that is really the name of this artifact and not just prefix caused by a context/service
  *
@@ -80,13 +79,12 @@ function beautifyExprArray(tokens) {
  * @param {string} artifactName Artifact name to use
  * @returns {string} non-prefix part of the artifact name
  */
-function getRealName(csn, artifactName) {
+function getRealName( csn, artifactName ) {
   const parts = artifactName.split('.');
   // Length of 1 -> There can be no prefix
   if (parts.length === 1)
     return artifactName;
 
-
   const namespace = getNamespace(csn, artifactName);
   const startIndex = namespace ? namespace.split('.').length : 0;
   let indexOfLastParent = startIndex;
@@ -120,7 +118,7 @@ function getRealName(csn, artifactName) {
    * @param {string} artifactName Name of the artifact to check for
    * @returns {string | null} Name of the topmost context or null
    */
-function getParentContextName(csn, artifactName) {
+function getParentContextName( csn, artifactName ) {
   const parts = artifactName.split('.');
   for (let i = 0; i < parts.length - 1; i++) {
     const name = parts.slice(0, i).join('.');
@@ -129,7 +127,6 @@ function getParentContextName(csn, artifactName) {
     if (art && (art.kind === 'context' || art.kind === 'service'))
       return name;
   }
-
   return null;
 }
 
@@ -140,7 +137,7 @@ function getParentContextName(csn, artifactName) {
  *
  * @param {Function[]} killList Array to add cleanup functions to
  */
-function addContextMarkers(csn, killList) {
+function addContextMarkers( csn, killList ) {
   const contextsToCreate = Object.create(null);
   forEachDefinition(csn, (art, artifactName) => {
     const namespace = getNamespace(csn, artifactName);
@@ -175,7 +172,7 @@ function addContextMarkers(csn, killList) {
   * @param {string} artifactName Name of the current context
   * @returns {string[]} All possible context names inbetween
   */
-function getIntermediateContextNames(csn, parentName, artifactName) {
+function getIntermediateContextNames( csn, parentName, artifactName ) {
   const parentLength = parentName.split('.').length;
   const parts = artifactName.split('.');
   const names = [];
@@ -197,7 +194,7 @@ function getIntermediateContextNames(csn, parentName, artifactName) {
  * @param {string} artifactName
  * @param {Function[]} killList Array to add cleanup functions to
  */
-function addMissingChildContexts(csn, artifactName, killList) {
+function addMissingChildContexts( csn, artifactName, killList ) {
   // Get all other definitions sharing the same prefix, sorted by shortest first
   const possibleNames = Object.keys(csn.definitions).filter(name => name.startsWith(`${artifactName}.`)).sort((a, b) => a.length - b.length);
   for (const name of possibleNames) {
@@ -206,7 +203,7 @@ function addMissingChildContexts(csn, artifactName, killList) {
       addPossibleGaps(name.slice(artifactName.length + 1).split('.'), artifactName);
   }
 
-  function addPossibleGaps(possibleGaps, gapArtifactName) {
+  function addPossibleGaps( possibleGaps, gapArtifactName ) {
     for (const gap of possibleGaps) {
       gapArtifactName += `.${gap}`;
       if (!csn.definitions[gapArtifactName]) {
@@ -317,7 +314,7 @@ const cdsToHdbcdsTypes = {
  * @param {CSN.Column} column Column from the same query
  * @returns {CSN.Element}
  */
-function findElement(elements, column) {
+function findElement( elements, column ) {
   if (!elements)
     return undefined;
   if (column.as)
@@ -336,7 +333,7 @@ function findElement(elements, column) {
   *
   * @param {Function[]} killList Array to add cleanup functions to
   */
-function addIntermediateContexts(csn, killList) {
+function addIntermediateContexts( csn, killList ) {
   for (const artifactName in csn.definitions) {
     const artifact = csn.definitions[artifactName];
     if ((artifact.kind === 'context') && !artifact._ignore) {
@@ -368,7 +365,7 @@ function addIntermediateContexts(csn, killList) {
  * @param {CSN.Options} options To check for `disableHanaComments`
  * @returns {boolean}
  */
-function hasHanaComment(obj, options) {
+function hasHanaComment( obj, options ) {
   return !options.disableHanaComments && typeof obj.doc === 'string';
 }
 /**
@@ -380,7 +377,7 @@ function hasHanaComment(obj, options) {
  * @param {CSN.Artifact|CSN.Element} obj
  * @returns {string}
  */
-function getHanaComment(obj) {
+function getHanaComment( obj ) {
   return obj.doc.split('\n\n')[0].trim();
 }
 
@@ -392,7 +389,7 @@ function getHanaComment(obj) {
  * @param {object} obj
  * @returns {object} object with .front and .back
  */
-function getSqlSnippets(options, obj) {
+function getSqlSnippets( options, obj ) {
   const front = obj['@sql.prepend'] ? `${obj['@sql.prepend']} ` : '';
   const back = obj['@sql.append'] ? ` ${obj['@sql.append']}` : '';
 
@@ -404,8 +401,7 @@ function getSqlSnippets(options, obj) {
  *
  * @callback renderPart
  * @param {object|array} expression
- * @param {CdlRenderEnvironment} env
- * @this {{inline: Boolean, nestedExpr: Boolean}}
+ * @this {ExpressionRenderer}
  * @returns {string}
  */
 
@@ -415,7 +411,27 @@ function getSqlSnippets(options, obj) {
  *
  * @typedef {object} ExpressionConfiguration
  * @property {(x: any) => string} finalize The final function to call on the expression(-string) before returning
- * @property {renderPart} explicitTypeCast
+ * @property {renderPart} typeCast
+ * @property {renderPart} val
+ * @property {renderPart} enum
+ * @property {renderPart} ref
+ * @property {renderPart} aliasOnly
+ * @property {renderPart} windowFunction
+ * @property {renderPart} func
+ * @property {renderPart} xpr
+ * @property {renderPart} SELECT
+ * @property {renderPart} SET
+ * @property {Function} [visitExpr]
+ * @property {Function} [renderExpr]
+ * @property {Function} [renderSubExpr]
+ * @property {boolean} [isNestedXpr]
+ * @property {object} [env]
+ */
+
+/**
+ * @typedef {object} ExpressionRenderer
+ * @property {(x: any) => string} finalize The final function to call on the expression(-string) before returning
+ * @property {renderPart} typeCast
  * @property {renderPart} val
  * @property {renderPart} enum
  * @property {renderPart} ref
@@ -425,114 +441,130 @@ function getSqlSnippets(options, obj) {
  * @property {renderPart} xpr
  * @property {renderPart} SELECT
  * @property {renderPart} SET
- * @property {boolean} [inline]
- * @property {boolean} [nestedExpr]
+ * @property {Function} visitExpr
+ * @property {Function} renderExpr
+ * @property {Function} renderSubExpr
+ * @property {boolean} isNestedXpr
+ * @property {object} env
+ */
+
+/**
+ * If `xpr` has a `cast` property, return a copy without it, otherwise return `xpr`.
+ * Useful for removing e.g. top-level CDL-style casts that should not be rendered as CAST().
+ *
+ * @param xpr
  */
+function withoutCast( xpr ) {
+  return !xpr.cast ? xpr : { ...xpr, cast: undefined };
+}
 
 /**
  * Render an expression (including paths and values) or condition 'x'.
  * (no trailing LF, don't indent if inline)
  *
- * @param {ExpressionConfiguration} renderer
- * @returns {Function} Rendered expression
+ * @param {ExpressionConfiguration} rendererBase
+ * @returns {ExpressionRenderer} Expression rendering utility
  */
-function getExpressionRenderer(renderer) {
+function createExpressionRenderer( rendererBase ) {
+  const renderer = Object.create(rendererBase);
+  renderer.visitExpr = visitExpr;
   /**
-   * Render an expression (including paths and values) or condition 'x'.
-   * (no trailing LF, don't indent if inline)
-   *
-   * @todo Reuse this with toCdl
-   * @param {Array|object|string} expr Expression to render
-   * @param {object} env Render environment
-   * @param {boolean} [inline=true] Whether to render the expression inline
-   * @param {boolean} [nestedExpr=false] Whether to treat the expression as nested
-   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `nestedExpr === false`.
-   *                                           Note: This is a hack for casts() inside groupBy.
-   * @returns {string} Rendered expression
+   * @param {any} x
+   * @param {object} env
    */
-  return function renderExpr(expr, env, inline = true, nestedExpr = false, alwaysRenderCast = false) {
-  // Compound expression
-    if (Array.isArray(expr)) {
-      const tokens = expr.map(item => renderExpr(item, env, inline, nestedExpr));
-      return beautifyExprArray(tokens);
-    }
-    else if (typeof expr === 'object' && expr !== null) {
-      if ((nestedExpr || alwaysRenderCast) && expr.cast && expr.cast.type && !expr.cast.target)
-        return renderer.explicitTypeCast.call({ inline, nestedExpr }, expr, env);
-      return renderExprObject(expr);
-    }
-    // Not a literal value but part of an operator, function etc - just leave as it is
-    // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
-    return renderer.finalize.call({ inline, nestedExpr }, expr, env);
-
-
-    /**
-     * Various special cases represented as objects
-     *
-     * @param {object} x Expression
-     * @returns {string} String representation of the expression
-     */
-    function renderExprObject(x) {
-      if (x.list) { // TODO: Does this still exist?
-        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
-      }
-      else if (x.val !== undefined) {
-        return renderer.val.call({ inline, nestedExpr }, x, env);
-      }
-      // Enum symbol
-      else if (x['#']) {
-        return renderer.enum.call({ inline, nestedExpr }, x, env);
-      }
-      // Reference: Array of path steps, possibly preceded by ':'
-      else if (x.ref) {
-        return renderer.ref.call({ inline, nestedExpr }, x, env);
-      }
-      // Function call, possibly with args (use '=>' for named args)
-      else if (x.func) {
-        if (x.xpr)
-          return renderer.windowFunction.call({ inline, nestedExpr }, x, env);
-        return renderer.func.call({ inline, nestedExpr }, x, env);
-      }
-      // Nested expression
-      else if (x.xpr) {
-        return renderer.xpr.call({ inline, nestedExpr }, x, env);
-      }
-      // Sub-select
-      else if (x.SELECT) {
-        return renderer.SELECT.call({ inline, nestedExpr }, x, env);
-      }
-      else if (x.SET) {
-        return renderer.SET.call({ inline, nestedExpr }, x, env);
-      }
-      else if (x.as && x.cast && x.cast.type && x.cast.target) {
-        return renderer.aliasOnly.call({ inline, nestedExpr }, x, env);
-      }
-
-      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
-    }
+  renderer.renderExpr = function renderExpr(x, env) {
+    /** @type {ExpressionRenderer} */
+    const renderObj = Object.create(renderer);
+    renderObj.env = env || this?.env;
+    // The outermost expression is not nested. All `.xpr` inside `expr`
+    // are nested.  This information is used for adding parentheses around
+    // expressions (see `this.xpr()`).
+    renderObj.isNestedXpr = false;
+    return renderObj.visitExpr(x);
   };
+  /**
+   * @param {any} x
+   * @param {object} env
+   */
+  renderer.renderSubExpr = function renderSubExpr(x, env) {
+    /** @type {ExpressionRenderer} */
+    const renderObj = Object.create(renderer);
+    renderObj.env = env || this?.env;
+    renderObj.isNestedXpr = true;
+    return renderObj.visitExpr(x);
+  };
+
+  return renderer;
 }
 
+
 /**
- * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
+ * Render an expression (including paths and values) or condition 'x'.
+ * (no trailing LF, don't indent if inline)
+ *
+ * `this` must refer to an object of type `ExpressionRenderer`, see
+ * `createExpressionRenderer()`
  *
- * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
- * @property {CSN.Path} [path] CSN path to the current artifact
- * @property {string}   [currentArtifactName] Name of the current artifact
- * @property {{[name: string]: {
-      quotedName: string,
-      quotedAlias: string
-    }}} topLevelAliases Dictionary of aliases for used artifact names
+ * @param {any} x (Sub-)Expression to render
  *
- * @property {string} namePrefix Current name prefix (including trailing dot if not empty)
- * @property {boolean} [skipKeys] Skip rendering keys in subqueries
- * @property {CSN.Artifact} [_artifact] The original view artifact, used when rendering queries
+ * @this ExpressionRenderer
+ * @returns {string} Rendered expression
  */
+function visitExpr( x ) {
+  if (Array.isArray(x)) {
+    // Compound expression, e.g. for on- or where-conditions.
+    // If xpr is part of an array, it's always a nested xpr,
+    // e.g. CSN for `(1=1 or 2=2) and 3=3`.
+    const tokens = x.map(item => this.renderSubExpr(item));
+    return beautifyExprArray(tokens);
+  }
+  else if (typeof x !== 'object' || x === null) {
+    // Not a literal value but part of an operator, function etc - just leave as it is
+    return this.finalize(x);
+  }
+  else if (x.cast?.type && !x.cast.target) {
+    return this.typeCast(x);
+  }
+  else if (x.list) {
+    // Render as non-nested expr.
+    return `(${x.list.map(item => this.renderExpr(item)).join(', ')})`;
+  }
+  else if (x.val !== undefined) {
+    return this.val(x);
+  }
+  else if (x['#']) {
+    // Enum symbol
+    return this.enum(x);
+  }
+  else if (x.ref) {
+    // Reference: Array of path steps, possibly preceded by ':'
+    return this.ref(x);
+  }
+  else if (x.func) {
+    // Function call, possibly with args (use '=>' for named args)
+    if (x.xpr)
+      return this.windowFunction(x);
+    return this.func(x);
+  }
+  else if (x.xpr) {
+    return this.xpr(x);
+  }
+  else if (x.SELECT) {
+    return this.SELECT(x);
+  }
+  else if (x.SET) {
+    return this.SET(x);
+  }
+  else if (x.as) {
+    return this.aliasOnly(x);
+  }
+
+  throw new ModelError(`renderExpr(): Unknown expression: ${JSON.stringify(x)}`);
+}
 
 module.exports = {
   renderFunc,
-  getExpressionRenderer,
-  beautifyExprArray,
+  createExpressionRenderer,
   getNamespace,
   getRealName,
   addIntermediateContexts,
@@ -544,4 +576,5 @@ module.exports = {
   findElement,
   funcWithoutParen,
   getSqlSnippets,
+  withoutCast,
 };

package/lib/render/utils/delta.js

@@ -0,0 +1,227 @@
+'use strict';
+
+/**
+ * Encapsulate all the functions needed to render SQL ALTER/DROP/ADD statements.
+ */
+class DeltaRenderer {
+  constructor(options, scopedFunctions) {
+    this.options = options;
+    this.scopedFunctions = scopedFunctions;
+  }
+
+  /**
+   * Render column additions as SQL. Checks for duplicate elements.
+   */
+  addColumnsFromElementStrings(artifactName, eltStrings) {
+    return eltStrings.map(eltString => `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD ${eltString};`);
+  }
+
+  /**
+   * Render column additions as SQL. Checks for duplicate elements.
+   */
+  addColumnsFromElementsObj(artifactName, elementsObj, env, duplicateChecker) {
+    // Only extend with 'ADD' for elements/associations
+    // TODO: May also include 'RENAME' at a later stage
+    const alterEnv = this.scopedFunctions.activateAlterMode(env);
+    const elements = Object.entries(elementsObj)
+      .map(([ name, elt ]) => this.scopedFunctions.renderElement(artifactName, name, elt, duplicateChecker, null, alterEnv))
+      .filter(s => s !== '');
+
+    if (elements.length)
+      return this.addColumnsFromElementStrings(artifactName, elements);
+
+    return [];
+  }
+
+  /**
+   * By default, we don't support rendering association-alters - only for HANA
+   */
+  addAssociations(_artifactName, _extElements, _env) {
+    return [];
+  }
+
+  /**
+   * Render key addition as SQL.
+   */
+  addKey(artifactName, elementsObj) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD ${this.primaryKey(elementsObj)};` ];
+  }
+
+  /**
+   * Render column removals as SQL.
+   */
+  dropColumns(artifactName, sqlIds) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP ${sqlIds.join(', ')};` ];
+  }
+
+  /**
+   * No associations by default - only for HANA.
+   */
+  dropAssociation(_artifactName, _sqlId) {
+    return [];
+  }
+
+  /**
+   * Render primary-key removals as SQL.
+   */
+  dropKey(artifactName) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP PRIMARY KEY;` ];
+  }
+
+  /**
+   * Render column modifications as SQL.
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER (${definitionsStr});` ];
+  }
+
+  /**
+   * Render primary keys as SQL.
+   */
+  primaryKey(elementsObj) {
+    const primaryKeys = Object.keys(elementsObj)
+      .filter(name => elementsObj[name].key && !elementsObj[name].virtual)
+      .map(name => this.scopedFunctions.quoteSqlId(name))
+      .join(', ');
+    return primaryKeys && `PRIMARY KEY(${primaryKeys})`;
+  }
+
+  /**
+   * Render entity-comment modifications as SQL.
+   */
+  alterEntityComment(artifactName, comment) {
+    return [ `COMMENT ON TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} IS ${this.comment(comment)};` ];
+  }
+
+  /**
+   * Render column-comment modifications as SQL.
+   */
+  alterColumnComment(artifactName, columnName, comment) {
+    return [ `COMMENT ON COLUMN ${this.scopedFunctions.renderArtifactName(artifactName)}.${columnName} IS ${this.comment(comment)};` ];
+  }
+
+  /**
+   * Render comment string.
+   */
+  comment(comment) {
+    return comment && this.scopedFunctions.renderStringForSql(this.scopedFunctions.getHanaComment({ doc: comment }), this.options.sqlDialect) || 'NULL';
+  }
+
+  /**
+   * Alter SQL snippet for entity.
+   */
+  alterEntitySqlSnippet(artifactName, snippet) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ${snippet};` ];
+  }
+
+  /**
+   * Concatenate multiple statements which are to be treated as one by the API caller.
+   */
+  concat(...statements) {
+    return [ statements.join('\n') ];
+  }
+}
+
+class DeltaRendererHana extends DeltaRenderer {
+  /**
+   * Render column additions as HANA SQL. Checks for duplicate elements.
+   */
+  addColumnsFromElementStrings(artifactName, eltStrings) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD (${eltStrings.join(', ')});` ];
+  }
+
+  /**
+   * Render association additions as HANA SQL.
+   * TODO duplicity check
+   */
+  addAssociations(artifactName, elementsObj, env) {
+    return Object.entries(elementsObj)
+      .map(([ name, elt ]) => this.scopedFunctions.renderAssociationElement(name, elt, env))
+      .filter(s => s !== '')
+      .map(eltStr => `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD ASSOCIATION (${eltStr});`);
+  }
+
+  /**
+   * Render column removals as HANA SQL.
+   */
+  dropColumns(artifactName, sqlIds) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP (${sqlIds.join(', ')});` ];
+  }
+
+  /**
+   * Render association removals as HANA SQL.
+   */
+  dropAssociation(artifactName, sqlId) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP ASSOCIATION ${sqlId};` ];
+  }
+}
+
+class DeltaRendererPostgres extends DeltaRenderer {
+  /**
+   * Render primary-key removals as SQL.
+   * @todo tableName is escaped - we cannot simply add _pkey
+   */
+  dropKey(artifactName) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP CONSTRAINT ${this.scopedFunctions.renderArtifactName(`${artifactName}_pkey`)};` ];
+  }
+
+  /**
+   * Render column removals as SQL.
+   */
+  dropColumns(artifactName, sqlIds) {
+    return sqlIds.map(sqlId => `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP ${sqlId};`);
+  }
+
+  /**
+   * Render column modifications as Postgres SQL - no ( ), special NOT NULL.
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr) {
+    const sqls = [];
+    if (delta.new.notNull === true || delta.new.key === true)
+      definitionsStr = definitionsStr.replace(' NOT NULL', ''); // TODO: Is this robust enough?
+    else if (delta.new.notNull === false || delta.new.$notNull === false)
+      definitionsStr = definitionsStr.replace(' NULL', ''); // TODO: Is this robust enough?
+
+    sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};`);
+    if (delta.new.notNull && !delta.old.notNull)
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${columnName} SET NOT NULL;`);
+    else if (delta.old.notNull && !delta.new.notNull)
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${columnName} DROP NOT NULL;`);
+
+    return sqls;
+  }
+}
+
+class DeltaRendererH2 extends DeltaRenderer {
+  /**
+   * Render column modifications as H2 SQL - no ().
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};` ];
+  }
+}
+
+/**
+ * Return an object encapsulating the render-functions for ALTER/DROP for a given db dialect.
+ *
+ * @param {CSN.Options} options
+ * @param {object} scopedFunctions
+ * @returns {DeltaRenderer}
+ */
+function getDeltaRenderer( options, scopedFunctions ) {
+  switch (options.sqlDialect) {
+    case 'hana':
+      return new DeltaRendererHana(options, scopedFunctions);
+    case 'h2':
+      return new DeltaRendererH2(options, scopedFunctions);
+    case 'postgres':
+      return new DeltaRendererPostgres(options, scopedFunctions);
+    default:
+      return new DeltaRenderer(options, scopedFunctions);
+  }
+}
+
+
+module.exports = {
+  getDeltaRenderer,
+};

package/lib/render/utils/sql.js

@@ -18,7 +18,7 @@ const { ModelError } = require('../../base/error');
  *
  * @returns {string} SQL statement which can be used to create the referential constraint on the db.
  */
-function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint = false) {
+function renderReferentialConstraint( constraint, indent, toUpperCase, csn, options, alterConstraint = false ) {
   let quoteId;
   // for to.hana we can't utilize the sql identifier utils
   if (options.transformation === 'hdbcds') {
@@ -29,7 +29,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     };
   }
   else {
-    quoteId = getIdentifierUtils(options).quoteSqlId;
+    quoteId = getIdentifierUtils(csn, options).quoteSqlId;
   }
   if (toUpperCase) {
     constraint.identifier = constraint.identifier.toUpperCase();
@@ -81,8 +81,8 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
  * @param {CSN.Options} options
  * @returns quoteSqlId and prepareIdentifier function
  */
-function getIdentifierUtils(options) {
-  return { quoteSqlId, prepareIdentifier };
+function getIdentifierUtils( csn, options ) {
+  return { quoteSqlId, prepareIdentifier, renderArtifactName };
   /**
    * Return 'name' with appropriate "-quotes.
    * Additionally perform the following conversions on 'name'
@@ -95,7 +95,7 @@ function getIdentifierUtils(options) {
    * @param {string} name Identifier to quote
    * @returns {string} Quoted identifier
    */
-  function quoteSqlId(name) {
+  function quoteSqlId( name ) {
     name = prepareIdentifier(name);
 
     switch (options.sqlMapping) {
@@ -120,7 +120,7 @@ function getIdentifierUtils(options) {
      * @param {string} name Identifier to prepare
      * @returns {string} Identifier prepared for quoting
      */
-  function prepareIdentifier(name) {
+  function prepareIdentifier( name ) {
     // Sanity check
     if (options.sqlDialect === 'sqlite' && options.sqlMapping !== 'plain')
       throw new ModelError(`Not expecting ${options.sqlMapping} names for 'sqlite' dialect`);
@@ -137,6 +137,22 @@ function getIdentifierUtils(options) {
         throw new ModelError(`No matching rendering found for naming mode ${options.sqlMapping}`);
     }
   }
+
+  /**
+   * Given the following artifact name: namespace.prefix.entity.with.dot, render the following,
+   * depending on the naming mode:
+   * - plain: NAMESPACE_PREFIX_ENTITY_WITH_DOT
+   * - quoted: namespace.prefix.entity_with_dot
+   * - hdbcds: namespace::prefix.entity_with_dot
+   *
+   *
+   * @param {string} artifactName Artifact name to render
+   *
+   * @returns {string} Artifact name
+   */
+  function renderArtifactName( artifactName ) {
+    return quoteSqlId(getResultingName(csn, options.sqlMapping, artifactName));
+  }
 }