@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/render/utils/sql.js

@@ -4,20 +4,21 @@
 
 const { getResultingName } = require('../../model/csnUtils');
 const { smartId, delimitedId } = require('../../sql-identifier');
+const { ModelError } = require('../../base/error');
 
 /**
  * Render a given referential constraint as part of a SQL CREATE TABLE statement, or as .hdbconstraint artefact.
  *
  * @param {CSN.ReferentialConstraint} constraint Content of the constraint
  * @param {string} indent Indent to render the SQL with
- * @param {boolean} toUpperCase Wether to uppercase the identifier
+ * @param {boolean} toUpperCase Whether to uppercase the identifier
  * @param {CSN.Model} csn CSN
  * @param {CSN.Options} options is needed for the naming mode and the sql dialect
- * @param {boolean} alterConstraint whether the constraint should be rendered as part of an ALTER TABLE statement
+ * @param {boolean} [alterConstraint=false] whether the constraint should be rendered as part of an ALTER TABLE statement
  *
  * @returns {string} SQL statement which can be used to create the referential constraint on the db.
  */
-function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint) {
+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') {
@@ -51,14 +52,16 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
   if (!alterConstraint) {
     result += `${indent}FOREIGN KEY(${constraint.foreignKey.map(quoteId).join(', ')})\n`;
     result += `${indent}REFERENCES ${quoteId(getResultingName(csn, names, constraint.parentTable))}(${constraint.parentKey.map(quoteId).join(', ')})\n`;
+    const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
+
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
     if (forSqlite) {
       if (constraint.onDelete === 'CASCADE' )
-        result += `${indent}ON DELETE ${constraint.onDelete}${constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : ''}\n`;
+        result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
     else {
       result += `${indent}ON UPDATE RESTRICT\n`;
-      result += `${indent}ON DELETE ${constraint.onDelete}${constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : ''}\n`;
+      result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
@@ -119,7 +122,7 @@ function getIdentifierUtils(options) {
   function prepareIdentifier(name) {
     // Sanity check
     if (options.toSql.dialect === 'sqlite' && options.toSql.names !== 'plain')
-      throw new Error(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
+      throw new ModelError(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
 
 
     switch (options.toSql.names) {
@@ -130,7 +133,7 @@ function getIdentifierUtils(options) {
       case 'hdbcds':
         return name;
       default:
-        throw new Error(`No matching rendering found for naming mode ${options.toSql.names}`);
+        throw new ModelError(`No matching rendering found for naming mode ${options.toSql.names}`);
     }
   }
 }

package/lib/render/utils/stringEscapes.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const controlCharacters = /[\u{0000}-\u{001F}]/u;
+const highSurrogate = /[\u{D800}-\u{DBFF}]/u;
+const lowSurrogate = /[\u{DC00}-\u{DFFF}]/u;
+// Either a high surrogate that is NOT followed by a low one or
+// a low surrogate not preceded by a high one.
+const unpairedSurrogate = /[^\u{D800}-\u{DBFF}][\u{DC00}-\u{DFFF}]|[\u{D800}-\u{DBFF}][^\u{DC00}-\u{DFFF}]/u;
+
+/**
+ * Returns true if the string contains an unpaired unicode surrogate.
+ * See <https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF>.
+ * As a surrogate pair MUST consist of a high one followed by a low surrogate,
+ * an unpaired surrogate MUST be escaped.
+ *
+ * @param {string} str
+ * @return {boolean}
+ */
+function hasUnpairedUnicodeSurrogate(str) {
+  return unpairedSurrogate.test(str);
+}
+
+/**
+ * Returns true if the string contains control characters such as LF or NUL.
+ *
+ * @param {string} str
+ * @return {boolean}
+ */
+function hasControlCharacters(str) {
+  return controlCharacters.test(str);
+}
+
+/**
+ * Escape the given string according to the given specification in `escapes`.
+ *
+ * `escapes` is an object where the entries are either:
+ *   - a mapping from character to string, e.g. `{ '"': '&quot;' }`
+ *   - `control: (codePoint) => str`
+ *     A function that returns an escape sequence for the given control character.
+ *   - `unpairedSurrogate: (codePoint) => str`
+ *     A function that returns an escape sequence for the given unpaired unicode surrogate.
+ *
+ * Multi-character keys are not allowed.
+ *
+ * Character escapes take precedence over `control` and `unpairedSurrogate` escapes,
+ * i.e. if you do not want to encode LF (`\n`), add an explicit mapping for it, e.g.
+ * `{ '\n': '\n' }`.
+ *
+ * @example
+ *   You can use `escapeString()` like this:
+ *   ```js
+ *   let escaped = escapeString(str, {
+ *     '"': '\\"',
+ *     control: (c) => `\\u{${c.toString(16)}}`;
+ *     unpairedSurrogate: (c) => `\\u{${c.toString(16)}}`;
+ *   });
+ *   ```
+ *
+ * @param {string} str
+ * @param {object} escapes
+ * @returns {string}
+ */
+function escapeString(str, escapes) {
+  const output = [];
+
+  for (let i = 0; i < str.length; ++i) {
+    const char = str[i];
+
+    if (char in escapes) {
+      output.push(escapes[char]);
+      continue;
+    }
+
+    // Control Characters: C0
+    // See <https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Basic_ASCII_control_codes>
+    if (controlCharacters.test(char)) {
+      output.push(escapes.control ? escapes.control(char.codePointAt(0)) : char);
+      continue;
+    }
+
+    // Unicode Surrogates
+    // These characters appear in _pairs_.  A high surrogate must be followed by a low surrogate.
+    // If this is not the case, either needs to be encoded.  This is also done by JSON.
+    // See also <https://docs.microsoft.com/en-us/globalization/encoding/surrogate-pairs>
+    if (highSurrogate.test(char)) {
+      if (i + 1 >= str.length || !lowSurrogate.test(str[i + 1])) {
+        output.push(escapes.unpairedSurrogate ? escapes.unpairedSurrogate(char.codePointAt(0)) : char);
+      }
+      else {
+        output.push(char);
+        ++i;
+        output.push(str[i]);
+      }
+    }
+    else if (lowSurrogate.test(char)) {
+      output.push(escapes.unpairedSurrogate ? escapes.unpairedSurrogate(char.codePointAt(0)) : char);
+    }
+    else {
+      // unhandled / non-special character
+      output.push(char);
+    }
+  }
+
+  return output.join('');
+}
+
+module.exports = {
+  escapeString,
+  hasUnpairedUnicodeSurrogate,
+  hasControlCharacters,
+};

package/lib/sql-identifier.js

@@ -9,7 +9,7 @@
 //    an identifier such that the effective name (the one in the DB schema) is
 //    the same as the name used in CDS.
 //  - 'quoted' and 'hdbcds' for HANA only: similar to the non-provided previous
-//    mode, with different adoptations to HANA CDS and XS (classic) restrictions.
+//    mode, with different adaptations to HANA CDS and XS (classic) restrictions.
 
 // The main objective of this file is to support the 'plain' mode in a “smart”
 // manner.  If we would use the CDS name (after `.` to `_` replacements)

package/lib/transform/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-shadow": "off"
+  }
+}

package/lib/transform/braceExpression.js

@@ -1,8 +1,10 @@
 'use strict';
 
 function isAlreadyBraced(expression, start, end){
-  const isBraced = start - 1 > -1 && end + 1 < expression.length && expression[start-1] === '(' && expression[end+1] === ')';
-  return isBraced;
+  return start - 1 > -1 &&
+    end + 1 < expression.length &&
+    expression[start-1] === '(' &&
+    expression[end+1] === ')';
 }
 
 function binarycomparison(expression, token, index){

package/lib/transform/db/.eslintrc.json

@@ -13,6 +13,8 @@
     // Don't enforce stupid descriptions
     "jsdoc/require-param-description": "off",
     "jsdoc/require-returns-description": "off",
+    // Sometimes if-else's are more specific
+    "sonarjs/prefer-single-boolean-return": "off",
     // Very whiny and nitpicky
     "sonarjs/cognitive-complexity": "off",
     // Does not recognize TS types

package/lib/transform/db/applyTransformations.js

@@ -18,12 +18,11 @@ const { setProp } = require('../../base/model');
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
+ * @param {applyTransformationsOptions} [options={}]
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
-function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, skipIgnore, options, path = []) {
+function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, options, path = []) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -32,6 +31,7 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
     enum: dictionary,
     mixin: dictionary,
     ref: pathRef,
+    $origin: () => {}, // no-op
   };
 
   const csnPath = [ ...path ];
@@ -50,7 +50,12 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
    * @param {object} node The value of node[_prop]
    */
   function standard( _parent, _prop, node ) {
-    if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( _parent, _prop ) || (typeof _prop === 'string' && _prop.startsWith('@')) || (skipIgnore && node._ignore))
+    if (!node || typeof node !== 'object' ||
+        !{}.propertyIsEnumerable.call( _parent, _prop ) ||
+        (typeof _prop === 'string' && _prop.startsWith('@')) ||
+        (options.skipIgnore && node._ignore) ||
+        (options.skipStandard && options.skipStandard[_prop])
+    )
       return;
 
     csnPath.push( _prop );
@@ -80,7 +85,7 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
    */
   function dictionary( node, _prop, dict ) {
     // Allow skipping dicts like actions in forHanaNew
-    if (options.skipDict && options.skipDict[_prop])
+    if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
       return;
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict ))
@@ -101,7 +106,10 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
   function definitions( node, _prop, dict ) {
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict )) {
-      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
+      const skip = (options && options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
+                   (options && options.skipArtifact && options.skipArtifact(dict[name], name)) ||
+                   (options && options.skip && options.skip.includes(dict[name].kind)) ||
+                   false;
       if (!skip) {
         artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
         standard( dict, name, dict[name] );
@@ -152,13 +160,15 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
  * @param {object} csn CSN to enrich in-place
  * @param {object} customTransformers Map of _prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
+ * @param {applyTransformationsOptions} [options={}]
  * @returns {object} CSN with transformations applied
  */
-function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], skipIgnore = true, options = {} ) {
+function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], options = { } ) {
+  if (options.skipIgnore === undefined)
+    options.skipIgnore = true;
+
   if (csn && csn.definitions)
-    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, skipIgnore, options);
+    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, options);
   return csn;
 }
 
@@ -176,14 +186,27 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
  * @param {object} parent The "parent" of which we transform a property of
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {applyTransformationsOptions} [options={}]
  * @param {CSN.Path} path Path pointing to parent
  * @returns {object} parent[prop] with transformations applied
  */
-function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, path = []) {
-  return applyTransformationsInternal(parent, prop, customTransformers, [], true, {}, path)[prop];
+function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, options = {}, path = []) {
+  return applyTransformationsInternal(parent, prop, customTransformers, [], options, path)[prop];
 }
 
 module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
 };
+
+
+/**
+ * @typedef {object} applyTransformationsOptions
+ * @property {(artifact, name) => boolean} [allowArtifact] to only allow certain artifacts
+ * @property {(artifact, name) => boolean} [skipArtifact] to skip certain artifacts
+ * @property {boolean} [drillRef] whether to drill into infix/args
+ * @property {string[]} [skip] skip definitions from certain kind
+ * @property {object} [skipStandard] stop drill-down on certain "standard" props
+ * @property {object} [skipDict] stop drill-down on certain "dictionary" props
+ * @property {boolean} [skipIgnore=true] Whether to skip _ignore elements or not
+ */

package/lib/transform/db/assertUnique.js

@@ -158,7 +158,7 @@ function processAssertUnique(csn, options, error, info) {
     function toRef(val) {
       let ref = val.split('.');
       const [ head, ...tail ] = ref;
-      if ([ '$self', '$projection' ].includes(head))
+      if (head === '$self' || head === '$projection')
         ref = tail;
       return {
         ref: ref.map((ps) => {

package/lib/transform/db/associations.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const {
+  applyTransformationsOnNonDictionary,
+  applyTransformations,
+  getUtils,
+} = require('../../model/csnUtils');
+
+
+/**
+ * In all .elements of entities and views (and their bound actions/functions), create the on-condition for
+ * a managed associations. This needs to happen after the .keys are expanded and the corresponding elements are created.
+ *
+ * @param {CSN.Model} csn
+ * @param {string} pathDelimiter
+ * @returns {CSN.Model} Return the input csn, with the transformations applied
+ */
+function attachOnConditions(csn, pathDelimiter) {
+  const {
+    isManagedAssociation,
+  } = getUtils(csn);
+
+  const alreadyHandled = new WeakMap();
+  applyTransformations(csn, {
+    elements: (parent, prop, elements) => {
+      for (const elemName in elements) {
+        const elem = elements[elemName];
+        // (140) Generate the ON-condition for managed associations
+        if (isManagedAssociation(elem))
+          transformManagedAssociation(elem, elemName);
+      }
+    },     /* only for views and entities */
+  }, [], { skipIgnore: false, allowArtifact: artifact => (artifact.kind === 'entity') });
+
+  return csn;
+
+  /**
+   * Create the foreign key elements for a managed association and build the on-condition
+   *
+   * @param {Object} elem The association to process
+   * @param {string} elemName
+   * @returns {void}
+   */
+  function transformManagedAssociation(elem, elemName) {
+    // No need to run over this - we already did, possibly because it was referenced in the ON-Condition
+    // of another association - see a few lines lower
+    if (alreadyHandled.has(elem))
+      return;
+    // Assemble an ON-condition with the foreign keys created in earlier steps
+    const onCondParts = [];
+    let joinWithAnd = false;
+    if (elem.keys.length === 0) { // TODO: really kill instead of _ignore?
+      elem._ignore = true;
+    }
+    else {
+      for (const foreignKey of elem.keys) {
+        // Assemble left hand side of 'assoc.key = fkey'
+        const assocKeyArg = {
+          ref: [
+            elemName,
+          ].concat(foreignKey.ref),
+        };
+        const fkName = `${elemName}${pathDelimiter}${foreignKey.as}`;
+        const fKeyArg = {
+          ref: [
+            fkName,
+          ],
+        };
+
+        if (joinWithAnd) { // more than one FK
+          onCondParts.push('and');
+        }
+
+        onCondParts.push(
+          assocKeyArg
+        );
+        onCondParts.push('=');
+        onCondParts.push(fKeyArg);
+
+        if (!joinWithAnd)
+          joinWithAnd = true;
+      }
+      elem.on = onCondParts;
+    }
+
+    // If the managed association has a 'key' property => remove it as unmanaged assocs cannot be keys
+    // TODO: Are there other modifiers (like 'key') that are valid for managed, but not valid for unmanaged assocs?
+    if (elem.key)
+      delete elem.key;
+
+    // If the managed association has a 'not null' property => remove it
+    if (elem.notNull)
+      delete elem.notNull;
+
+    // The association is now unmanaged, i.e. actually it should no longer have foreign keys
+    // at all. But the processing of backlink associations below expects to have them, so
+    // we don't delete them
+    // TODO: maybe make non-enumerable, so we become recompilable in the future?
+
+    // Remember that we already processed this
+    alreadyHandled.set(elem, true);
+  }
+}
+
+/**
+ * @param {CSN.Model} csn
+ * @param {string} pathDelimiter
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
+ */
+function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
+  const {
+    inspectRef,
+  } = getUtils(csn);
+
+  return handleManagedAssocStepsInOnCondition;
+
+  /**
+   * Loop over all elements and for all unmanaged associations translate
+   * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
+   *
+   * Or in other words: Allow using the foreign keys of managed associations in on-conditions
+   *
+   * @param {CSN.Artifact} artifact Artifact to check
+   * @param {string} artifactName Name of the artifact
+   */
+  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
+    for (const elemName in artifact.elements) {
+      const elem = artifact.elements[elemName];
+      // The association is an unmanaged on
+      if (!elem.keys && elem.target && elem.on) {
+        applyTransformationsOnNonDictionary(elem, 'on', {
+          ref: (refOwner, prop, ref, path) => {
+            // [<assoc base>.]<managed assoc>.<field>
+            if (ref.length > 1) {
+              const { links } = inspectRef(path);
+              if (links) {
+                // eslint-disable-next-line for-direction
+                for (let i = links.length - 1; i >= 0; i--) {
+                  const link = links[i];
+                  // We found the latest managed assoc path step
+                  if (link.art && link.art.target && link.art.keys &&
+                    // Doesn't work when ref-target (filter condition) or similar is used
+                    !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
+                    // We join the managed assoc with everything following it
+                    const sourceElementName = ref.slice(i).join(pathDelimiter);
+                    const source = findSource(links, i - 1) || artifact;
+                    // allow specifying managed assoc on the source side
+                    const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
+                    if (fks && fks.length >= 1) {
+                      const fk = fks[0];
+                      const managedAssocStepName = refOwner.ref[i];
+                      const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
+                      if (source && source.elements[fkName])
+                        refOwner.ref = [ ...ref.slice(0, i), fkName ];
+                    }
+                  }
+                }
+              }
+            }
+          },
+        }, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+      }
+    }
+
+    /**
+     * Find out where the managed association is
+     *
+     * @param {Array} links
+     * @param {number} startIndex
+     * @returns {Object| undefined} CSN definition of the source of the managed association
+     */
+    function findSource(links, startIndex) {
+      for (let i = startIndex; i >= 0; i--) {
+        const link = links[i];
+        // We found the latest assoc step - now check where that points to
+        if (link.art && link.art.target)
+          return csn.definitions[link.art.target];
+      }
+
+      return undefined;
+    }
+  }
+}
+module.exports = {
+  attachOnConditions,
+  getManagedAssocStepsInOnConditionFinalizer,
+};

package/lib/transform/db/cdsPersistence.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const {
+  forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
+  getUtils,
+} = require('../../model/csnUtils');
+const transformUtils = require('../transformUtilsNew');
+
+const exists = '@cds.persistence.exists';
+
+/**
+ * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
+ * with _ignore.
+ *
+ * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
+ */
+function getAnnoProcessor() {
+  return handleCdsPersistence;
+  /**
+   * @param {CSN.Artifact} artifact
+   */
+  function handleCdsPersistence(artifact) {
+    const ignoreArtifact = (artifact.kind === 'entity') &&
+                           (artifact.abstract ||
+                            hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                            hasAnnotationValue(artifact, exists));
+    if (ignoreArtifact)
+      artifact._ignore = true;
+  }
+}
+
+/**
+ * Return a callback function for forEachDefinition that marks associations with _ignore
+ * if their target does not reach the database, i.e. marked with @cds.persistence.skip or is abstract
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.info
+ * @returns {(artifact: CSN.Artifact, artifactName: string, prop: string, path: CSN.Path) => void} Callback function for forEachDefinition
+ */
+function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
+  const { info } = messageFunctions;
+  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
+
+  const { isAssocOrComposition } = getUtils(csn);
+
+  return ignoreAssociationToSkippedTarget;
+  /**
+   * Associations that target a @cds.persistence.skip artifact must be removed
+   * from the persistence model
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   * @param {string} prop
+   * @param {CSN.Path} path
+   */
+  function ignoreAssociationToSkippedTarget(artifact, artifactName, prop, path) {
+    if (isPersistedOnDatabase(artifact)) {
+      // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
+      if (artifact.query) {
+        // If we do A2J, we don't need to check the mixin. Either it is used -> a join
+        // or published -> handled via elements/members. Unused mixins are removed anyway.
+        if (!doA2J && artifact.query.SELECT && artifact.query.SELECT.mixin)
+          forEachGeneric(artifact.query.SELECT, 'mixin', ignore, path.concat([ 'query', 'SELECT' ]));
+
+        else if (!doA2J && artifact.query.SET && artifact.query.SET.mixin)
+          forEachGeneric(artifact.query.SET, 'mixin', ignore, path.concat([ 'query', 'SET' ]));
+      }
+      forEachMemberRecursively(artifact, ignore, [ 'definitions', artifactName ]);
+    }
+  }
+
+  /**
+   * Mark the given member with _ignore if it is an association/composition and it's target is unreachable.
+   *
+   * @param {CSN.Element} member
+   * @param {string} memberName
+   * @param {string} prop
+   * @param {CSN.Path} path
+   * @todo Why do we check for @cds.persistence.exists here if the parent-function only calls this for skip/abstract?
+   */
+  function ignore(member, memberName, prop, path) {
+    if (options.sqlDialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
+      const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], exists) ? exists : '@cds.persistence.skip';
+      info(null, path,
+           { target: member.target, anno: targetAnnotation },
+           'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
+      member._ignore = true;
+    }
+  }
+
+  /**
+   * Check whether the given artifact is an unreachable association target because it will not "realy" hit the database:
+   * - @cds.persistence.skip/exists
+   * - abstract
+   *
+   * @param {CSN.Artifact} art
+   * @returns {boolean}
+   */
+  function isUnreachableAssociationTarget(art) {
+    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, exists);
+  }
+}
+
+/**
+ * Return a callback function for forEachDefinition that handles artifacts marked with @cds.persistence.table.
+ * If a .query artifact has this annotation, the .query will be deleted and it will be treated like a table.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
+ */
+function getPersistenceTableProcessor(csn, options, messageFunctions ) {
+  const { error } = messageFunctions;
+  const {
+    recurseElements,
+  } = transformUtils.getTransformers(csn, options, '_');
+
+  return handleQueryish;
+
+
+  /**
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   */
+  function handleQueryish(artifact, artifactName) {
+    const stripQueryish = artifact.query && hasAnnotationValue(artifact, '@cds.persistence.table');
+
+    if (stripQueryish) {
+      artifact.kind = 'entity';
+      delete artifact.query;
+
+      recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
+        // All elements must have a type for this to work
+        if (!member._ignore && !member.kind && !member.type)
+          error(null, path, 'Expecting element to have a type if view is annotated with “@cds.persistence.table“');
+      });
+    }
+  }
+}
+
+
+module.exports = {
+  getAnnoProcessor,
+  getAssocToSkippedIgnorer,
+  getPersistenceTableProcessor,
+};