commit

ready for tests to pass after regenerating changed asts

Author: jitsedesmet

packages/algebra-transformer-1-1/lib/algebraToAst/sparql.ts

@@ -56,6 +56,9 @@ import type {
   Term,
   Sparql11Nodes,
   Quads,
+
+  DatasetClauses,
+  PatternFilter,
 } from '@traqula/rules-sparql-1-1';
 import { isomorphic } from 'rdf-isomorphic';
 import * as Algebra from '../algebra';
@@ -258,7 +261,7 @@ class Translator {
     return this.astFactory.wildcard(this.astFactory.gen());
   }
 
-  private arrayToPattern(input: Pattern[]): Pattern {
+  private arrayToPattern(input: Pattern[]): PatternGroup {
     if (!Array.isArray(input)) {
       return this.astFactory.patternGroup([ input ], this.astFactory.gen());
     }
@@ -314,6 +317,14 @@ class Translator {
     ]);
   }
 
+  private translateDatasetClauses(_default: RDF.NamedNode[], named: RDF.NamedNode[]): DatasetClauses {
+    const F = this.astFactory;
+    return F.datasetClauses([
+      ..._default.map(x => (<const>{ clauseType: 'default', value: this.translateTerm(x) })),
+      ...named.map(x => (<const>{ clauseType: 'named', value: this.translateTerm(x) })),
+    ], F.gen());
+  }
+
   /**
    * Input of from is for example a project
    */
@@ -326,10 +337,7 @@ class Translator {
     } else {
       query = result;
     }
-    query.datasets = F.datasetClauses([
-      ...op.default.map(x => (<const>{ clauseType: 'default', value: this.translateTerm(x) })),
-      ...op.named.map(x => (<const>{ clauseType: 'named', value: this.translateTerm(x) })),
-    ], F.gen());
+    query.datasets = this.translateDatasetClauses(op.default, op.named);
     return <PatternGroup> result;
   }
 
@@ -395,6 +403,7 @@ class Translator {
   }
 
   private translateMinus(op: Algebra.Minus): Pattern[] {
+    const F = this.astFactory;
     let patterns = this.translateOperation(op.input[1]);
     if (patterns.type === 'group') {
       patterns = patterns.patterns;
@@ -404,10 +413,7 @@ class Translator {
     }
     return Util.flatten([
       this.translateOperation(op.input[0]),
-      {
-        type: 'minus',
-        patterns,
-      },
+      F.patternMinus(patterns, F.gen()),
     ]);
   }
 
@@ -578,15 +584,14 @@ class Translator {
     // Convert filter to 'having' if it contains an aggregator variable
     // could always convert, but is nicer to use filter when possible
     if (result.where && F.isPatternFilter(result.where.patterns.at(-1) ?? {})) {
-      // TODO: jitsy: inspect closer
-      // const filter = <PatternFilter> result.where.patterns.at(-1);
-      // if (this.objectContainsValues(filter, Object.keys(aggregators))) {
-      //   select.solutionModifiers.having = F.solutionModifierHaving(
-      //     Util.flatten([ this.replaceAggregatorVariables((<any> filter).expression, aggregators) ]),
-      //     F.gen(),
-      //   );
-      //   result.where.patterns.splice(-1);
-      // }
+      const filter = <PatternFilter> result.where.patterns.at(-1);
+      if (this.objectContainsVariable(filter, Object.keys(aggregators))) {
+        select.solutionModifiers.having = F.solutionModifierHaving(
+          Util.flatten([ this.replaceAggregatorVariables(filter.expression, aggregators) ]),
+          F.gen(),
+        );
+        result.where.patterns.splice(-1);
+      }
     }
 
     this.extend = extend;
@@ -598,6 +603,21 @@ class Translator {
     return F.patternGroup([ select ], F.gen());
   }
 
+  private objectContainsVariable(o: any, vals: string[]): boolean {
+    const F = this.astFactory;
+    const casted = <Sparql11Nodes> o;
+    if (F.isTermVariable(casted)) {
+      return vals.includes(casted.value);
+    }
+    if (Array.isArray(o)) {
+      return o.some(e => this.objectContainsVariable(e, vals));
+    }
+    if (o === Object(o)) {
+      return Object.keys(o).some(key => this.objectContainsVariable(o[key], vals));
+    }
+    return false;
+  }
+
   private translateReduced(op: Algebra.Reduced): Pattern {
     const result = this.translateOperation(op.input);
     // Project is nested in group object
@@ -646,7 +666,7 @@ class Translator {
 
   private translateUnion(op: Algebra.Union): PatternUnion {
     return this.astFactory.patternUnion(
-      <PatternGroup[]> op.input.map(x => this.translateOperation(x)).map(x => this.arrayToPattern(x)),
+      op.input.map(x => this.translateOperation(x)).map(x => this.arrayToPattern(x)),
       this.astFactory.gen(),
     );
   }
@@ -768,33 +788,26 @@ F.gen(),
     if (where && where.type === types.FROM) {
       const from = where;
       where = from.input;
-      use = { default: from.default, named: from.named };
+      use = this.translateDatasetClauses(from.default, from.named);
     }
 
     const updates = <[UpdateOperationModify & { where?: unknown; delete?: unknown; insert?: unknown }]> [{
       type: 'updateOperation',
       subType: 'modify',
       delete: this.convertUpdatePatterns(op.delete ?? []),
       insert: this.convertUpdatePatterns(op.insert ?? []),
-      from: F.datasetClauses([], F.gen()),
+      where: F.patternGroup([], F.gen()),
+      from: use ?? F.datasetClauses([], F.gen()),
       loc: F.gen(),
     }];
-    // Typings don't support 'using' yet
-    if (use) {
-      (<any> updates[0]).from = use;
-    }
 
     // Corresponds to empty array in SPARQL.js
     if (!where || (where.type === types.BGP && where.patterns.length === 0)) {
-      updates[0].where = [];
+      updates[0].where = F.patternGroup([], F.gen());
     } else {
       const graphs: RDF.NamedNode[] = [];
-      const result = this.translateOperation(this.removeQuadsRecursive(where, graphs));
-      if (result.type === 'group') {
-        updates[0].where = result.patterns;
-      } else {
-        updates[0].where = [ result ];
-      }
+      const result = <Pattern[]> this.translateOperation(this.removeQuadsRecursive(where, graphs));
+      updates[0].where = this.arrayToPattern(result);
       // Graph might not be applied yet since there was no project
       // this can only happen if there was a single graph
       if (graphs.length > 0) {
@@ -803,7 +816,9 @@ F.gen(),
         }
         // Ignore if default graph
         if (graphs[0]?.value !== '') {
-          updates[0].where = [ F.patternGraph(this.translateTerm(graphs[0]), updates[0].where, F.gen()) ];
+          updates[0].where.patterns = [
+            F.patternGraph(this.translateTerm(graphs[0]), updates[0].where.patterns, F.gen()),
+          ];
         }
       }
     }

packages/algebra-transformer-1-1/lib/sparqlAlgebra.ts

@@ -538,7 +538,7 @@ class QueryTranslator {
       const contained = predicate.items[0];
       let items: (TermIri | PathNegatedElt)[];
       if (this.astFactory.isPathPure(contained) && contained.subType === '|') {
-        items = <(TermIri | PathNegatedElt)[]> contained.items;
+        items = contained.items;
       } else {
         items = [ contained ];
       }
@@ -1071,8 +1071,8 @@ class QueryTranslator {
         this.translateUpdateTriplesBlock(quad, op.graph ? this.translateTerm(op.graph) : op.graph)));
       insertTriples.push(...op.insert.flatMap(quad =>
         this.translateUpdateTriplesBlock(quad, op.graph ? this.translateTerm(op.graph) : op.graph)));
-      if (op.where.length > 0) {
-        where = this.translateGraphPattern(F.patternGroup(op.where, F.sourceLocation(...op.where)));
+      if (op.where.patterns.length > 0) {
+        where = this.translateGraphPattern(op.where);
         const use: { default: RDF.NamedNode[]; named: RDF.NamedNode[] } = this.translateDatasetClause(op.from);
         if (use.default.length > 0 || use.named.length > 0) {
           where = this.factory.createFrom(where, use.default, use.named);

packages/algebra-transformer-1-1/test/sparql/sparql11-query/update/sparql-update-3-1-3-2b-quads.sparql

@@ -13,3 +13,9 @@ WHERE
       ?person  foaf:name  ?name .
       OPTIONAL { ?person  foaf:mbox  ?email }
     } }
+
+INSERT{
+GRAPH <http://example/addresses> {
+?person <http://xmlns.com/foaf/0.1/name> ?name .
+?person <http://xmlns.com/foaf/0.1/mbox> ?email . } } WHERE {
+GRAPH <http://example/people> { } } ;

packages/core/lib/generator-builder/dynamicGenerator.ts

@@ -48,6 +48,7 @@ export class DynamicGenerator<Context, Names extends string, RuleDefs extends Ge
     const generate = (): void => def.gImpl({
       SUBRULE: this.subrule,
       PRINT: this.print,
+      PRINT_SPACE_LEFT: this.printSpaceLeft,
       PRINT_WORD: this.printWord,
       PRINT_WORDS: this.printWords,
       CATCHUP: this.catchup,
@@ -119,6 +120,11 @@ export class DynamicGenerator<Context, Names extends string, RuleDefs extends Ge
     this.expectsSpace = true;
   };
 
+  private readonly printSpaceLeft: RuleDefArg['PRINT_WORD'] = (...args) => {
+    this.expectsSpace = true;
+    this.print(...args);
+  };
+
   private readonly printWords: RuleDefArg['PRINT_WORD'] = (...args) => {
     for (const arg of args) {
       this.printWord(arg);

packages/core/lib/generator-builder/generatorTypes.ts

@@ -32,6 +32,7 @@ export type GeneratorRule<
 export interface RuleDefArg {
   SUBRULE: <T, U>(cstDef: GeneratorRule<any, any, T, U>, input: T, arg: U) => void;
   PRINT: (...args: string[]) => void;
+  PRINT_SPACE_LEFT: (...args: string[]) => void;
   PRINT_WORD: (...args: string[]) => void;
   PRINT_WORDS: (...args: string[]) => void;
   HANDLE_LOC: <T>(loc: Localized, nodeHandle: () => T) => T | undefined;

packages/rules-sparql-1-1/lib/RoundTripTypes.ts

@@ -88,7 +88,7 @@ export type UpdateOperationModify = UpdateOperationBase & {
   insert: Quads[];
   delete: Quads[];
   from: DatasetClauses;
-  where: Pattern[];
+  where: PatternGroup;
 };
 export type UpdateOperation =
   | UpdateOperationLoad

packages/rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts

@@ -4,7 +4,7 @@ import type {
   GraphRef,
   GraphRefDefault,
   GraphRefSpecific,
-  Pattern,
+  Pattern, PatternGroup,
   Quads,
   TermIri,
   UpdateOperationAdd,
@@ -254,7 +254,7 @@ export function UpdateOperationFactoryMixin<TBase extends Constructor<CoreFactor
       loc: SourceLocation,
       insert: Quads[] | undefined,
       del: Quads[] | undefined,
-      where: Pattern[],
+      where: PatternGroup,
       from: DatasetClauses,
       graph?: TermIri | undefined,
     ): UpdateOperationModify {

packages/rules-sparql-1-1/lib/grammar/dataSetClause.ts

@@ -51,6 +51,7 @@ export const usingClause = datasetClauseUsing('usingClause', l.usingClause);
 export function datasetClauseUsingStar<RuleName extends string>(
   name: RuleName,
   subRule: ReturnType<typeof datasetClauseUsing<any>>,
+  fromUsing: 'FROM' | 'USING',
 ): SparqlRule<RuleName, DatasetClauses> {
   return {
     name,
@@ -69,7 +70,7 @@ export function datasetClauseUsingStar<RuleName extends string>(
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
       for (const clause of ast.clauses) {
-        PRINT_WORD('FROM');
+        PRINT_WORD(fromUsing);
         if (clause.clauseType === 'named') {
           F.printFilter(ast, () => PRINT_WORD('NAMED'));
         }
@@ -79,8 +80,8 @@ export function datasetClauseUsingStar<RuleName extends string>(
   };
 }
 
-export const datasetClauseStar = datasetClauseUsingStar(<const> 'datasetClauses', datasetClause);
-export const usingClauseStar = datasetClauseUsingStar(<const> 'usingClauses', usingClause);
+export const datasetClauseStar = datasetClauseUsingStar(<const> 'datasetClauses', datasetClause, 'FROM');
+export const usingClauseStar = datasetClauseUsingStar(<const> 'usingClauses', usingClause, 'USING');
 
 /**
  * [[15]](https://www.w3.org/TR/sparql11-query/#rNamedGraphClause)

packages/rules-sparql-1-1/lib/grammar/expression.ts

@@ -70,7 +70,9 @@ export const argList: SparqlRule<'argList', Wrap<IArgList>> = <const> {
       }
     });
     const [ head, ...tail ] = ast.val.args;
-    SUBRULE(expression, head, undefined);
+    if (head) {
+      SUBRULE(expression, head, undefined);
+    }
     for (const expr of tail) {
       F.printFilter(ast, () => PRINT_WORD(','));
       SUBRULE(expression, expr, undefined);
@@ -104,7 +106,7 @@ export const expressionList: SparqlGrammarRule<'expressionList', Wrap<Expression
   ]),
 };
 
-const infixOperators = new Set([ '||', '&&', '=', '!=', '<', '>', '<=', '>=', '+', '-', '*', '/' ]);
+const infixOperators = new Set([ 'in', 'notin', '||', '&&', '=', '!=', '<', '>', '<=', '>=', '+', '-', '*', '/' ]);
 const prefixOperator = new Set([ '!', 'UPLUS', 'UMINUS' ]);
 
 /**
@@ -118,7 +120,7 @@ export const expression: SparqlRule<'expression', Expression> = <const> {
       SUBRULE(varOrTerm, ast, undefined);
     } else if (F.isExpressionOperator(ast)) {
       if (infixOperators.has(ast.operator)) {
-        const [ left, right ] = <[Expression, Expression]>ast.args;
+        const [ left, ...right ] = ast.args;
         F.printFilter(ast, () => PRINT_WORD('('));
         SUBRULE(expression, left, undefined);
         F.printFilter(ast, () => {
@@ -130,7 +132,11 @@ export const expression: SparqlRule<'expression', Expression> = <const> {
             PRINT_WORD(ast.operator);
           }
         });
-        SUBRULE(expression, right, undefined);
+        if (right.length === 1) {
+          SUBRULE(expression, right[0], undefined);
+        } else {
+          SUBRULE(argList, F.wrap({ args: right, distinct: false }, ast.loc), undefined);
+        }
         F.printFilter(ast, () => PRINT_WORD(')'));
       } else if (prefixOperator.has(ast.operator)) {
         const [ expr ] = <[Expression]>ast.args;

packages/rules-sparql-1-1/lib/grammar/literals.ts

@@ -64,8 +64,8 @@ export const rdfLiteral: SparqlRule<'rdfLiteral', TermLiteral> = <const> {
       } },
     ])) ?? value;
   },
-  gImpl: ({ SUBRULE, PRINT }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT(stringEscapedLexical(ast.value)));
+  gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { factory }) => {
+    factory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
 
     if (ast.langOrIri) {
       if (typeof ast.langOrIri === 'string') {
@@ -240,8 +240,8 @@ export const iriFull: SparqlRule<'iriFull', TermIriFull> = <const> {
     const iriToken = CONSUME(l.terminals.iriRef);
     return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
   },
-  gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT_WORD('<', ast.value, '>'));
+  gImpl: ({ PRINT }) => (ast, { factory }) => {
+    factory.printFilter(ast, () => PRINT('<', ast.value, '>'));
   },
 };