@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/model/enrichCsn.js

@@ -7,9 +7,9 @@
 
 // * `File.cds:3:5` if the original CSN has a non-enumerable `$location` property
 //   with value `{file: "File.cds", line: 3, col: 5}`.
-// * `File.cds:3:5-1` if the original CSN has _no_ `$location` property, for an
+// * `File.cds:3:5^` if the original CSN has _no_ `$location` property, for an
 //   inferred member of a main artifact or member with `$location: `File.cds:3:5`;
-//   the number of digits in the `-1` suffix is the member depth.
+//   the number of `^`s in the suffix is the member depth.
 
 // Other enumerable properties in the JSON for non-enumerable properties in the
 // original CSN:
@@ -25,11 +25,17 @@
 // * `_type`, `_includes` and `_targets` have as values the `$location`s of the
 //   referred artifacts which are returned by function `artifactRef`.
 // * `_links` and `_art` as sibling properties of `ref` have as values the
-//   `$locations` of the artifacts/members returned by function `inspectRef`.
+//   `$locations` of the artifacts/members returned by function `inspectRef` (`_art`
+//   for ref in `from` only, where it is different to the last item of `_links`).
 // * `_scope` and `_env` as sibling properties of `ref` have (string) values,
 //   returned by function `inspectRef`, giving add/ info about the “ref base”.
 // * `_origin` (in Universal CSN only) has as value the `$location` of the
 //   prototype returned by function getOrigin().
+// * `_test.inspect.csnpath` as sibling property of `ref` has an object value
+//   with properties `_links` and `_scope` of a further `inspectRef` call;
+//   it is only called, with `[‹art›, ...‹csnpath›]` as argument, if `‹art›`,
+//   which is the referred artifact returned by the first `inspectRef` call,
+//   has an annotation `@$test.inspect.csnpath` with array value `‹csnpath›`.
 
 'use strict';
 
@@ -55,10 +61,14 @@ function enrichCsn( csn, options = {} ) {
     // TODO: excluding
     '@': () => { /* ignore annotations */ },
   }
-  setLocations( csn, false, null );
-  const { inspectRef, artifactRef, getOrigin, __getCache_forEnrichCsnDebugging } =
-      csnRefs( csn );
+  // options.enrichCsn = 'DEBUG';
   let $$cacheObjectNumber = 0;   // for debugging
+  const debugLocationInfo = options.enrichCsn === 'DEBUG' && Object.create(null);
+
+  setLocations( csn, false, null );
+  const { inspectRef, artifactRef, getOrigin, initDefinition, __getCache_forEnrichCsnDebugging } =
+        csnRefs( csn, true );
+
   const csnPath = [];
   if (csn.definitions)
     dictionary( csn, 'definitions', csn.definitions );
@@ -92,7 +102,7 @@ function enrichCsn( csn, options = {} ) {
     // call getOrigin() before standard() to set implicit protos inside standard():
     const origin = handleError( err => err ? err.toString() : getOrigin( obj ) );
     standard( parent, prop, obj );
-    if (obj.$origin === undefined && origin != null)
+    if (obj.$origin === undefined && !obj.type && origin != null)
       obj._origin = refLocation( origin );
   }
 
@@ -101,6 +111,8 @@ function enrichCsn( csn, options = {} ) {
       return;
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
+      if (prop === 'definitions')
+        initDefinition( dict[name] );
       definition( dict, name, dict[name] );
     }
     if (!Object.prototype.propertyIsEnumerable.call( parent, prop ))
@@ -109,11 +121,19 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function refLocation( art ) {
-    if (art && typeof art === 'object')
-      return art.$location || '<no location>';
+    if (!art || typeof art !== 'object' || Array.isArray( art )) {
+      if (!options.testMode)
+        return (typeof art === 'string')
+        ? `<illegal ref = ${art}>`
+        : `<illegal ref: ${typeof art}>`;
+      throw new Error( 'Illegal reference' );
+    }
+    else if (art.$location)
+      return art.$location;
+
     if (!options.testMode)
-      return art || '<illegal link>';
-    throw new Error( 'Undefined reference' );
+      return `<${Object.keys( art ).join('+')}+!$location>`;
+    throw new Error( 'Reference to object without $location' );
   }
 
   function simpleRef( parent, prop, ref ) {
@@ -142,16 +162,18 @@ function enrichCsn( csn, options = {} ) {
     handleError( err => {
       if (err)
         parent._origin = err.toString();
-      else if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […], not $origin: {…}
-        parent._origin = refLocation( getOrigin( parent, true ) );
-      else if ( ref )
+      else if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […] / "short-ref"
+        parent._origin = refLocation( getOrigin( parent ) );
+      else if ( ref )                                           // $origin: {…}
         standard( parent, prop, ref );
     } );
   }
 
-  function pathRef( parent, prop, path ) {
-    const { links, art, scope, $env }
-          = handleError( err => (err) ? { scope: err.toString() } : inspectRef( csnPath ) );
+  function pathRef( parent, prop, path, inspectionPath = csnPath ) {
+    const inspection = handleError( (err) => {
+      return (err) ? { scope: err.toString() } : inspectRef( inspectionPath );
+    });
+    const { links, art, scope, $env } = inspection;
     if (links)
       parent._links = links.map( l => refLocation( l.art ) );
     if (links && links[links.length-1].art !== art)
@@ -160,6 +182,15 @@ function enrichCsn( csn, options = {} ) {
     if ($env)
       parent._env = $env;
 
+    if (!prop)                  // recursive call for @$test.inspect.csnpath
+      return;
+    const testPath = art && art['@$test.inspect.csnpath'];
+    if (testPath && parent.ref) {
+      const further = {};
+      pathRef( further, null, null, [ inspection, ...testPath ] );
+      parent['_test.inspect.csnpath'] = further;
+    }
+
     csnPath.push( prop );
     path.forEach( function step( s, i ) {
       if (s && typeof s === 'object') {
@@ -225,6 +256,10 @@ function enrichCsn( csn, options = {} ) {
             obj.$$cacheObject[name] = sub;
           }
         }
+        else if (name === '$origin$step') { // string value handled above
+          const kind = Object.keys( val )[0];
+          obj.$$cacheObject[name] = `${kind}: ${ val[kind] }`;
+        }
         else if (Array.isArray( val )) {
           obj.$$cacheObject[name] = val.map( item => {
             if (!item.$$objectNumber)
@@ -240,8 +275,53 @@ function enrichCsn( csn, options = {} ) {
       }
     }
   }
+
+  function debugLocation( loc, userProvided ) {
+    if (debugLocationInfo && !userProvided) {
+      loc = loc.replace( /\([0-9]+\)\^/, '^' );
+      debugLocationInfo[loc] = (debugLocationInfo[loc] || 0) + 1;
+      loc = `${loc}(${debugLocationInfo[loc]})`;
+    }
+    return loc;
+  }
+
+  function setLocations( node, prop, loc ) {
+    if (!node || typeof node !== 'object')
+      return;
+    const isMember = artifactProperties.includes( prop );
+    if (!isMember && node.$location) {
+      if (typeof node.$location === 'string') // already set for nested 'items'
+        return;
+      loc = locationString( node.$location, true );
+      if (!node.SELECT) // compatibility: $location of query both inside and as sibling of SELECT
+        reveal( node, '$location', debugLocation( loc, !node.$generated ) );
+    }
+    else if (prop === true || prop === 'returns') { // in dictionary or returns
+      loc = debugLocation( loc + '^' );
+      node.$location = loc;
+    }
+    else if (prop === 'items') {
+      let iloc = loc + '[]';
+      let obj = node;
+      while (obj) {
+        // should not appear in --enrich-csn, only for _origin info
+        Object.defineProperty( obj, '$location', { value: iloc, enumerable: false } );
+        obj = obj.items;
+        iloc += '[]';
+      }
+    }
+    if (Array.isArray( node )) {
+      for (const item of node)
+        setLocations( item, isMember, loc );
+    }
+    else {
+      for (const name of Object.getOwnPropertyNames( node ))
+        setLocations( node[name], isMember || name, loc );
+    }
+  }
 }
 
+
 function reveal( node, prop, value ) {
   Object.defineProperty( node, prop, {
     value,
@@ -251,27 +331,4 @@ function reveal( node, prop, value ) {
   } );
 }
 
-function setLocations( node, prop, loc ) {
-  if (!node || typeof node !== 'object')
-    return;
-  const isMember = artifactProperties.includes( prop );
-  if (!isMember && node.$location) {
-    const value = locationString( node.$location, true );
-    reveal( node, '$location', value );
-    loc = value + '-';
-  }
-  else if (prop === true) {
-    loc += '1';
-    node.$location = loc;
-  }
-  if (Array.isArray( node )) {
-    for (const item of node)
-      setLocations( item, isMember, loc );
-  }
-  else {
-    for (const name of Object.getOwnPropertyNames( node ))
-      setLocations( node[name], isMember || name, loc );
-  }
-}
-
 module.exports = enrichCsn;

package/lib/model/revealInternalProperties.js

@@ -50,7 +50,16 @@ function tableAliasAsLink( art, parent, name ) {
       parent === art._parent.$tableAliases[name].$duplicates);
 }
 
-function revealInternalProperties( model, name ) {
+/**
+ * Reveal internal properties of `model` for the given artifact name (or path).
+ * `path` could be a definition name or a `/`-separated XSN path such as
+ * `name.space/S/E/elements/a/type/scope/`.
+ *
+ * @param {XSN.Model} model
+ * @param {string} [nameOrPath]
+ * @returns {string}
+ */
+function revealInternalProperties( model, nameOrPath ) {
   const transformers = {
     messages: m => m,
     name: shortenName,
@@ -76,6 +85,7 @@ function revealInternalProperties( model, name ) {
     $tableAliases: dictionary,
     $duplicates: duplicates,
     $keysNavigation: dictionary,
+    targetAspect,
     $layerNumber: n => n,
     $extra: e => e,
     _layerRepresentative: s => s.realname,
@@ -89,7 +99,7 @@ function revealInternalProperties( model, name ) {
     $messageFunctions: () => '‹some functions›',
   }
   unique_id = 1;
-  return revealXsnPath(name, model);
+  return revealXsnPath(nameOrPath, model);
 
   // Returns the desired artifact/dictionary in the XSN.
   //
@@ -259,6 +269,12 @@ function revealInternalProperties( model, name ) {
     return r;
   }
 
+  function targetAspect( node, parent ) {
+    if (node.elements && unique_id && node.__unique_id__ == null)
+      Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
+    return reveal( node, parent );
+  }
+
   function duplicates( node, parent ) {
     return reveal( node, parent, parent.name && parent.name.id );
   }
@@ -272,10 +288,12 @@ function artifactIdentifier( node, parent ) {
   let outer = unique_id ? '##' + node.__unique_id__ : '';
   if (node._outer) {
     if (node.$inferred === 'REDIRECTED')
-      outer = '/redirected';
+      outer = '/redirected' + outer;
     else
-      outer = (node._outer.items === node) ? '/items'
-            : (node._outer.returns === node) ? '/returns' : '/returns/items';
+      outer = (node._outer.items === node) ? '/items' + outer
+            : (node._outer.returns === node) ? '/returns' + outer
+            : (node._outer.targetAspect === node) ? '/target' + outer
+            : '/returns/items' + outer;
     node = node._outer;
   }
   if (node === parent)
@@ -305,7 +323,10 @@ function artifactIdentifier( node, parent ) {
       return 'source:' + quoted( node.location && node.location.file ) +
         '/using:' + quoted( node.name.id )
     default: {
-      return ((node._main || node).kind || '<kind>') + ':' + msg.artName( node ) + outer;
+      let main = node._main;
+      while (main && main._outer) // anonymous aspect
+        main = main._outer._main;
+      return ((main || node).kind || '<kind>') + ':' + msg.artName( node ) + outer;
     }
   }
 }

package/lib/model/sortViews.js

@@ -1,5 +1,6 @@
 'use strict';
 const {setDependencies} = require('./csnUtils');
+const { ModelError } = require("../base/error");
 
 /**
  * @typedef {Object} Layers
@@ -91,7 +92,7 @@ module.exports = function({sql, csn}){
   const { layers, leftover } = sortTopologically(csn, _dependents, _dependencies);
   cleanup.forEach(fn => fn());
   if(leftover.length > 0)
-    throw new Error('Unable to build a correct dependency graph! Are there cycles?');
+    throw new ModelError('Unable to build a correct dependency graph! Are there cycles?');
 
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting

package/lib/modelCompare/compare.js

@@ -6,13 +6,14 @@ const {
   forEachMember,
   hasAnnotationValue
 } = require('../model/csnUtils');
+const { isBetaEnabled } = require('../base/model');
 
 /**
  * Compares two models, in HANA-transformed CSN format, to each other.
  *
  * @param beforeModel the before-model
  * @param afterModel the after-model
- * @param {import('../api/main.js').hdiOptions|false} options
+ * @param {HdiOptions|false} options
  * @returns {object} the sets of deletions, extensions, and migrations of entities necessary to transform the before-model
  * to the after-model, together with all the definitions of the after-model
  */
@@ -26,8 +27,8 @@ function compareModels(beforeModel, afterModel, options) {
   const migrations = []; // element changes/removals or changes of entity properties
 
   // There is currently no use in knowing the added entities only. If this changes, hand in `addedEntities` to `getArtifactComparator` below.
-  forEachDefinition(afterModel, getArtifactComparator(beforeModel, null, null, elementAdditions, migrations));
-  forEachDefinition(beforeModel, getArtifactComparator(afterModel, null, deletedEntities, null, null));
+  forEachDefinition(afterModel, getArtifactComparator(beforeModel, options, null, null, elementAdditions, migrations));
+  forEachDefinition(beforeModel, getArtifactComparator(afterModel, options, null, deletedEntities, null, null));
 
   const returnObj = Object.create(null);
   returnObj.definitions = afterModel.definitions;
@@ -60,7 +61,7 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
 }
 
-function getArtifactComparator(otherModel, addedEntities, deletedEntities, elementAdditions, migrations) {
+function getArtifactComparator(otherModel, options, addedEntities, deletedEntities, elementAdditions, migrations) {
   return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
@@ -70,7 +71,11 @@ function getArtifactComparator(otherModel, addedEntities, deletedEntities, eleme
       }
     }
     function changePropsOrRemoveOrChangeElements() {
-      const relevantProperties = ['doc'];
+      const relevantProperties = [
+        { name: 'doc' },
+        { name: '@sql.prepend' },
+        { name: '@sql.append' },
+      ];
       const changedProperties = {};
 
       const removedElements = {};
@@ -79,8 +84,8 @@ function getArtifactComparator(otherModel, addedEntities, deletedEntities, eleme
       const migration = { migrate: name };
 
       relevantProperties.forEach(prop => {
-        if (artifact[prop] !== otherArtifact[prop]) {
-          changedProperties[prop] = changedElement(artifact[prop], otherArtifact[prop] || null);
+        if (artifact[prop.name] !== otherArtifact[prop.name] && (!prop.beta || isBetaEnabled(options, prop.beta))) {
+          changedProperties[prop.name] = changedElement(artifact[prop.name], otherArtifact[prop.name] || null);
         }
       });
       if (Object.keys(changedProperties).length > 0) {
@@ -150,7 +155,7 @@ function isPersistedAsTable(artifact) {
       && !hasAnnotationValue(artifact, '@cds.persistence.exists');
 }
 
-function getElementComparator(otherArtifact, addedElements = null, changedElements = null) {
+function getElementComparator(otherArtifact, addedElementsDict = null, changedElementsDict = null) {
   return function compareElements(element, name) {
     if (element._ignore) {
       return;
@@ -159,19 +164,19 @@ function getElementComparator(otherArtifact, addedElements = null, changedElemen
     const otherElement = otherArtifact.elements[name];
     if (otherElement && !otherElement._ignore) {
       // Element type changed?
-      if (!changedElements) {
+      if (!changedElementsDict) {
         return;
       }
       if (relevantTypeChange(element.type, otherElement.type) || typeParametersChanged(element, otherElement)) {
         // Type or parameters, e.g. association target, changed.
-        changedElements[name] = changedElement(element, otherElement);
+        changedElementsDict[name] = changedElement(element, otherElement);
       }
 
       return;
     }
 
-    if (addedElements) {
-      addedElements[name] = element;
+    if (addedElementsDict) {
+      addedElementsDict[name] = element;
     }
   }
 }

package/lib/optionProcessor.js

@@ -30,8 +30,8 @@ optionProcessor
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
   .option('    --assert-integrity <mode>', [ 'true', 'false', 'individual' ])
-  .option('    --assert-integrity-type <type>', [ 'RT', 'DB' ])
-  .option('    --constraints-as-alter <boolean>')
+  .option('    --assert-integrity-type <type>', [ 'RT', 'DB' ], { ignoreCase: true })
+  .option('    --constraints-in-create-table')
   .option('    --deprecated <list>')
   .option('    --hana-flavor')
   .option('    --direct-backend')
@@ -104,7 +104,7 @@ optionProcessor
        --integrity-not-validated         If this option is supplied, referential constraints are NOT VALIDATED.
                                          This option is also applied to result of "cdsc manageConstraints"
        --assert-integrity      <mode>    Turn DB constraints on/off:
-                                           true        : Constraints will be generated for all associations if 
+                                           true        : (default) Constraints will be generated for all associations if
                                                          the assert-integrity-type is set to DB
                                            false       : No constraints will be generated
                                            individual  : Constraints will be generated for selected associations
@@ -112,9 +112,9 @@ optionProcessor
                                            RT : (default) No database constraint for an association
                                                if not explicitly demanded via annotation
                                            DB : Create database constraints for associations
-       --constraints-as-alter <boolean>  If set to 'true', the foreign key constraints will be rendered as 
-                                         "ALTER TABLE ADD CONSTRAINT" statement rather than being part of the
-                                         "CREATE TABLE" statement
+       --constraints-in-create-table   If set, the foreign key constraints will be rendered as
+                                       part of the "CREATE TABLE" statements rather than as separate
+                                       "ALTER TABLE ADD CONSTRAINT" statements
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
                               noElementsExpansion
@@ -124,6 +124,7 @@ optionProcessor
                               renderVirtualElements
                               unmanagedUpInComponent
                               createLocalizedViews
+                              redirectInSubQueries
        --hana-flavor        Compile with backward compatibility for HANA CDS (incomplete)
        --parse-only         Stop compilation after parsing and write result to <stdout>
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this

package/lib/render/DuplicateChecker.js

@@ -62,7 +62,7 @@ class DuplicateChecker {
    * Add an element to the "seen"-list
    *
    * @param {string} name Rendered element name
-   * @param {CSN.Location} location
+   * @param {CSN.Location|CSN.Path} location
    * @param {string} modelName CSN element name
    *
    */

package/lib/render/manageConstraints.js

@@ -5,6 +5,7 @@ const {
   forEachDefinition,
   getResultingName,
 } = require('../model/csnUtils');
+const { forEach } = require('../utils/objectUtils');
 
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -13,7 +14,7 @@ const {
 /**
  * This render middleware can be used to generate SQL DDL ALTER TABLE <table> ALTER / ADD / DROP CONSTRAINT <constraint> statements for a given CDL model.
  * Moreover, it can be used to generate .hdbconstraint artifacts.
- * Depending on the options.manageConstraints provided,the VALIDATED / ENFORCED flag of the constraints can be adjusted.
+ * Depending on the options.manageConstraints provided, the VALIDATED / ENFORCED flag of the constraints can be adjusted.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
@@ -29,25 +30,24 @@ function manageConstraints(csn, options) {
   const { quoteSqlId } = getIdentifierUtils(options);
   forEachDefinition(csn, (artifact) => {
     if (artifact.$tableConstraints && artifact.$tableConstraints.referential) {
-      Object.entries(artifact.$tableConstraints.referential)
-        .forEach(([ fileName, constraint ]) => {
-          const renderAlterConstraintStatement = alter && src !== 'hdi';
-          const renderedConstraint = renderReferentialConstraint(constraint, indent, false, csn, options, renderAlterConstraintStatement);
-          if (src === 'hdi') {
-            resultArtifacts[fileName] = renderedConstraint;
-            return;
-          }
-          let alterTableStatement = '';
-          alterTableStatement += `${indent}ALTER TABLE ${quoteSqlId(getResultingName(csn, options.toSql.names, constraint.dependentTable))}`;
-          if (renderAlterConstraintStatement)
-            alterTableStatement += `\n${indent}ALTER ${renderedConstraint};`;
-          else if (drop)
-            alterTableStatement += `${indent} DROP CONSTRAINT ${quoteSqlId(constraint.identifier)};`;
-          else
-            alterTableStatement += `\n${indent}ADD ${renderedConstraint};`;
-
-          resultArtifacts[fileName] = alterTableStatement;
-        });
+      forEach(artifact.$tableConstraints.referential, (fileName, constraint) => {
+        const renderAlterConstraintStatement = alter && src !== 'hdi';
+        const renderedConstraint = renderReferentialConstraint(constraint, indent, false, csn, options, renderAlterConstraintStatement);
+        if (src === 'hdi') {
+          resultArtifacts[fileName] = renderedConstraint;
+          return;
+        }
+        let alterTableStatement = '';
+        alterTableStatement += `${indent}ALTER TABLE ${quoteSqlId(getResultingName(csn, options.toSql.names, constraint.dependentTable))}`;
+        if (renderAlterConstraintStatement)
+          alterTableStatement += `\n${indent}ALTER ${renderedConstraint};`;
+        else if (drop)
+          alterTableStatement += `${indent} DROP CONSTRAINT ${quoteSqlId(constraint.identifier)};`;
+        else
+          alterTableStatement += `\n${indent}ADD ${renderedConstraint};`;
+
+        resultArtifacts[fileName] = alterTableStatement;
+      });
     }
   });
   return resultArtifacts;
@@ -65,25 +65,29 @@ function listReferentialIntegrityViolations(csn, options) {
   const referentialConstraints = getListOfAllConstraints(csn);
   const resultArtifacts = {};
   const indent = '    ';
-  const increaseIndent = indent => `${indent}    `;
+  const increaseIndent = str => `    ${str}`;
   // helper function to reduce parent key / foreign key array to a comma separated string which can be used in a select clause
   const keyStringReducer = prefix => (prev, curr, index) => (index > 0 ? `${prev},\n${curr} AS "${prefix}:${curr}"` : prev);
   // helper function to reduce the parent key / foreign key arrays of a referential constraint to a join list which can be used in a where clause
   const joinPkWithFkReducer = (constraint, subQueryAlias, mainQueryAlias) => (prev, curr, index) => (index > 0
     ? `${prev} AND
-    ${increaseIndent(indent)}${mainQueryAlias}.${quoteSqlId(constraint.foreignKey[index])} = ${subQueryAlias}.${quoteSqlId(constraint.parentKey[index])}`
+    ${increaseIndent(indent)}"${mainQueryAlias}".${quoteSqlId(constraint.foreignKey[index])} = ${subQueryAlias}.${quoteSqlId(constraint.parentKey[index])}`
     : increaseIndent(increaseIndent(indent)) + prev);
 
-  Object.entries(referentialConstraints).forEach(([ identifier, constraint ]) => {
+  Object.entries(referentialConstraints).forEach(([ identifier, constraint ], index) => {
     let selectViolations = 'SELECT\n';
+    // this column indicates which SELECT revealed the integrity violation
+    // and helps to identify the corrupted table
+    selectViolations += `${index} as "SELECT-ID",\n`;
     // SELECT <primary_key>,
     const primaryKeyList = selectPrimaryKeyColumns(constraint);
     if (primaryKeyList)
       selectViolations += `${primaryKeyList},\n`;
     // ... <foreign_key>
     selectViolations += selectForeignKeyColumns(constraint);
-    // ... FROM <dependent table> AS "MAIN"
-    selectViolations += `\nFROM ${quoteAndGetResultingName(constraint.dependentTable)} AS "MAIN"\n`;
+    const mainQueryAlias = `MAIN_${index}`;
+    // ... FROM <dependent table> AS "${index}"
+    selectViolations += `\nFROM ${quoteAndGetResultingName(constraint.dependentTable)} AS "${mainQueryAlias}"\n`;
     // ... WHERE NOT (<(part of) foreign key is null>)
     selectViolations += whereNotForeignKeyIsNull(constraint);
     /*
@@ -91,7 +95,7 @@ function listReferentialIntegrityViolations(csn, options) {
             SELECT * FROM <parent_table> WHERE <dependent_table>.<foreign_key> = <parent_table>.<parent_key>
         )
     */
-    selectViolations += andNoMatchingPrimaryKeyExists(constraint);
+    selectViolations += andNoMatchingPrimaryKeyExists(constraint, mainQueryAlias);
     resultArtifacts[identifier] = selectViolations;
   });
 
@@ -147,21 +151,21 @@ function listReferentialIntegrityViolations(csn, options) {
    * Generate SQL sub-SELECT, listing all rows of the parent table where no matching primary key column for the respective foreign key is found.
    *
    * @param {CSN.ReferentialConstraint} constraint
+   * @param {string} mainQueryAlias
    * @returns AND NOT EXISTS ( SELECT * FROM <parent_table> WHERE <dependent_table>.<foreign_key> = <parent_table>.<parent_key> ) statement
    */
-  function andNoMatchingPrimaryKeyExists(constraint) {
+  function andNoMatchingPrimaryKeyExists(constraint, mainQueryAlias) {
     let andNotExists = `\n${indent}AND NOT EXISTS (\n`;
     andNotExists += `${increaseIndent(indent)}SELECT * FROM ${quoteAndGetResultingName(constraint.parentTable)}`;
     // add an alias to both queries so that they can be distinguished at all times
     const subQueryAlias = '"SUB"';
-    const mainQueryAlias = '"MAIN"';
     andNotExists += ` AS ${subQueryAlias}`;
     andNotExists += '\n';
     const joinListReducer = joinPkWithFkReducer(constraint, subQueryAlias, mainQueryAlias);
     andNotExists += `${increaseIndent(indent)}WHERE (\n`;
     andNotExists += constraint.foreignKey
       .reduce(joinListReducer,
-              `${mainQueryAlias}.${quoteSqlId(constraint.foreignKey[0])} = ${subQueryAlias}.${quoteSqlId(constraint.parentKey[0])}`);
+              `"${mainQueryAlias}".${quoteSqlId(constraint.foreignKey[0])} = ${subQueryAlias}.${quoteSqlId(constraint.parentKey[0])}`);
     andNotExists += `\n${increaseIndent(indent)})`;
     andNotExists += `\n${indent});`;
     return andNotExists;
@@ -179,10 +183,9 @@ function getListOfAllConstraints(csn) {
   const referentialConstraints = {};
   forEachDefinition(csn, (artifact) => {
     if (artifact.$tableConstraints && artifact.$tableConstraints.referential) {
-      Object.entries(artifact.$tableConstraints.referential)
-        .forEach(([ identifier, referentialConstraint ]) => {
-          referentialConstraints[identifier] = referentialConstraint;
-        });
+      forEach(artifact.$tableConstraints.referential, (identifier, referentialConstraint) => {
+        referentialConstraints[identifier] = referentialConstraint;
+      });
     }
   });
   return referentialConstraints;