@sap/cds-compiler 5.9.4 → 6.0.12

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;
   }