part of quety generation

Author: jitsedesmet

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

@@ -27,7 +27,7 @@ import type {
 } from '../RoundTripTypes';
 import type { SparqlGrammarRule, SparqlRule } from '../Sparql11types';
 import { expression } from './expression';
-import { string } from './literals';
+import { string, stringEscapedLexical } from './literals';
 
 export const builtInStr = funcExpr1(l.builtIn.str);
 export const builtInLang = funcExpr1(l.builtIn.lang);
@@ -294,5 +294,22 @@ export const aggregate: SparqlRule<'aggregate', ExpressionAggregate> = <const>{
 
     return result;
   },
-  gImpl: () => () => {},
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_WORD(ast.aggregation, '(');
+      if (ast.distinct) {
+        PRINT_WORD('DISTINCT');
+      }
+    });
+    const arg = ast.expression[0];
+    if (F.isWildcard(arg)) {
+      F.printFilter(ast, () => PRINT_WORD('*'));
+    } else {
+      SUBRULE(expression, arg, undefined);
+    }
+    if (F.isExpressionAggregateSeparator(ast)) {
+      F.printFilter(ast, () => PRINT_WORD(';', 'SEPARATOR', '=', stringEscapedLexical(ast.separator)));
+    }
+    F.printFilter(ast, () => PRINT_WORD(')'));
+  },
 };

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

@@ -12,9 +12,10 @@ import type {
   SparqlGrammarRule,
   SparqlRule,
 } from '../Sparql11types';
-import { builtInCall } from './builtIn';
+import { aggregate, builtInCall } from './builtIn';
 import {
   var_,
+  varOrTerm,
 } from './general';
 import {
   booleanLiteral,
@@ -24,9 +25,7 @@ import {
   numericLiteralPositive,
   rdfLiteral,
 } from './literals';
-
-const infixOperators = new Set([ '||', '&&', '=', '!=', '<', '>', '<=', '>=', 'in', 'notin', '+', '-', '*', '/' ]);
-const prefixOperator = new Set([ '!', 'UPLUS', 'UMINUS' ]);
+import { groupGraphPattern } from './whereClause';
 
 /**
  * [[71]](https://www.w3.org/TR/sparql11-query/#rArgList)
@@ -64,13 +63,27 @@ export const argList: SparqlRule<'argList', Wrap<IArgList>> = <const> {
           C.factory.wrap({ args, distinct }, C.factory.sourceLocation(open, close)));
       } },
     ]),
-  gImpl: () => () => {},
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_WORD('(');
+      if (ast.val.distinct) {
+        PRINT_WORD('distinct');
+      }
+    });
+    const [ head, ...tail ] = ast.val.args;
+    SUBRULE(expression, head, undefined);
+    for (const expr of tail) {
+      F.printFilter(ast, () => PRINT_WORD(','));
+      SUBRULE(expression, expr, undefined);
+    }
+    F.printFilter(ast, () => PRINT_WORD(')'));
+  },
 };
 
 /**
  * [[72]](https://www.w3.org/TR/sparql11-query/#rConstructTemplate)
  */
-export const expressionList: SparqlRule<'expressionList', Wrap<Expression[]>> = <const> {
+export const expressionList: SparqlGrammarRule<'expressionList', Wrap<Expression[]>> = <const> {
   name: 'expressionList',
   impl: ({ ACTION, CONSUME, MANY, OR, SUBRULE1, SUBRULE2 }) => C => OR([
     { ALT: () => {
@@ -90,16 +103,66 @@ export const expressionList: SparqlRule<'expressionList', Wrap<Expression[]>> =
       return ACTION(() => C.factory.wrap(args, C.factory.sourceLocation(open, close)));
     } },
   ]),
-  gImpl: () => () => '',
 };
 
+const infixOperators = new Set([ '||', '&&', '=', '!=', '<', '>', '<=', '>=', '+', '-', '*', '/' ]);
+const prefixOperator = new Set([ '!', 'UPLUS', 'UMINUS' ]);
+
 /**
  * [[110]](https://www.w3.org/TR/sparql11-query/#rExpression)
  */
 export const expression: SparqlRule<'expression', Expression> = <const> {
   name: 'expression',
   impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression, undefined),
-  gImpl: () => () => {},
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+    if (F.isTerm(ast)) {
+      SUBRULE(varOrTerm, ast, undefined);
+    } else {
+      if (ast.expressionType === 'operation') {
+        if (infixOperators.has(ast.operator)) {
+          const [ left, right ] = <[Expression, Expression]>ast.args;
+          F.printFilter(ast, () => PRINT_WORD('('));
+          SUBRULE(expression, left, undefined);
+          F.printFilter(ast, () => {
+            if (ast.operator === 'notin') {
+              PRINT_WORD('NOT IN');
+            } else if (ast.operator === 'in') {
+              PRINT_WORD('IN');
+            } else {
+              PRINT_WORD(ast.operator);
+            }
+          });
+          SUBRULE(expression, right, undefined);
+          F.printFilter(ast, () => PRINT_WORD(')'));
+        } else if (prefixOperator.has(ast.operator)) {
+          const [ expr ] = <[Expression]>ast.args;
+          F.printFilter(ast, () => PRINT_WORD(ast.operator));
+          SUBRULE(expression, expr, undefined);
+        } else {
+          F.printFilter(ast, () => PRINT_WORD(ast.operator, '('));
+          const [ head, ...tail ] = ast.args;
+          if (head) {
+            SUBRULE(expression, head, undefined);
+          }
+          for (const arg of tail) {
+            F.printFilter(ast, () => PRINT_WORD(ast.operator, ','));
+            SUBRULE(expression, arg, undefined);
+          }
+        }
+      }
+      if (ast.expressionType === 'patternOperation') {
+        const patterns = ast.args;
+        F.printFilter(ast, () => PRINT_WORD(ast.operator === 'exists' ? 'EXISTS' : 'NOT EXISTS'));
+        SUBRULE(groupGraphPattern, F.patternGroup(patterns, ast.loc), undefined);
+      }
+      if (ast.expressionType === 'functionCall') {
+        return SUBRULE(iriOrFunction, ast, undefined);
+      }
+      if (ast.expressionType === 'aggregate') {
+        return SUBRULE(aggregate, ast, undefined);
+      }
+    }
+  },
 };
 
 type LeftDeepBuildArgs = (left: Expression) => ExpressionOperation;
@@ -403,5 +466,12 @@ export const iriOrFunction: SparqlRule<'iriOrFunction', TermIri | ExpressionFunc
     });
     return functionCall ?? iriVal;
   },
-  gImpl: () => () => {},
+  gImpl: ({ SUBRULE }) => (ast, { factory: F }) => {
+    if (F.isTermIri(ast)) {
+      SUBRULE(iri, ast, undefined);
+    } else {
+      SUBRULE(iri, ast.function, undefined);
+      SUBRULE(argList, F.wrap({ args: ast.args, distinct: ast.distinct }, ast.loc), undefined);
+    }
+  },
 };

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

@@ -40,7 +40,11 @@ export const baseDecl: SparqlRule<'baseDecl', ContextDefinitionBaseDecl> = <cons
     const val = SUBRULE(iriFull, undefined);
     return ACTION(() => C.factory.baseDecl(C.factory.sourceLocation(base, val), val));
   },
-  gImpl: () => () => {},
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT }) => (ast, { factory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD('BASE'));
+    SUBRULE(iri, ast.value, undefined);
+    F.printFilter(ast, () => PRINT('\n'));
+  },
 };
 
 /**
@@ -56,7 +60,13 @@ export const prefixDecl: SparqlRule<'prefixDecl', ContextDefinitionPrefixDecl> =
 
     return ACTION(() => C.factory.prefixDecl(C.factory.sourceLocation(prefix, value), name, value));
   },
-  gImpl: () => () => {},
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT }) => (ast, { factory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_WORD('PREFIX', `${ast.key}:`);
+    });
+    SUBRULE(iri, ast.value, undefined);
+    F.printFilter(ast, () => PRINT('\n'));
+  },
 };
 
 /**
@@ -110,10 +120,8 @@ export const var_: SparqlRule<'var', TermVariable> = <const> {
     ]);
     return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
   },
-  gImpl: ({ PRINT_WORD }) => (ast) => {
-    if (!ast.loc) {
-      PRINT_WORD('?', ast.value);
-    }
+  gImpl: ({ PRINT_WORD }) => (ast, { factory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
   },
 };
 

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

@@ -27,9 +27,9 @@ import type {
   SparqlRule,
 } from '../../Sparql11types';
 import { usingClauseStar } from '../dataSetClause';
-import { prologue, varOrIri } from '../general';
+import { prologue, varOrIri, varOrTerm } from '../general';
 import { iri } from '../literals';
-import { triplesTemplate } from '../tripleBlock';
+import { triplesBlock, triplesTemplate } from '../tripleBlock';
 import { groupGraphPattern } from '../whereClause';
 
 /**
@@ -455,5 +455,11 @@ export const quadsNotTriples: SparqlRule<'quadsNotTriples', GraphQuads> = <const
       loc: C.factory.sourceLocation(graph, close),
     }));
   },
-  gImpl: () => () => '',
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD('GRAPH'));
+    SUBRULE(varOrTerm, ast.graph, undefined);
+    F.printFilter(ast, () => PRINT_WORD('{'));
+    SUBRULE(triplesBlock, F.patternBgp(ast.triples, ast.loc), undefined);
+    F.printFilter(ast, () => PRINT_WORD('}'));
+  },
 };