@sap/cds-compiler 5.9.2 → 6.0.10

package/lib/model/xprAsTree.js

@@ -7,19 +7,26 @@
 //
 // Function/assoc arguments and filter conditions are
 //  - traversed with expressionAsTree() and conditionAsTree(),
-//  - not traversed with exprAsTree() and condAsTree()
+//  - not traversed with exprAsTree() and condAsTree(), you might need to call
+//    splitClauses() to cover `order by` in the last function argument
 
 'use strict';
 
-const xprParser = require( '../parsers/XprTree' );
+const { csnAsTree, splitClauses } = require( '../parsers/XprTree' );
 
 function conditionAsTree( args ) {
   args.forEach( expressionAsTree );
-  return xprParser.xprAsTree( args, args, true );
+  return asTree( args );
 }
 function condAsTree( args ) {
   args.forEach( exprAsTree );
-  return xprParser.xprAsTree( args, args, true );
+  return asTree( args );
+}
+
+function asTree( args ) {
+  return (args.length === 2 && args[0] === 'over' && args[1]?.xpr && !args[1].func)
+    ? [ 'over', { xpr: splitClauses( args[1].xpr, true ) } ]
+    : csnAsTree( args );
 }
 
 function expressionAsTree( expr ) {
@@ -31,11 +38,17 @@ function expressionAsTree( expr ) {
   }
   if (expr.list)                // expression, ref
     expr.list.forEach( expressionAsTree );
-  if (expr.args) {               // expression, ref
-    if (Array.isArray( expr.args ) )
-      expr.args.forEach(expressionAsTree);
-    else
-      Object.values(expr.args).forEach(expressionAsTree);
+  const { args } = expr;
+  if (args) {               // expression, ref
+    if (!Array.isArray( args )) {
+      Object.values( args ).forEach( expressionAsTree );
+    }
+    else if (args.length) {
+      args.forEach( expressionAsTree );
+      const last = args.at( -1 );
+      if (last?.xpr && last.xpr.length > 4) // order by in last argument
+        last.xpr = splitClauses( last.xpr, true );
+    }
   }
   if (expr.ref)                 // expression
     expr.ref.forEach( expressionAsTree );
@@ -68,4 +81,5 @@ module.exports = {
   condAsTree,
   expressionAsTree,
   exprAsTree,
+  splitClauses: nodes => splitClauses( nodes, true ),
 };

package/lib/modelCompare/compare.js

@@ -57,20 +57,21 @@ function validateCsnVersions(beforeModel, afterModel, options) {
 
   if (!beforeVersionParts || beforeVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(beforeModel, options, 'modelCompare');
-    error(null, null, { version: beforeVersion || 'undefined' }, 'Invalid CSN version: $(VERSION)');
+    error('api-invalid-version', null, { version: beforeVersion || 'unknown' });
     throwWithAnyError();
   }
   if (!afterVersionParts || afterVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, { version: afterVersion || 'undefined' }, 'Invalid CSN version: $(VERSION)');
+    error('api-invalid-version', null, { version: afterVersion || 'unknown' });
     throwWithAnyError();
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
 
     const { version } = require('../../package.json');
-    error(null, null, { value: afterVersion, othervalue: beforeVersion, version },
-          'Incompatible CSN versions: $(VALUE) is a major downgrade from $(OTHERVALUE). Is @sap/cds-compiler version $(VERSION) outdated?');
+    error('api-invalid-version', null, {
+      '#': 'migrationComparison', value: afterVersion, othervalue: beforeVersion, version,
+    });
     throwWithAnyError();
   }
 }

package/lib/optionProcessor.js

@@ -18,7 +18,6 @@ const { availableBetaFlags } = require('./base/model');
 const optionProcessor = createOptionProcessor();
 
 // General options
-// FIXME: Since they mainly affect the compiler, they could also live near main.compile
 optionProcessor
   .option('-h, --help')
   .option('-v, --version')
@@ -40,7 +39,6 @@ optionProcessor
   .option('    --debug <id-list>')
   .option('-E, --enrich-csn')
   .option('-R, --raw-output <name>')
-  .option('    --new-parser')
   .option('    --internal-msg')
   .option('    --beta-mode')
   .option('    --beta <list>')
@@ -51,6 +49,7 @@ optionProcessor
   .option('    --test-mode')
   .option('    --test-sort-csn')
   .option('    --doc-comment')
+  .option('    --propagate-doc-comments')
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --tenant-discriminator')
@@ -119,7 +118,6 @@ optionProcessor
                             with name = "+", write complete XSN, long!
        --tenant-discriminator  Add tenant fields to entities
        --internal-msg       Write raw messages with call stack to <stdout>/<stderr>
-       --new-parser         Use the new CDL parser
        --beta-mode          Enable all unsupported, incomplete (beta) features
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
@@ -130,8 +128,6 @@ optionProcessor
                                   .join(`\n${ ' '.repeat(30) }`)
                               }
        --deprecated <list>  Comma separated list of deprecated options.
-                            Valid values are:
-                              eagerPersistenceForGeneratedEntities
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this
                                  parser as a fallback. Valid values are:
                                    cdl   : Use CDL parser
@@ -153,6 +149,7 @@ optionProcessor
                             OData CSN, CDL order and more.  When --test-mode is enabled, this
                             option is implicitly enabled as well.
        --doc-comment        Preserve /** */ comments at annotation positions as doc property in CSN
+       --propagate-doc-comments     Propagate doc comments ('--doc-comment')
        --add-texts-language-assoc   In generated texts entities, add association "language"
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
@@ -163,7 +160,7 @@ optionProcessor
        --skip-name-check    Skip certain name checks, e.g. that there must be no '.' in element names.
 
   Commands
-    H, toHana [options] <files...>              Generate HANA CDS source files
+    H, toHana [options] <files...>              (deprecated) Generate HANA CDS source files
     O, toOdata [options] <files...>             Generate ODATA metadata and annotations
     C, toCdl <files...>                         Generate CDS source files
     Q, toSql [options] <files...>               Generate SQL DDL statements
@@ -204,10 +201,14 @@ optionProcessor.command('H, toHana')
   .option('    --assert-integrity-type <type>', { valid: [ 'RT', 'DB' ], ignoreCase: true })
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
-  .option('    --standard-database-functions')
+  .option('    --no-standard-database-functions')
   .help(`
   Usage: cdsc toHana [options] <files...>
 
+  ====================================================
+  DEPRECATED! Since v5, this backend is deprecated!
+  ====================================================
+
   Generate HANA CDS source files, or CSN.
 
   Options
@@ -241,7 +242,7 @@ optionProcessor.command('H, toHana')
                                            DB : Create database constraints for associations
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
-   --standard-database-functions Enable rendering of standard database function mappings.
+   --no-standard-database-functions Disable rendering of standard database function mappings.
 `);
 
 optionProcessor.command('O, toOdata')
@@ -294,7 +295,7 @@ optionProcessor.command('O, toOdata')
                                    { prefix: { alias, ns, uri }, ... }
        --odata-no-creator          Omit creator identification in API
    -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
-                             the corresponding database name (see "--sql-mapping" for "toHana or "toSql")
+                             the corresponding database name (see "--sql-mapping" for "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores
                                quoted  : Names in original case as in CDL. Entity names with dots,
                                          but element names flattened with underscores
@@ -319,8 +320,8 @@ optionProcessor.command('J, forJava')
 
 optionProcessor.command('C, toCdl')
   .option('-h, --help')
-  .option('    --render-cdl-definition-nesting')
-  .option('    --render-cdl-common-namespace')
+  .option('    --no-render-cdl-definition-nesting')
+  .option('    --no-render-cdl-common-namespace')
   .help(`
   Usage: cdsc toCdl [options] <files...>
 
@@ -328,10 +329,10 @@ optionProcessor.command('C, toCdl')
 
   Options
    -h, --help      Show this help text
-       --render-cdl-definition-nesting   If set, definitions will be nested
+       --no-render-cdl-definition-nesting   If set, definitions will be nested
                    inside services/contexts instead of having only top-level
                    definitions.
-       --render-cdl-common-namespace  If true and render-cdl-definition-nesting
+       --no-render-cdl-common-namespace  If true and render-cdl-definition-nesting
                    is set, a common namespace will be extracted and rendered.
 `);
 
@@ -355,9 +356,10 @@ optionProcessor.command('Q, toSql')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables <bool>')
   .option('    --transitive-localized-views')
-  .option('    --boolean-equality')
+  .option('    --no-boolean-equality')
   .option('    --with-hana-associations <bool>', { valid: [ 'true', 'false' ] })
-  .option('    --standard-database-functions')
+  .option('    --no-standard-database-functions')
+  .option('    --dollar-now-as-timestamp')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -420,8 +422,10 @@ optionProcessor.command('Q, toSql')
                               Enable or disable rendering of "WITH ASSOCIATIONS" for sqlDialect 'hana'.
                                 true  : (default) Render "WITH ASSOCIATIONS"
                                 false : Do not render "WITH ASSOCIATIONS"
-   --standard-database-functions Enable rendering of standard database function mappings.
-   --boolean-equality            Enable support for boolean logic '!=' operator.
+   --no-standard-database-functions Disable rendering of standard database function mappings.
+   --no-boolean-equality      Enable support for boolean logic '!=' operator.
+   --dollar-now-as-timestamp  Render '$now' variable as 'CURRENT_TIMESTAMP' instead of 'SESSION_CONTEXT(…)'
+                              for SQL dialect 'hana'.
 `);
 
 optionProcessor.command('toRename')

package/lib/parsers/AstBuildingParser.js

@@ -44,7 +44,6 @@ const extensionsCode = {
   service: 'extend service',
 };
 
-const PRECEDENCE_OF_IN_PREDICATE = 10;
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
@@ -177,8 +176,6 @@ class AstBuildingParser extends BaseParser {
     const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
     const generic = this.dynamic_.generic?.[text];
     if (tryGenericIntro) {
-      if (this.dynamic_.generic?.IN === 'separator')
-        this.prec_ = PRECEDENCE_OF_IN_PREDICATE; // only expressions if `in` is separator
       if (generic !== 'expr')
         return (generic === 'intro') ? 'GenericIntro' : type;
       // if both intro and expr: specialFunctions[fn][argPos][token] = 'expr'
@@ -268,6 +265,15 @@ class AstBuildingParser extends BaseParser {
       this.precNone_( _test, prec );
   }
 
+  // TODO: as leanCondition ?  `order` should probably appear in the message for
+  // test3/Compiler/GrammarRobustness/InvalidSelectInWhere.err.cds
+  orderByLimitRestriction( mode ) {
+    if (mode && (!this.$allowOrderByLimit || this.precPost_( mode, 0 )))
+      return true;
+    this.$allowOrderByLimit = !mode;
+    return false;
+  }
+
   isNamedArg() {
     const type = this.tokens[this.tokenIdx + 1]?.type;
     return type !== ':' && type !== '=>';
@@ -569,13 +575,27 @@ class AstBuildingParser extends BaseParser {
 
   noAssignmentInSameLine() {
     const next = this.la();
-    if (next.text === '@' && next.line <= this.lb().endLine) {
+    if (next.text === '@' && next.location.line <= this.lb().location.endLine &&
+        // TODO Tool Runtime: it is probably better to skip tokens directly
+        // do not report error if the '@' is not correct:
+        this.s !== null && this.tokenIdx > this.recoverTokenIdx) {
       this.warning( 'syntax-missing-semicolon', next, { code: ';' },
                     // eslint-disable-next-line @stylistic/js/max-len
                     'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
     }
   }
 
+  reportDubiousAnnoSpacing() {
+    const at = this.lb();
+    const before = this.tokens[this.tokenIdx - 2];
+    if (before?.type === 'Id' && before.location.endLine === at.location.line &&
+        before.location.endCol === at.location.col) {
+      this.warning( 'syntax-expecting-anno-space', at.location, { code: '@' },
+                    'Expecting a space before the $(CODE) starting an annotation assignment' );
+    }
+    this.reportUnexpectedSpace( at );
+  }
+
   // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths,
   // inside `.*` and `.{`
   reportUnexpectedSpace( prefix = this.lb(),
@@ -749,8 +769,23 @@ class AstBuildingParser extends BaseParser {
     return ast;
   }
 
+  virtualOrImplicit( art ) {
+    const token = this.lb();
+    const ref = art.value.func || art.value;
+    if (!art.virtual ||
+        ref.path[0].location.tokenIndex < token.location.tokenIndex ||
+        this.la().text === '{') {
+      this.classifyImplicitName( 'ItemImplicit', ref );
+    }
+    else {
+      token.parsedAs = 'ItemAlias';
+      art.name = ref.path[0];
+      art.value = undefined;
+    }
+  }
+
   classifyImplicitName( category, ref ) {
-    if (!ref || ref.path) {
+    if (!ref || ref.path) {     // TODO: func
       const tokenIndex = ref?.path.at(-1)?.location.tokenIndex;
       const token = this.prevTokenWithIndex( tokenIndex ) ?? this.tokens[this.tokenIdx - 1];
       const { parsedAs } = token;
@@ -1043,10 +1078,8 @@ class AstBuildingParser extends BaseParser {
       line: chosen.location.line,
       col: chosen.location.col,
     };
-    if (erroneous.val === chosen.val) {
-      // TODO v6: duplicate clause = error, independently whether it is the same
-      this.warning( 'syntax-duplicate-equal-clause', erroneous.location, args );
-    }
+    if (erroneous.val === chosen.val)
+      this.message( 'syntax-duplicate-equal-clause', erroneous.location, args );
     // TODO extra msg text 'syntax-duplicate-clause' for noRepeatedCardinality()
   }
 
@@ -1169,6 +1202,21 @@ class AstBuildingParser extends BaseParser {
     };
   }
 
+  valuePathAstWithNew( expr, path ) {
+    path = this.valuePathAst( path );
+    if (path.op?.val !== 'ixpr') {
+      expr.args.push( path );
+    }
+    else {
+      const ref = path.args[0];
+      const op = { val: 'ixpr', location: expr.args[0].location };
+      const location = this.combineLocation( expr.args[0], ref );
+      path.args[0] = { op, args: [ expr.args[0], ref ], location };
+      expr.args = path.args;
+    }
+    this.attachLocation( expr );
+  }
+
   valuePathAst( ref ) {
     // TODO: XSN representation of functions is a bit strange - rework
     // TODO: rework this function
@@ -1189,8 +1237,12 @@ class AstBuildingParser extends BaseParser {
       if (filter) // TODO v7: make this be reported via guard, as error
         this.message( 'syntax-unexpected-filter', filter.location, {} );
       // TODO: XSN representation of functions is a bit strange - rework
-      const op = { location, val: 'call' };
-      return this.attachLocation( { op, func: ref, args } );
+      return this.attachLocation( {
+        op: { location, val: 'call' },
+        func: ref,
+        args,
+        location: ref.location,
+      } );
     }
 
     // $syntax === ':' => path(P: 1)

package/lib/parsers/XprTree.js

@@ -9,7 +9,7 @@
 
 const prefixOperators = {     // see <prec=…,prefix> in `expression` of CdlGrammar
   __proto__: null,
-  new: 33,                  // special in CDL (only before ref), clarify with `.`
+  new: 39,                  // special in CDL (only before ref)
   exists: 33,               // special in CDL
   '+': 30,                  // note: binary `.` and `over` have higher precedence!
   '-': 30,
@@ -85,10 +85,54 @@ class XprTree {
     this.location = location;
   }
 
+  splitClauses() {
+    const { length } = this.args;
+    if (length < 3)
+      return this.args;
+    const args = [];
+    let idx = 0;
+    while (idx < length) {
+      if (this.isToken( idx + 1, 'by' ) &&
+          this.isToken( idx, 'partition' ) || this.isToken( idx, 'order' )) {
+        this.pushSection( args, idx );
+        args.push( this.args[idx++] );
+        args.push( this.args[idx++] );
+        this.nodeIdx = idx;
+      }
+      else if (this.isToken( idx, 'rows' )) {
+        this.pushSection( args, idx );
+        args.push( this.args[idx++] );
+        this.nodeIdx = idx;
+      }
+      else {
+        ++idx;
+      }
+    }
+    if (!args.length)
+      return this.args;
+    this.pushSection( args, idx );
+    return args;
+  }
+
+  isToken( idx, keyword ) {
+    const tok = this.args[idx];
+    return tok && (this.location === true)
+      ? keyword === tok
+      : keyword === tok?.val && tok.literal === 'token';
+  }
+
+  pushSection( args, idx ) {
+    if (idx > this.nodeIdx) {
+      args.push( (idx > this.nodeIdx + 1)
+        ? this.create( this.args.slice( this.nodeIdx, idx ) )
+        : this.args[this.nodeIdx] );
+      this.nodeIdx = idx;
+    }
+  }
+
   tree() {
     const args = [];
     const { length } = this.args;
-    // TODO: orderByClauseAsXpr, overClause
     while (this.nodeIdx < length) {
       const expr = this.expression( -1 );
       if (expr)
@@ -210,6 +254,16 @@ class XprTree {
   }
 }
 
+function xprAsTree( nodes, args, location ) {
+  return (new XprTree( nodes, args, location )).tree();
+}
+
+function splitClauses( tree, isCsn ) {
+  return (new XprTree( null, tree, !!isCsn || tree.location )).splitClauses();
+}
+
 module.exports = {
-  xprAsTree: ( nodes, args, location ) => (new XprTree( nodes, args, location )).tree(),
+  xsnAsTree: xprAsTree,
+  csnAsTree: nodes => xprAsTree( nodes, nodes, true ),
+  splitClauses,
 };

package/lib/parsers/identifiers.js

@@ -14,7 +14,7 @@ const functionsWithoutParentheses = [
 ];
 
 // CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
-// Keep in sync with reserved keywords in language.g4
+// TODO: Use `parser.keywords` from our generated CdlParser.js (#13856)
 const cdlKeywords = [
   'ALL',
   'ANY',

package/lib/parsers/index.js

@@ -7,7 +7,6 @@ const { CompilerAssertion } = require( '../base/error' );
 const { createMessageFunctions } = require( '../base/messages' );
 const { XsnSource } = require('../compiler/xsn-model');
 
-const parseWithAntlr = lazyload('../language/antlrParser');
 const CdlLexer = require( './Lexer' );
 const gen = lazyload( '../gen/CdlParser' );
 
@@ -21,8 +20,6 @@ function parseCdl( source, filename = '<undefined>.cds',
                    options = {}, messageFunctions = null,
                    rule = 'cdl' ) {
   const rulespec = rules[rule];
-  if (!options.newParser && !options.newparser)
-    return parseWithAntlr( source, filename, options, messageFunctions, rulespec );
   const { CdlParser } = gen;
   if (CdlParser.tracingParser)  // tracing → direct console output of message
     messageFunctions = createMessageFunctions( {}, 'parse', {} );

package/lib/render/manageConstraints.js

@@ -100,13 +100,13 @@ function manageConstraint( constraint, csn, options, indent, quoteSqlId ) {
   if (options.src === 'hdi' && !options.drop)
     return renderedConstraint;
   let alterTableStatement = '';
-  alterTableStatement += `${indent}ALTER TABLE ${quoteSqlId(getResultingName(csn, options.sqlMapping, constraint.dependentTable))}`;
+  alterTableStatement += `${ indent }ALTER TABLE ${ quoteSqlId(getResultingName(csn, options.sqlMapping, constraint.dependentTable)) }`;
   if (renderAlterConstraintStatement)
-    alterTableStatement += `\n${indent}ALTER ${renderedConstraint};`;
+    alterTableStatement += `\n${ indent }ALTER ${ renderedConstraint };`;
   else if (options.drop)
-    alterTableStatement += `${indent} DROP CONSTRAINT ${quoteSqlId(constraint.identifier)};`;
+    alterTableStatement += `${ indent } DROP CONSTRAINT ${ quoteSqlId(constraint.identifier) };`;
   else
-    alterTableStatement += `\n${indent}ADD ${renderedConstraint};`;
+    alterTableStatement += `\n${ indent }ADD ${ renderedConstraint };`;
 
   return alterTableStatement;
 }
@@ -123,29 +123,29 @@ function listReferentialIntegrityViolations( csn, options ) {
   const referentialConstraints = getListOfAllConstraints(csn);
   const resultArtifacts = {};
   const indent = '    ';
-  const increaseIndent = str => `    ${str}`;
+  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);
+  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])}`
+    ? `${ prev } AND
+    ${ increaseIndent(indent) }"${ mainQueryAlias }".${ quoteSqlId(constraint.foreignKey[index]) } = ${ subQueryAlias }.${ quoteSqlId(constraint.parentKey[index]) }`
     : increaseIndent(increaseIndent(indent)) + prev);
 
   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`;
+    selectViolations += `${ index } as "SELECT-ID",\n`;
     // SELECT <primary_key>,
     const primaryKeyList = selectPrimaryKeyColumns(constraint);
     if (primaryKeyList)
-      selectViolations += `${primaryKeyList},\n`;
+      selectViolations += `${ primaryKeyList },\n`;
     // ... <foreign_key>
     selectViolations += selectForeignKeyColumns(constraint);
-    const mainQueryAlias = `MAIN_${index}`;
+    const mainQueryAlias = `MAIN_${ index }`;
     // ... FROM <dependent table> AS "${index}"
-    selectViolations += `\nFROM ${quoteAndGetResultingName(constraint.dependentTable)} AS "${mainQueryAlias}"\n`;
+    selectViolations += `\nFROM ${ quoteAndGetResultingName(constraint.dependentTable) } AS "${ mainQueryAlias }"\n`;
     // ... WHERE NOT (<(part of) foreign key is null>)
     selectViolations += whereNotForeignKeyIsNull(constraint);
     /*
@@ -173,7 +173,7 @@ function listReferentialIntegrityViolations( csn, options ) {
     // if no primary key is set in the table
     if (primaryKeyOfDependentTable.length === 0)
       return '';
-    return primaryKeyOfDependentTable.reduce(pkReducer, `${quoteSqlId(primaryKeyOfDependentTable[0])} AS "K:${primaryKeyOfDependentTable[0]}"`);
+    return primaryKeyOfDependentTable.reduce(pkReducer, `${ quoteSqlId(primaryKeyOfDependentTable[0]) } AS "K:${ primaryKeyOfDependentTable[0] }"`);
   }
 
   /**
@@ -184,7 +184,7 @@ function listReferentialIntegrityViolations( csn, options ) {
    */
   function selectForeignKeyColumns( constraint ) {
     const fkReducer = keyStringReducer('FK');
-    return constraint.foreignKey.reduce(fkReducer, `${quoteSqlId(constraint.foreignKey[0])} AS "FK:${constraint.foreignKey[0]}"`);
+    return constraint.foreignKey.reduce(fkReducer, `${ quoteSqlId(constraint.foreignKey[0]) } AS "FK:${ constraint.foreignKey[0] }"`);
   }
 
   /**
@@ -194,14 +194,14 @@ function listReferentialIntegrityViolations( csn, options ) {
    * @returns WHERE NOT ( <foreign_key IS NULL ... ) statement
    */
   function whereNotForeignKeyIsNull( constraint ) {
-    let whereNot = `${indent}WHERE NOT (\n`;
+    let whereNot = `${ indent }WHERE NOT (\n`;
     whereNot += constraint.foreignKey
       .reduce((prev, curr, index) => {
         if (index > 0)
-          return `${prev} OR \n${increaseIndent(indent)}${quoteSqlId(curr)} IS NULL`;
+          return `${ prev } OR \n${ increaseIndent(indent) }${ quoteSqlId(curr) } IS NULL`;
         return increaseIndent(indent) + prev;
-      }, `${quoteSqlId(constraint.foreignKey[0])} IS NULL`);
-    whereNot += `\n${indent})`;
+      }, `${ quoteSqlId(constraint.foreignKey[0]) } IS NULL`);
+    whereNot += `\n${ indent })`;
     return whereNot;
   }
 
@@ -213,19 +213,19 @@ function listReferentialIntegrityViolations( csn, options ) {
    * @returns AND NOT EXISTS ( SELECT * FROM <parent_table> WHERE <dependent_table>.<foreign_key> = <parent_table>.<parent_key> ) statement
    */
   function andNoMatchingPrimaryKeyExists( constraint, mainQueryAlias ) {
-    let andNotExists = `\n${indent}AND NOT EXISTS (\n`;
-    andNotExists += `${increaseIndent(indent)}SELECT * FROM ${quoteAndGetResultingName(constraint.parentTable)}`;
+    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"';
-    andNotExists += ` AS ${subQueryAlias}`;
+    andNotExists += ` AS ${ subQueryAlias }`;
     andNotExists += '\n';
     const joinListReducer = joinPkWithFkReducer(constraint, subQueryAlias, mainQueryAlias);
-    andNotExists += `${increaseIndent(indent)}WHERE (\n`;
+    andNotExists += `${ increaseIndent(indent) }WHERE (\n`;
     andNotExists += constraint.foreignKey
       .reduce(joinListReducer,
-              `"${mainQueryAlias}".${quoteSqlId(constraint.foreignKey[0])} = ${subQueryAlias}.${quoteSqlId(constraint.parentKey[0])}`);
-    andNotExists += `\n${increaseIndent(indent)})`;
-    andNotExists += `\n${indent});`;
+              `"${ mainQueryAlias }".${ quoteSqlId(constraint.foreignKey[0]) } = ${ subQueryAlias }.${ quoteSqlId(constraint.parentKey[0]) }`);
+    andNotExists += `\n${ increaseIndent(indent) })`;
+    andNotExists += `\n${ indent });`;
     return andNotExists;
   }