@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/model/csnUtils.js

@@ -5,6 +5,8 @@ const { applyTransformations, applyTransformationsOnNonDictionary } = require('.
 const { isBuiltinType } = require('../compiler/builtins.js')
 const { sortCsn, cloneCsnDictionary: _cloneCsnDictionary } = require('../json/to-csn');
 const { ModelError } = require("../base/error");
+const { typeParameters } = require("../compiler/builtins");
+const { forEach } = require('../utils/objectUtils');
 const version = require('../../package.json').version;
 
 // Low-level utility functions to work with compact CSN.
@@ -34,11 +36,14 @@ const version = require('../../package.json').version;
  */
 
 /**
- * Get utility functions for a given CSN.
+ * Get utility functions for a given CSN. Re-exports functions of `csnRefs()`.
  * @param {CSN.Model} model (Compact) CSN model
  */
 function getUtils(model, universalReady) {
-  const { artifactRef, inspectRef, effectiveType, getOrigin, targetAspect, getColumn, getElement, initDefinition } = csnRefs(model, universalReady);
+  const _csnRefs = csnRefs(model, universalReady);
+  const { artifactRef } = _csnRefs;
+  /** Cache for getFinalBaseTypeWithProps(). Specific to the current model. */
+  const finalBaseTypeCache = Object.create(null);
 
   return {
     getCsnDef,
@@ -56,17 +61,10 @@ function getUtils(model, universalReady) {
     getServiceName,
     hasAnnotationValue,
     cloneWithTransformations,
-    getFinalBaseType,
-    inspectRef,
-    artifactRef,
-    effectiveType,
+    getFinalBaseTypeWithProps,
     get$combined,
-    getOrigin,
     getQueryPrimarySource,
-    targetAspect,
-    getColumn,
-    getElement,
-    initDefinition
+    ..._csnRefs,
   };
 
   /**
@@ -261,7 +259,7 @@ function getUtils(model, universalReady) {
    */
   function isStructured(obj) {
     return obj.elements ||
-      (obj.type && ((getFinalTypeDef(obj.type).elements) || (obj.type.ref && getFinalBaseType(obj.type).elements)));
+      (obj.type && ((getFinalTypeDef(obj.type).elements) || (obj.type.ref && getFinalBaseTypeWithProps(obj.type)?.elements)));
   }
 
   /**
@@ -447,13 +445,13 @@ function getUtils(model, universalReady) {
    * The transformer functions are called with the following signature:
    * transformer(value, node, resultNode, key)
    *
-   * @param {any} node Node to transform
+   * @param {any} rootNode Node to transform
    * @param {any} transformers Object defining transformer functions
    * @returns {object}
    */
-  function cloneWithTransformations(node, transformers) {
+  function cloneWithTransformations(rootNode, transformers) {
 
-    return transformNode(node);
+    return transformNode(rootNode);
 
   // This general transformation function will be applied to each node recursively
     function transformNode(node) {
@@ -486,97 +484,122 @@ function getUtils(model, universalReady) {
     }
   }
 
+  function _normalizeTypeRef(type) {
+    if (type && typeof type === 'object' && type.ref?.length === 1)
+      type = type.ref[0]; // simplify type: no element -> simple string can be used
+    return type;
+  }
 
   /**
-   * Resolve to the final type of a type, that means follow type chains, references to other types or
-   * elements a.s.o
-   * Works for all kinds of types, strings as well as type objects. Strings need to be absolute type names.
-   * Returns the final type as string (if it has a name, which is not always the case, think of embedded structures),
-   * else the type object itself is returned. If a type is structured, you can navigate into it by providing a path,
-   * e.g. given the following model
-   *     type bar: S.foo;
-   *     type s1 {
-   *       s: s2;
-   *     };
-   *     type s2 {
-   *       u: type of S.e:t;
-   *     }
-   *     service S {
-   *       type foo: type of S.e:i.j1;
-   *       entity e {
-   *         key i: { j1: Integer };
-   *         t: bar;
-   *         v: s1;
-   *         x: blutz.s.u;
-   *       };
-   *       type blutz: S.e.v;
-   *       view V as select from e {
-   *         1+1 as i: bar,
-   *       };
-   *       type tt: type of V:i;
-   *    }
-   * the following calls will all return 'cds.Integer'
-   *     getFinalBaseType('S.tt')
-   *     getFinalBaseType('S.e',['i','j1'])
-   *     getFinalBaseType('S.e',['t'])
-   *     getFinalBaseType('S.e',['x'])
-   *     getFinalBaseType('S.blutz',['s', 'u'])
-   * Types are always resolved as far as possible. A type name which has no further definition is simply returned.
-   * Composed types (structures, entities, views, ...) are returned as type objects, if not drilled down into
-   * the elements. Path steps that have no corresponding element lead to 'undefined'. Refs to something that has
-   * no type (e.g. expr in a view without explicit type) returns 'null'
+   * Resolve to the final type of a type, that means follow type chains, references, etc.
+   * Input is a type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
+   *
+   * Returns `null` if the type can't be resolved or if the referenced element has no type,
+   * e.g. `typeof V:calculated`.
+   * Otherwise, if scalar, returns an object that has a `type` property and all collected type
+   * properties, or the type object with `elements` or `items` property if structured/arrayed.
    *
-   * @param {string|object} type Type - either string or ref
-   * @param {CSN.Path} path
-   * @param {WeakMap} [resolved=new WeakMap()] WeakMap containing already resolved refs - if a ref is not cached, it will be resolved JIT
-   * @param {object} [cycleCheck] Dictionary to remember already resolved types - to be cycle-safe
-   * @returns
+   * Caches type lookups.  If the CSN changes drastically, you will need to re-call `csnUtils()`
+   * and use the newly returned `getFinalBaseTypeWithProps()`.
+   *
+   * @param {string|object} type Type as string or type ref, i.e. `{ ref: [...] }`
+   * @returns {object|null}
    */
-  function getFinalBaseType(type, path = [], resolved = new WeakMap(), cycleCheck = undefined) {
+  function getFinalBaseTypeWithProps(type) {
+    type = _normalizeTypeRef(type);
     if (!type)
-      return type;
-    if (typeof(type) === 'string') {
-      if (isBuiltinType(type)) // built-in type
-        return type;
-      if (cycleCheck) {
-        let visited = path.length? type + ':' + path.join('.') : type;
-        if (cycleCheck[visited])
-          throw new ModelError('Circular type chain on type ' + type);
-        else
-          cycleCheck[visited] = true;
+      return null;
+
+    // Nothing to copy from builtin type name.
+    if (typeof type === 'string' && isBuiltinType( type )) {
+      return { type };
+    }
+
+    // We differentiate between ref and type to avoid collisions due to dict key.
+    // Delimiter chosen arbitrarily; just one that is rarely used.
+    const resolvedKey = (typeof type === 'object') ? `ref:${type.ref.join('\\')}` : `type:${type}`;
+
+    if (finalBaseTypeCache[resolvedKey]) {
+      if (finalBaseTypeCache[resolvedKey] === true)
+        throw new ModelError(`Detected circular type reference; can't resolve: ${resolvedKey}`);
+      return finalBaseTypeCache[resolvedKey];
+    }
+
+    let typeRef = artifactRef(type); // throws if not found
+    const isNonScalar = _cacheNonScalar(typeRef);
+    if (isNonScalar)
+      return finalBaseTypeCache[resolvedKey];
+
+    const props = {};
+    _copyTypeProps(props, typeRef);
+
+    // If the resolved type is a builtin, stop and use its type arguments.
+    type = _normalizeTypeRef(typeRef.type);
+    if (typeof type === 'string' && isBuiltinType(type))
+      return _cacheResolved(props);
+
+    // Set to true (before the recursive call) to avoid cyclic issues.
+    finalBaseTypeCache[resolvedKey] = true;
+
+    // Continue the search
+    const finalBase = getFinalBaseTypeWithProps(type);
+    if (!finalBase) // Reference has no proper type, e.g. due to `type of View:calculated`.
+      return _cacheResolved(null);
+    const nonScalar = _cacheNonScalar(finalBase);
+    if (nonScalar)
+      return finalBaseTypeCache[resolvedKey];
+
+    // If not a non-scalar, must be resolved type.
+    _copyTypeProps(props, finalBase);
+    _cacheResolved(props);
+    return props;
+
+    /**
+     * Cache/Store the type props under the current `resolvedKey` in the `resolved` cache.
+     *
+     * @param {object} typeProps
+     */
+    function _cacheResolved(typeProps) {
+      finalBaseTypeCache[resolvedKey] = typeProps;
+      return typeProps;
+    }
+
+    /**
+     * Structured or arrayed types are not followed further, so cache them.
+     *
+     * @param obj
+     * @returns {boolean} True, if structured/arrayed/invalid, false if scalar.
+     */
+    function _cacheNonScalar(obj) {
+      if (!obj) { // Reference has no proper type, e.g. due to `type of View:calculated`.
+        _cacheResolved(null);
+        return true;
       }
-      else {
-        cycleCheck = Object.create(null);
+      if (obj.elements || obj.items) {
+        _cacheResolved(obj);
+        return true;
       }
-      let definedType = model.definitions[type];
-      if (definedType && definedType.type)
-        return getFinalBaseType(definedType.type, path, resolved, cycleCheck);
-      else
-        return getFinalBaseType(definedType, path, resolved, cycleCheck);
+      return false;
     }
-    else if (typeof(type) === 'object') {
-      if (type.ref) {
-        // assert type.ref instanceof Array && type.ref.length >= 1
-        const ref = resolved.has(type) ? resolved.get(type).art : artifactRef(type);
-        return getFinalBaseType(ref, path, resolved, cycleCheck);
-      }
-      else if (type.elements) {
-        if (path.length) {
-          let [e, ...p] = path;
-          return getFinalBaseType(type.elements[e], p, resolved, cycleCheck);
+
+    /**
+     * Copy type properties from source to target.  Also copies `type`, `enum`,
+     * and `localized` (if keepLocalized is true).  Only copies from source,
+     * if target does not have them.
+     *
+     * @param {object} target
+     * @param {object} source
+     */
+    function _copyTypeProps(target, source) {
+      target.type = source.type;
+      const typeProps = [ ...typeParameters.list, 'enum', 'default', 'localized' ];
+      for (const param of typeProps) {
+        if (target[param] === undefined && source[param] !== undefined) {
+          target[param] = source[param];
         }
       }
-      else if (type.type)
-        return (getFinalBaseType(type.type, path, resolved, cycleCheck));
-      else if (type.items)
-        return type;
-      else
-        // TODO: this happens if we don't have a type, e.g. an expression in a select list
-        // in a view without explicit type. Instead of returning null we might want to return
-        // the object instead?
-        return null;
+      return target;
     }
-    return type;
   }
 }
 
@@ -588,7 +611,7 @@ function getUtils(model, universalReady) {
  * @param {object} csn Top-level CSN.  You can pass non-dictionary values.
  * @param {CSN.Options} options CSN Options, only used for `dictionaryPrototype`, `testMode`, and `testSortCsn`
  */
-function cloneCsn(csn, options) {
+function cloneCsnNonDict(csn, options) {
   return sortCsn(csn, options);
 }
 
@@ -596,7 +619,7 @@ function cloneCsn(csn, options) {
  * Deeply clone the given CSN dictionary and return it.
  * Note that annotations are only copied shallowly.
  * This function does _not_ sort the given dictionary.
- * See cloneCsn() if you want sorted definitions.
+ * See cloneCsnNonDict() if you want sorted definitions.
  *
  * @param {object} csn
  * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
@@ -632,8 +655,10 @@ function forEachDefinition( csn, callback, iterateOptions = {} ) {
  * @param {CSN.Path} [path]
  * @param {boolean} [ignoreIgnore]
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param constructCallback
  */
-function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {}) {
+function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                        constructCallback = (_construct, _prop, _path) => {}) {
   // Allow processing _ignored elements if requested
   if (ignoreIgnore && construct._ignore) {
     return;
@@ -641,8 +666,7 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
 
   // `items` itself is a structure that can contain "elements", and more.
   if (construct.items) {
-    // TODO: Should we go to the deepest items.items?
-    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions );
+    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions, constructCallback );
   }
 
   // Unlike XSN, we don't make "returns" a "params" in the callback.
@@ -650,12 +674,43 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   // `elements` of the return type (if structured).
   // TODO: `returns` should be handled like a parameter just like XSN (maybe with different prop name)
   if (construct.returns && !iterateOptions.elementsOnly) {
-    forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions );
+    forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions, constructCallback );
   }
 
   path = [...path]; // Copy
   const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'actions', 'params']);
-  propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
+  propsWithMembers.forEach((prop) => {
+    forEachGeneric( construct, prop, callback, path, iterateOptions );
+    if (construct[prop]) {
+      if (Array.isArray(constructCallback))
+        constructCallback.forEach(cb => cb(construct, prop, path));
+      else
+        constructCallback(construct, prop, path);
+    }
+  });
+}
+
+/**
+ * Call `forEachMember` and then apply `forEachMember` on queries.
+ *
+ * @param {CSN.Artifact} construct
+ * @param {genericCallback|genericCallback[]} callback
+ * @param {CSN.Path} [path]
+ * @param {boolean} [ignoreIgnore]
+ * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
+ */
+function forEachMemberWithQuery( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+  constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMember(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
+  if (construct.query) {
+    forAllQueries(construct.query, (q, p) => {
+      const s = q.SELECT;
+      if(s) {
+        forEachMember(s, callback, p, ignoreIgnore, iterateOptions);
+      }
+    }, [ ...path, 'query' ]);
+  }
 }
 
 /**
@@ -667,16 +722,43 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
  * @param {CSN.Path} [path]
  * @param {boolean} [ignoreIgnore]
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
  */
-function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {}) {
-  forEachMember( construct, ( member, memberName, prop, subpath ) => {
+function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                                   constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMember( construct, ( member, memberName, prop, subpath, parent ) => {
     if(Array.isArray(callback))
-      callback.forEach(cb => cb( member, memberName, prop, subpath, construct ));
+      callback.forEach(cb => cb( member, memberName, prop, subpath, parent ));
     else
-      callback( member, memberName, prop, subpath, construct );
+      callback( member, memberName, prop, subpath, parent );
     // Descend into nested members, too
-    forEachMemberRecursively( member, callback, subpath, ignoreIgnore, iterateOptions);
-  }, path, ignoreIgnore, iterateOptions);
+    forEachMemberRecursively( member, callback, subpath, ignoreIgnore, iterateOptions, constructCallback);
+  }, path, ignoreIgnore, iterateOptions, constructCallback);
+}
+
+/**
+ * Apply function `callback(member, memberName)` to each member in `construct`,
+ * recursively (i.e. also for sub-elements of elements).
+ * Recursively iterate over elements of `construct` query.
+ *
+ * @param {CSN.Artifact} construct
+ * @param {genericCallback|genericCallback[]} callback
+ * @param {CSN.Path} [path]
+ * @param {boolean} [ignoreIgnore]
+ * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
+ */
+function forEachMemberRecursivelyWithQuery( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                                              constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMemberRecursively(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
+  if(construct.query) {
+    forAllQueries(construct.query, (q, p) => {
+      const s = q.SELECT;
+      if(s) {
+        forEachMemberRecursively(s, callback, p, ignoreIgnore, iterateOptions);
+      }
+    }, [ ...path, 'query' ]);
+  }
 }
 
 /**
@@ -685,14 +767,14 @@ function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=tr
  * the following arguments: the object, the name, and -if it is a duplicate-
  * the array index and the array containing all duplicates.
  *
- * @param {object} obj
+ * @param {object} construct
  * @param {string} prop
  * @param {genericCallback|genericCallback[]} callback
  * @param {CSN.Path} path
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
  */
-function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
-  const dict = obj[prop];
+function forEachGeneric( construct, prop, callback, path = [], iterateOptions = {}) {
+  const dict = construct[prop];
   for (const name in dict) {
     if (!Object.prototype.hasOwnProperty.call(dict, name))
       continue;
@@ -701,98 +783,79 @@ function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
        || (iterateOptions.skipArtifact && typeof iterateOptions.skipArtifact === 'function'
            && iterateOptions.skipArtifact(dictObj, name)))
       continue;
-    cb( dictObj, name );
+    executeCallbacks( dictObj, name );
   }
-  function cb(o, name ) {
+  function executeCallbacks(o, name ) {
     if (Array.isArray(callback))
-      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name])));
+      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name]), construct ));
     else
-      callback( o, name, prop, path.concat([prop, name]))
+      callback( o, name, prop, path.concat([prop, name]), construct )
   }
 }
 
-// Like Object.assign() but copies also non enumerable properties
-function assignAll(target, ...sources) {
-  sources.forEach(source => {
-    let descriptors = Object.getOwnPropertyNames(source).reduce((descriptors, key) => {
-      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
-      return descriptors;
-    }, {});
-    // by default, Object.assign copies enumerable Symbols too
-    Object.getOwnPropertySymbols(source).forEach(sym => {
-      let descriptor = Object.getOwnPropertyDescriptor(source, sym);
-      if (descriptor.enumerable) {
-        descriptors[sym] = descriptor;
-      }
-    });
-    Object.defineProperties(target, descriptors);
-  });
-  return target;
-}
-
 /**
- * @param {CSN.Query} query
- * @param {queryCallback|queryCallback[]} callback
+ * @param {CSN.Query} mainQuery
+ * @param {queryCallback|queryCallback[]} queryCallback
  * @param {CSN.Path} path
  */
-function forAllQueries(query, callback, path = []){
-  return traverseQuery(query, callback, path);
-  function traverseQuery( q, callback, p ) {
-    if (q.SELECT) {
+function forAllQueries(mainQuery, queryCallback, path = []){
+  return traverseQuery(mainQuery, queryCallback, path);
+  function traverseQuery( query, callback, queryPath ) {
+    if (query.SELECT) {
       // The projection is turned into a normalized query - there
       // is no real SELECT, it is fake
       if(!(path.length === 3 && path[2] === 'projection'))
-        p.push('SELECT');
-      cb( q, p );
-      q = q.SELECT;
+        queryPath.push('SELECT');
+      executeCallbacks();
+      query = query.SELECT;
     }
-    else if (q.SET) {
-      p.push('SET');
-      cb( q, p );
-      q = q.SET;
+    else if (query.SET) {
+      queryPath.push('SET');
+      executeCallbacks();
+      query = query.SET;
     }
 
-    if (q.from)
-      traverseFrom( q.from, callback, p.concat(['from']) );
+    if (query.from)
+      traverseFrom( query.from, callback, queryPath.concat(['from']) );
 
     for (const prop of ['args', 'xpr', 'columns', 'where', 'having']) {
       // all properties which could have sub queries (directly or indirectly)
-      const expr = q[prop];
+      const expr = query[prop];
       if (expr && typeof expr === 'object') {
         if(Array.isArray(expr)){
           for(let i = 0; i < expr.length; i++){
-            traverseQuery(expr[i], callback, p.concat([prop, i]));
+            traverseQuery(expr[i], callback, queryPath.concat([prop, i]));
           }
         } else {
           for(const argName of Object.keys( expr )){
-            traverseQuery(expr[argName], callback, p.concat([prop, argName]))
+            traverseQuery(expr[argName], callback, queryPath.concat([prop, argName]))
           }
         }
       }
     }
-    function cb(q, p) {
+    function executeCallbacks() {
       if(Array.isArray(callback))
-        callback.forEach(cb => cb( q, p ));
+        callback.forEach(cb => cb( query, queryPath ));
       else
-        callback( q, p );
+        callback( query, queryPath );
     }
   }
 
   /**
    * @param {CSN.QueryFrom} from
    * @param {Function} callback
-   * @param {CSN.Path} path
+   * @param {CSN.Path} csnPath
    */
-  function traverseFrom( from, callback, path = [] ) {
+  function traverseFrom( from, callback, csnPath = [] ) {
     if (from.ref) // ignore
       return;
     else if (from.args){ // join
       for(let i = 0; i < from.args.length; i++){
-        traverseFrom(from.args[i], callback, path.concat(['args', i]));
+        traverseFrom(from.args[i], callback, csnPath.concat(['args', i]));
       }
     }
     else
-      traverseQuery( from, callback, path ); // sub query in FROM
+      traverseQuery( from, callback, csnPath ); // sub query in FROM
   }
 }
 
@@ -837,12 +900,10 @@ function hasAnnotationValue(artifact, annotationName, expected = true, caseInsen
  * @param {ODataOptions} options EDM specific options
  */
 function isEdmPropertyRendered(elementCsn, options) {
-  if(options.toOdata)
-    options = options.toOdata;
   // FKs are rendered in
   // V2/V4 flat: always on
   // V4 struct: on/off
-  const renderForeignKey = (options.version === 'v4' && options.odataFormat === 'structured') ? !!options.odataForeignKeys : true;
+  const renderForeignKey = (options.odataVersion === 'v4' && options.odataFormat === 'structured') ? !!options.odataForeignKeys : true;
   const isNotIgnored = !elementCsn.target ? !elementCsn['@cds.api.ignore'] : true;
   const isNavigable = elementCsn.target ?
     (elementCsn['@odata.navigable'] === undefined ||
@@ -865,16 +926,19 @@ function isEdmPropertyRendered(elementCsn, options) {
  * - For the 'plain' naming mode, it means converting all '.' to '_' and upper-casing.
  * - For the 'quoted' naming mode, this means correctly replacing some '.' with '_'.
  *
- * If the old function signature is used - with a namespace as the third argument - the result might be wrong,
- * since the '.' -> '_' conversion for quoted/hdbcds is missing.
+ * The above rules might differ for different SQL dialects.
+ * Exceptions will be listed below.
  *
  * @param {string} artifactName The fully qualified name of the artifact
- * @param {('plain'|'quoted'|'hdbcds')} sqlMapping The naming mode to use
- * @param {CSN.Model|string|undefined} csn
+ * @param {'plain'|'quoted'|'hdbcds'|string} sqlMapping The naming mode to use
+ * @param {CSN.Model} csn
+ * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
  */
-function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn) {
-  if(csn && typeof csn === 'object' && csn.definitions)
+// eslint-disable-next-line no-unused-vars
+function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn, sqlDialect='plain') {
+  if(csn && typeof csn === 'object' && csn.definitions) {
+    isValidMappingDialectCombi(sqlDialect, sqlMapping)
     if (sqlMapping === 'quoted' || sqlMapping === 'hdbcds') {
       return getResultingName(csn, sqlMapping, artifactName);
     }
@@ -883,24 +947,8 @@ function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn) {
     } else {
       throw new Error('Unknown naming mode: ' + sqlMapping);
     }
-  else {
-    console.error(`This invocation of "getArtifactCdsPersistenceName" is deprecated, as it doesn't produce correct output with definition names containing dots - please provide a CSN as the third parameter.`);
-    if (sqlMapping === 'hdbcds') {
-      if (csn) {
-        const namespace = String(csn);
-        return `${namespace}::${artifactName.substring(namespace.length + 1)}`;
-      }
-      return artifactName;
-    }
-    else if (sqlMapping === 'plain') {
-      return artifactName.replace(/\./g, '_').toUpperCase();
-    }
-    else if (sqlMapping === 'quoted') {
-      return artifactName;
-    }
-    else {
-      throw new Error('Unknown naming mode: ' + sqlMapping);
-    }
+  } else {
+    throw new Error('A valid CSN model is required to correctly calculate the database name of an artifact.');
   }
 }
 
@@ -967,7 +1015,7 @@ function getUnderscoredName(startIndex, parts, csn) {
 
       return result;
     } else if(art && art.kind === 'service') {
-      // inside services, we immediatly turn . into _
+      // inside services, we immediately turn . into _
       const prefix = parts.slice(0, i).join('.');
       const suffix = parts.slice(i).join('_');
       const result = [];
@@ -983,6 +1031,12 @@ function getUnderscoredName(startIndex, parts, csn) {
   return null;
 }
 
+function isValidMappingDialectCombi(sqlDialect, sqlMapping) {
+  if(sqlMapping === 'hdbcds' && sqlDialect !== 'hana')
+    throw new Error(`sqlMapping "hdbcds" must only be used with sqlDialect "hana" - found: ${sqlDialect}`);
+  return true;
+}
+
 
 /**
  *  Return the resulting database element name for 'elemName', depending on the current
@@ -992,11 +1046,17 @@ function getUnderscoredName(startIndex, parts, csn) {
  *  - For the 'quoted' naming mode, it means converting all '.' to '_'.
  *  No other naming modes are accepted!
  *
+ *  The above rules might differ for different SQL dialects.
+ *  Exceptions will be listed below.
+ *
  * @param {string} elemName The name of the element
- * @param {('plain'|'quoted'|'hdbcds')} sqlMapping The naming mode to use
+ * @param {'plain'|'quoted'|'hdbcds'|string} sqlMapping The naming mode to use
+ * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database element name for 'elemName', depending on the current naming mode.
  */
-function getElementDatabaseNameOf(elemName, sqlMapping) {
+// eslint-disable-next-line no-unused-vars
+function getElementDatabaseNameOf(elemName, sqlMapping, sqlDialect='plain') {
+  isValidMappingDialectCombi(sqlMapping, sqlDialect)
   if (sqlMapping === 'hdbcds') {
     return elemName;
   }
@@ -1111,85 +1171,6 @@ function getNormalizedQuery(art) {
   return art;
 }
 
-/**
- * Merge multiple 'options' objects (from right to left, i.e. rightmost wins). Structured option values are
- * merged deeply. Structured option value from the right may override corresponding bool options on the left,
- * but no other combination of struct/scalar values is allowed. Array options are not merged, i.e. their
- * content is treated like scalars.
- * Returns a new options object.
- *
- * @param {...CSN.Options} optionsObjects
- * @return {CSN.Options}
- */
-function mergeOptions(...optionsObjects) {
-  let result = {};
-  for (const options of optionsObjects) {
-    if (options)
-      result = mergeTwo(result, options, 'options');
-  }
-
-  // Reverse the array to ensure that the rightmost option has priority
-  const reversedOptions = [...optionsObjects].reverse(); // de-structure and create a new array, so reverse doesn't impact optionsObject
-  const msgOptions = reversedOptions.find(opt => opt && Array.isArray(opt.messages));
-  if (msgOptions) {
-    result.messages = msgOptions.messages;
-  }
-
-  return result;
-
-  // Recursively used for scalars, too
-  function mergeTwo(left, right, name) {
-    let result;
-    // Copy left as far as required
-    if (Array.isArray(left)) {
-      // Shallow-copy left array
-      result = left.slice();
-    } else if (isObject(left)) {
-      // Deep-copy left object (unless empty)
-      result = Object.keys(left).length ? mergeTwo({}, left, name) : {};
-    } else {
-      // Just use left scalar
-      result = left;
-    }
-    // Check against improper overwriting
-    if (isObject(left) && !Array.isArray(left) && (Array.isArray(right) || isScalar(right))) {
-      throw new ModelError(`Cannot overwrite structured option "${name}" with array or scalar value`);
-    }
-    if ((isScalar(left) && typeof left !== 'boolean' || Array.isArray(left)) && isObject(right) && !Array.isArray(right)) {
-      throw new ModelError(`Cannot overwrite non-boolean scalar or array option "${name}" with structured value`);
-    }
-
-    // Copy or overwrite properties from right to left
-    if (Array.isArray(right)) {
-      // Shallow-copy right array
-      result = right.slice();
-    } else if (isObject(right)) {
-      // Object overwrites undefined, scalars and arrays
-      if (result === undefined || isScalar(result) || Array.isArray(result)) {
-        result = {};
-      }
-      // Deep-copy right object into result
-      for (let key of Object.keys(right)) {
-        result[key] = mergeTwo(result[key], right[key], `${name}.${key}`);
-      }
-    } else {
-      // Right scalar wins (unless undefined)
-      result = (right !== undefined) ? right : result;
-    }
-    return result;
-  }
-
-  // Return true if 'o' is a non-null object or array
-  function isObject(o) {
-    return typeof o === 'object' && o !== null
-  }
-
-  // Return true if 'o' is a non-undefined scalar
-  function isScalar(o) {
-    return o !== undefined && !isObject(o);
-  }
-}
-
 /**
 * If the artifact with the name given is part of a context (or multiple), return the top-most context.
 * Else, return the artifact itself. Namespaces are not of concern here.
@@ -1241,68 +1222,103 @@ function getLastPartOfRef(ref) {
   return getLastPartOf(lastPathStep.id || lastPathStep);
 }
 
-// Return the name of the parent artifact of the artifact 'name' or
-// '' if there is no parent.
-function getParentNameOf(name) {
-  return name.substring(0, name.lastIndexOf('.'));
-}
+/**
+ * Copy all annotations from 'fromNode' to 'toNode'.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} fromNode
+ * @param {object} toNode
+ * @param {boolean} [overwrite]
+ */
+function copyAnnotations(fromNode, toNode, overwrite = false) {
+  // Ignore if no toNode (in case of errors)
+  if (!toNode)
+    return;
 
-// Return an array of parent names of 'name' (recursing into grand-parents)
-// Examples:
-//   'foo.bar.wiz' => [ 'foo.bar', 'foo' ]
-//   'foo' => []
-//   'foo::bar.wiz' => 'foo::bar'
-//   'foo::bar' => []
-function getParentNamesOf(name) {
-  let remainder = name.slice(0, -getLastPartOf(name).length);
-  if (remainder.endsWith('.')) {
-    let parentName = remainder.slice(0, -1);
-    return [parentName, ...getParentNamesOf(parentName)];
-  } else {
-    return [];
+  const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
+
+  for (const anno of annotations) {
+    if (toNode[anno] === undefined || overwrite) {
+      toNode[anno] = fromNode[anno];
+    }
   }
 }
 
 
-// Copy all annotations from 'fromNode' to 'toNode'. Overwrite existing ones only if 'overwrite' is true
-function copyAnnotations(fromNode, toNode, overwrite=false) {
+/**
+ * Same as `copyAnnotations()` but also copies the
+ * annotation-like property `doc`.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} fromNode
+ * @param {object} toNode
+ * @param {boolean} [overwrite]
+ */
+function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
   // Ignore if no toNode (in case of errors)
-  if (!toNode) {
+  if (!toNode)
     return;
-  }
-  for (let prop in fromNode) {
-    if (!Object.hasOwnProperty.call( fromNode, prop ))
-      continue;
-    if (prop.startsWith('@')) {
-      if (toNode[prop] === undefined || overwrite) {
-        toNode[prop] = fromNode[prop];
-      }
+
+  const annotations = Object.keys(fromNode)
+    .filter(key => key.startsWith('@') || key === 'doc');
+
+  for (const anno of annotations) {
+    if (toNode[anno] === undefined || overwrite) {
+      toNode[anno] = fromNode[anno];
     }
   }
 }
 
-function isAspect(node) {
-  return node && node.kind === 'aspect';
-}
-
-// For each property named 'path' in 'node' (recursively), call callback(path, node)
-function forEachPath(node, callback) {
-  if (node === null || typeof node !== 'object') {
-    // Primitive node
+/**
+ * Applies annotations from `csn.extensions` to definitions and their elements.
+ *
+ * `config.filter` can be used to only copy annotations for those definitions,
+ * for which the filter returns true.
+ *
+ * @todo Does _not_ apply param/action/... annotations.
+ *
+ * @param {CSN.Model} csn
+ * @param {{overwrite?: boolean, filter?: (name: string) => boolean}} config
+ */
+function applyAnnotationsFromExtensions(csn, config) {
+  if (!csn.extensions)
     return;
-  }
-  for (let name in node) {
-    if (!Object.hasOwnProperty.call( node, name ))
-      continue;
-    // If path found within a non-dictionary, call callback
-    if (name === 'path' && Object.getPrototypeOf(node)) {
-      callback(node.path, node);
+
+  const filter = config.filter || ((_name) => true);
+  for (const ext of csn.extensions) {
+    const name = ext.annotate || ext.extend;
+    const def = csn.definitions[name];
+    if (name && def && filter(name)) {
+      copyAnnotationsAndDoc(ext, def, config.overwrite);
+      applyAnnotationsToElements(ext, def);
     }
-    // Descend recursively
-    forEachPath(node[name], callback);
+  }
+
+  function applyAnnotationsToElements(ext, def) {
+    // Only the definition is arrayed but the extension is not since
+    // `items` is not expected in `extensions` by the CSN frontend and not
+    // generated by the CDL parser for `annotate E:arrayed.elem`.
+    if (def.items)
+      def = def.items;
+
+    if (!ext.elements || !def.elements)
+      return;
+
+    forEach(ext.elements, (key, sourceElem) => {
+      const targetElem = def.elements[key];
+      if (targetElem) {
+        copyAnnotationsAndDoc(sourceElem, targetElem, config.overwrite);
+        applyAnnotationsToElements(sourceElem, targetElem);
+      }
+    });
   }
 }
 
+function isAspect(node) {
+  return node && node.kind === 'aspect';
+}
 
 /**
  * Return true if the artifact has a valid, truthy persistence.exists/skip annotation
@@ -1379,16 +1395,6 @@ function getServiceNames(csn) {
   return result;
 }
 
-/**
- * Check whether the artifact is @cds.persistence.skip
- *
- * @param {CSN.Artifact} artifact
- * @returns {Boolean}
- */
-function isSkipped(artifact) {
-  return hasAnnotationValue(artifact, '@cds.persistence.skip', true)
-}
-
 /**
  * Walk path in the CSN and return the result.
  *
@@ -1442,7 +1448,7 @@ function getVariableReplacement(ref, options) {
  * @returns {boolean} returns equality
  *
  * noExtendedProps remove '$', '_' and '@' properties from
- * the comparision. This eliminates false negatives such as
+ * the comparison. This eliminates false negatives such as
  *  mismatching $locations or @odata.foreignKey4.
  */
 function isDeepEqual(obj, other, noExtendedProps) {
@@ -1472,14 +1478,17 @@ function isDeepEqual(obj, other, noExtendedProps) {
 
 module.exports = {
   getUtils,
-  cloneCsn,
+  cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
+  cloneCsnNonDict,
   cloneCsnDictionary,
   isBuiltinType,
-  assignAll,
+  applyAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,
   forEachMember,
+  forEachMemberWithQuery,
   forEachMemberRecursively,
+  forEachMemberRecursivelyWithQuery,
   forAllQueries,
   hasAnnotationValue,
   isEdmPropertyRendered,
@@ -1493,20 +1502,16 @@ module.exports = {
   isPersistedOnDatabase,
   generatedByCompilerVersion,
   getNormalizedQuery,
-  mergeOptions,
   getRootArtifactName,
   getLastPartOfRef,
-  getParentNamesOf,
-  getParentNameOf,
   getLastPartOf,
   copyAnnotations,
+  copyAnnotationsAndDoc,
   isAspect,
-  forEachPath,
   hasValidSkipOrExists,
   getNamespace,
   sortCsnDefinitionsForTests,
   getServiceNames,
-  isSkipped,
   walkCsnPath,
   getVariableReplacement,
   implicitAs,