@traqula/rules-sparql-1-1 0.0.1-alpha.176 → 0.0.1

package/lib/grammar/queryUnit/queryUnit.js

@@ -1,12 +1,11 @@
 import * as l from '../../lexer';
-import { Wildcard } from '../../Wildcard';
-import { datasetClause } from '../dataSetClause';
+import { queryIsGood } from '../../validation/validators';
+import { datasetClauseStar } from '../dataSetClause';
 import { expression } from '../expression';
 import { prologue, var_, varOrIri, varOrTerm } from '../general';
-import { iri } from '../literals';
 import { solutionModifier } from '../solutionModifier';
 import { triplesBlock, triplesTemplate } from '../tripleBlock';
-import { dataBlock, groupGraphPattern, inlineDataFull, whereClause } from '../whereClause';
+import { inlineData, whereClause } from '../whereClause';
 /**
  * [[1]](https://www.w3.org/TR/sparql11-query/#rQueryUnit)
  */
@@ -19,9 +18,9 @@ export const queryUnit = {
  */
 export const query = {
     name: 'query',
-    impl: ({ ACTION, SUBRULE, OR }) => () => {
+    impl: ({ ACTION, SUBRULE, OR }) => (C) => {
         const prologueValues = SUBRULE(prologue, undefined);
-        const queryType = OR([
+        const subType = OR([
             { ALT: () => SUBRULE(selectQuery, undefined) },
             { ALT: () => SUBRULE(constructQuery, undefined) },
             { ALT: () => SUBRULE(describeQuery, undefined) },
@@ -29,187 +28,64 @@ export const query = {
         ]);
         const values = SUBRULE(valuesClause, undefined);
         return ACTION(() => ({
-            ...prologueValues,
-            ...queryType,
+            context: prologueValues,
+            ...subType,
             type: 'query',
             ...(values && { values }),
+            loc: C.factory.sourceLocation(prologueValues.at(0), subType, values),
         }));
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const prologueString = SUBRULE(prologue, ast, undefined);
-        let queryString = '';
-        switch (ast.queryType) {
-            case 'SELECT':
-                queryString = SUBRULE(selectQuery, ast, undefined);
-                break;
-            case 'CONSTRUCT':
-                queryString = SUBRULE(constructQuery, ast, undefined);
-                break;
-            case 'DESCRIBE':
-                queryString = SUBRULE(describeQuery, ast, undefined);
-                break;
-            case 'ASK':
-                queryString = SUBRULE(askQuery, ast, undefined);
-                break;
+    gImpl: ({ SUBRULE }) => (ast, { factory: F }) => {
+        SUBRULE(prologue, ast.context, undefined);
+        if (F.isQuerySelect(ast)) {
+            SUBRULE(selectQuery, ast, undefined);
         }
-        const valuesString = ast.values ? SUBRULE(valuesClause, ast.values, undefined) : '';
-        return [prologueString, queryString, valuesString].filter(Boolean).join(' ');
-    },
-};
-function extractFromOfDataSetClauses(ACTION, MANY, SUBRULE) {
-    const datasetClauses = [];
-    MANY(() => {
-        datasetClauses.push(SUBRULE(datasetClause, undefined));
-    });
-    return ACTION(() => {
-        const from = {
-            default: [],
-            named: [],
-        };
-        for (const datasetClause of datasetClauses) {
-            if (datasetClause.type === 'default') {
-                from.default.push(datasetClause.value);
-            }
-            else {
-                from.named.push(datasetClause.value);
-            }
-        }
-        return (from.default.length === 0 && from.named.length === 0) ? undefined : from;
-    });
-}
-/**
- * Get all 'aggregate' rules from an expression
- */
-function getAggregatesOfExpression(expression) {
-    if ('type' in expression) {
-        if (expression.type === 'aggregate') {
-            return [expression];
+        else if (F.isQueryConstruct(ast)) {
+            SUBRULE(constructQuery, ast, undefined);
         }
-        if (expression.type === 'operation') {
-            const aggregates = [];
-            for (const arg of expression.args) {
-                aggregates.push(...getAggregatesOfExpression(arg));
-            }
-            return aggregates;
-        }
-    }
-    return [];
-}
-/**
- * Return the id of an expression
- */
-function getExpressionId(expression) {
-    // Check if grouping
-    if ('variable' in expression && expression.variable) {
-        return expression.variable.value;
-    }
-    if ('value' in expression) {
-        return expression.value;
-    }
-    return 'value' in expression.expression ? expression.expression.value : undefined;
-}
-/**
- * Get all variables used in an expression
- */
-function getVariablesFromExpression(expression) {
-    const variables = new Set();
-    const visitExpression = (expr) => {
-        if (!expr) {
-            return;
+        else if (F.isQueryDescribe(ast)) {
+            SUBRULE(describeQuery, ast, undefined);
         }
-        if ('termType' in expr && expr.termType === 'Variable') {
-            variables.add(expr);
+        else if (F.isQueryAsk(ast)) {
+            SUBRULE(askQuery, ast, undefined);
         }
-        else if ('type' in expr && expr.type === 'operation') {
-            for (const rec of expr.args) {
-                visitExpression(rec);
-            }
+        if (ast.values) {
+            SUBRULE(inlineData, ast.values, undefined);
         }
-    };
-    visitExpression(expression);
-    return variables;
-}
+    },
+};
 /**
  * [[7]](https://www.w3.org/TR/sparql11-query/#rSelectQuery)
  */
 export const selectQuery = {
     name: 'selectQuery',
-    impl: ({ ACTION, SUBRULE, MANY }) => (C) => {
+    impl: ({ ACTION, SUBRULE }) => (C) => {
         const selectVal = SUBRULE(selectClause, undefined);
-        const from = extractFromOfDataSetClauses(ACTION, MANY, SUBRULE);
+        const from = SUBRULE(datasetClauseStar, undefined);
         const where = SUBRULE(whereClause, undefined);
-        const modifier = SUBRULE(solutionModifier, undefined);
-        ACTION(() => {
-            if (selectVal.variables.length === 1 && selectVal.variables[0] instanceof Wildcard) {
-                if (modifier.group !== undefined) {
-                    throw new Error('GROUP BY not allowed with wildcard');
-                }
-                return;
-            }
-            const variables = selectVal.variables;
-            // Check for projection of ungrouped variable
-            // Check can be skipped in case of wildcard select.
-            if (!C.skipValidation) {
-                const hasCountAggregate = variables.flatMap(varVal => 'termType' in varVal ? [] : getAggregatesOfExpression(varVal.expression)).some(agg => agg.aggregation === 'count' && !(agg.expression instanceof Wildcard));
-                if (hasCountAggregate || modifier.group) {
-                    // We have to check whether
-                    //  1. Variables used in projection are usable given the group by clause
-                    //  2. A selectCount will create an implicit group by clause.
-                    for (const selectVar of variables) {
-                        if ('termType' in selectVar) {
-                            if (!modifier.group || !modifier.group.map(groupvar => getExpressionId(groupvar))
-                                .includes((getExpressionId(selectVar)))) {
-                                throw new Error('Variable not allowed in projection');
-                            }
-                        }
-                        else if (getAggregatesOfExpression(selectVar.expression).length === 0) {
-                            const usedvars = getVariablesFromExpression(selectVar.expression);
-                            for (const usedvar of usedvars) {
-                                if (!modifier.group || !modifier.group.map || !modifier.group.map(groupVar => getExpressionId(groupVar))
-                                    .includes(getExpressionId(usedvar))) {
-                                    throw new Error(`Use of ungrouped variable in projection of operation (?${getExpressionId(usedvar)})`);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // Check if id of each AS-selected column is not yet bound by subquery
-            const subqueries = where.filter(pattern => pattern.type === 'query');
-            if (subqueries.length > 0) {
-                const selectedVarIds = [];
-                for (const selectedVar of variables) {
-                    if ('variable' in selectedVar) {
-                        selectedVarIds.push(selectedVar.variable.value);
-                    }
-                }
-                const vars = subqueries.flatMap(sub => sub.variables)
-                    .map(v => 'value' in v ? v.value : v.variable.value);
-                const subqueryIds = new Set(vars);
-                for (const selectedVarId of selectedVarIds) {
-                    if (subqueryIds.has(selectedVarId)) {
-                        throw new Error(`Target id of 'AS' (?${selectedVarId}) already used in subquery`);
-                    }
-                }
-            }
+        const modifiers = SUBRULE(solutionModifier, undefined);
+        return ACTION(() => {
+            const ret = {
+                subType: 'select',
+                where: where.val,
+                solutionModifiers: modifiers,
+                datasets: from,
+                ...selectVal.val,
+                loc: C.factory.sourceLocation(selectVal, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset),
+            };
+            queryIsGood(ret);
+            return ret;
         });
-        return {
-            ...selectVal,
-            queryType: 'SELECT',
-            ...(from && { from }),
-            where,
-            ...modifier,
-        };
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const selectString = SUBRULE(selectClause, ast, undefined);
-        const fromDefaultString = ast.from?.default.map(clause => `FROM ${SUBRULE(iri, clause, undefined)}`).join(' ') ?? '';
-        const fromNamedString = ast.from?.named.map(clause => `FROM NAMED ${SUBRULE(iri, clause, undefined)}`).join(' ') ?? '';
-        const whereString = ast.where ?
-            `WHERE ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.where }, undefined)}` :
-            '';
-        const modifierString = SUBRULE(solutionModifier, ast, undefined);
-        return [selectString, fromDefaultString, fromNamedString, whereString, modifierString].filter(Boolean).join(' ');
+    gImpl: ({ SUBRULE }) => (ast, { factory: F }) => {
+        SUBRULE(selectClause, F.wrap({
+            variables: ast.variables,
+            distinct: ast.distinct,
+            reduced: ast.reduced,
+        }, F.sourceLocation(...ast.variables)), undefined);
+        SUBRULE(datasetClauseStar, ast.datasets, undefined);
+        SUBRULE(whereClause, F.wrap(ast.where, ast.where.loc), undefined);
+        SUBRULE(solutionModifier, ast.solutionModifiers, undefined);
     },
 };
 /**
@@ -217,104 +93,117 @@ export const selectQuery = {
  */
 export const subSelect = {
     name: 'subSelect',
-    impl: ({ ACTION, SUBRULE }) => () => {
-        const clause = SUBRULE(selectClause, undefined);
+    impl: ({ ACTION, SUBRULE }) => (C) => {
+        const selectVal = SUBRULE(selectClause, undefined);
         const where = SUBRULE(whereClause, undefined);
         const modifiers = SUBRULE(solutionModifier, undefined);
         const values = SUBRULE(valuesClause, undefined);
-        return ACTION(() => ({
-            ...modifiers,
-            ...clause,
-            type: 'query',
-            queryType: 'SELECT',
-            where,
+        return ACTION(() => C.factory.querySelect({
+            where: where.val,
+            datasets: C.factory.datasetClauses([], C.factory.sourceLocation()),
+            context: [],
+            solutionModifiers: modifiers,
+            ...selectVal.val,
             ...(values && { values }),
-        }));
+        }, C.factory.sourceLocation(selectVal, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values)));
     },
 };
+/**
+ * [[9]](https://www.w3.org/TR/sparql11-query/#rSelectClause)
+ */
 export const selectClause = {
     name: 'selectClause',
-    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, OR3 }) => (C) => {
-        CONSUME(l.select);
+    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, SUBRULE2, CONSUME, OPTION, OR1, OR2, OR3, }) => (C) => {
+        const select = CONSUME(l.select);
         const couldParseAgg = ACTION(() => C.parseMode.has('canParseAggregate') || !C.parseMode.add('canParseAggregate'));
-        const distinctOrReduced = OPTION(() => OR1([
+        const distinctAndReduced = OPTION(() => OR1([
             { ALT: () => {
                     CONSUME(l.distinct);
-                    return { distinct: true };
+                    return [true, false];
                 } },
             { ALT: () => {
                     CONSUME(l.reduced);
-                    return { reduced: true };
+                    return [false, true];
                 } },
-        ]));
-        const variables = OR2([
+        ])) ?? [false, false];
+        const distRed = ACTION(() => {
+            const [distinct, reduced] = distinctAndReduced;
+            return {
+                ...(distinct && { distinct }),
+                ...(reduced && { reduced }),
+            };
+        });
+        let last;
+        const val = OR2([
             { ALT: () => {
-                    CONSUME(l.symbols.star);
-                    return [new Wildcard()];
+                    const star = CONSUME(l.symbols.star);
+                    return ACTION(() => {
+                        last = star;
+                        return { variables: [C.factory.wildcard(C.factory.sourceLocation(star))], ...distRed };
+                    });
                 } },
             { ALT: () => {
                     const usedVars = [];
-                    const result = [];
+                    const variables = [];
                     AT_LEAST_ONE(() => OR3([
                         { ALT: () => {
                                 const raw = SUBRULE1(var_, undefined);
                                 ACTION(() => {
-                                    if (usedVars.some(v => v.equals(raw))) {
+                                    if (usedVars.some(v => v.value === raw.value)) {
                                         throw new Error(`Variable ${raw.value} used more than once in SELECT clause`);
                                     }
                                     usedVars.push(raw);
-                                    result.push(raw);
+                                    variables.push(raw);
+                                    last = raw;
                                 });
                             } },
                         { ALT: () => {
-                                CONSUME(l.symbols.LParen);
-                                const expr = SUBRULE(expression, undefined);
+                                const open = CONSUME(l.symbols.LParen);
+                                const expr = SUBRULE1(expression, undefined);
                                 CONSUME(l.as);
                                 const variable = SUBRULE2(var_, undefined);
-                                CONSUME(l.symbols.RParen);
+                                const close = CONSUME(l.symbols.RParen);
                                 ACTION(() => {
-                                    if (usedVars.some(v => v.equals(variable))) {
+                                    last = close;
+                                    if (usedVars.some(v => v.value === variable.value)) {
                                         throw new Error(`Variable ${variable.value} used more than once in SELECT clause`);
                                     }
                                     usedVars.push(variable);
-                                    result.push({
-                                        expression: expr,
-                                        variable,
-                                    });
+                                    variables.push(C.factory.patternBind(expr, variable, C.factory.sourceLocation(open, last)));
                                 });
                             } },
                     ]));
-                    return result;
+                    return { variables, ...distRed };
                 } },
         ]);
         ACTION(() => !couldParseAgg && C.parseMode.delete('canParseAggregate'));
-        return ACTION(() => ({
-            ...distinctOrReduced,
-            variables,
-        }));
+        return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(select, last)));
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const builder = ['SELECT'];
-        if (ast.distinct) {
-            builder.push('DISTINCT');
-        }
-        else if (ast.reduced) {
-            builder.push('REDUCED');
-        }
-        if (ast.variables.length === 1 && ast.variables[0] instanceof Wildcard) {
-            builder.push('*');
-        }
-        else {
-            for (const variable of ast.variables) {
-                if ('expression' in variable) {
-                    builder.push(`( ${SUBRULE(expression, variable.expression, undefined)} AS ${SUBRULE(var_, variable.variable, undefined)} )`);
-                }
-                else {
-                    builder.push(SUBRULE(var_, variable, undefined));
-                }
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => {
+            PRINT_WORD('SELECT');
+            if (ast.val.distinct) {
+                PRINT_WORD('DISTINCT');
+            }
+            else if (ast.val.reduced) {
+                PRINT_WORD('REDUCED');
+            }
+        });
+        for (const variable of ast.val.variables) {
+            if (F.isWildcard(variable)) {
+                F.printFilter(ast, () => PRINT_WORD('*'));
+            }
+            else if (F.isTerm(variable)) {
+                SUBRULE(var_, variable, undefined);
+            }
+            else {
+                F.printFilter(ast, () => PRINT_WORD('('));
+                SUBRULE(expression, variable.expression, undefined);
+                F.printFilter(ast, () => PRINT_WORD('AS'));
+                SUBRULE(var_, variable.variable, undefined);
+                F.printFilter(ast, () => PRINT_WORD(')'));
             }
         }
-        return builder.join(' ');
     },
 };
 /**
@@ -322,59 +211,56 @@ export const selectClause = {
  */
 export const constructQuery = {
     name: 'constructQuery',
-    impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, MANY1, MANY2, OPTION, OR }) => () => {
-        CONSUME(l.construct);
+    impl: ({ ACTION, SUBRULE1, SUBRULE2, CONSUME, OR }) => (C) => {
+        const construct = CONSUME(l.construct);
         return OR([
-            {
-                ALT: () => {
-                    const template = SUBRULE(constructTemplate, undefined);
-                    const from = extractFromOfDataSetClauses(ACTION, MANY1, SUBRULE1);
-                    const where = SUBRULE(whereClause, undefined);
+            { ALT: () => {
+                    const template = SUBRULE1(constructTemplate, undefined);
+                    const from = SUBRULE1(datasetClauseStar, undefined);
+                    const where = SUBRULE1(whereClause, undefined);
                     const modifiers = SUBRULE1(solutionModifier, undefined);
                     return ACTION(() => ({
-                        ...modifiers,
-                        queryType: 'CONSTRUCT',
-                        template,
-                        from,
-                        where,
+                        subType: 'construct',
+                        template: template.val,
+                        datasets: from,
+                        where: where.val,
+                        solutionModifiers: modifiers,
+                        loc: C.factory.sourceLocation(construct, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset),
                     }));
-                },
-            },
-            {
-                ALT: () => {
-                    const from = extractFromOfDataSetClauses(ACTION, MANY2, SUBRULE2);
+                } },
+            { ALT: () => {
+                    const from = SUBRULE2(datasetClauseStar, undefined);
                     CONSUME(l.where);
-                    CONSUME(l.symbols.LCurly);
-                    const template = OPTION(() => SUBRULE(triplesTemplate, undefined));
-                    CONSUME(l.symbols.RCurly);
+                    // ConstructTemplate is same as '{' TriplesTemplate? '}'
+                    const template = SUBRULE2(constructTemplate, undefined);
                     const modifiers = SUBRULE2(solutionModifier, undefined);
-                    const where = template ?
-                        [{
-                                type: 'bgp',
-                                triples: template,
-                            }] :
-                        [];
                     return ACTION(() => ({
-                        ...modifiers,
-                        queryType: 'CONSTRUCT',
-                        from,
-                        template,
-                        where,
+                        subType: 'construct',
+                        template: template.val,
+                        datasets: from,
+                        where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
+                        solutionModifiers: modifiers,
+                        loc: C.factory.sourceLocation(construct, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset),
                     }));
-                },
-            },
+                } },
         ]);
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const constructString = SUBRULE(constructTemplate, ast.template, undefined);
-        const fromDefaultString = ast.from?.default.map(clause => `FROM ${SUBRULE(iri, clause, undefined)}`).join(' ') ?? '';
-        const fromNamedString = ast.from?.named.map(clause => `FROM NAMED ${SUBRULE(iri, clause, undefined)}`).join(' ') ?? '';
-        const whereString = ast.where ?
-            `WHERE ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.where }, undefined)}` :
-            '';
-        const modifierString = SUBRULE(solutionModifier, ast, undefined);
-        return ['CONSTRUCT', constructString, fromDefaultString, fromNamedString, whereString, modifierString]
-            .filter(Boolean).join(' ');
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('CONSTRUCT'));
+        if (!F.isSourceLocationNoMaterialize(ast.where.loc)) {
+            // You are NOT in second case construct
+            F.printFilter(ast, () => PRINT_WORD('{'));
+            SUBRULE(triplesBlock, ast.template, undefined);
+            F.printFilter(ast, () => PRINT_WORD('}'));
+        }
+        SUBRULE(datasetClauseStar, ast.datasets, undefined);
+        if (F.isSourceLocationNoMaterialize(ast.where.loc)) {
+            SUBRULE(whereClause, F.wrap(F.patternGroup([ast.template], ast.template.loc), ast.template.loc), undefined);
+        }
+        else {
+            SUBRULE(whereClause, F.wrap(ast.where, ast.where.loc), undefined);
+        }
+        SUBRULE(solutionModifier, ast.solutionModifiers, undefined);
     },
 };
 /**
@@ -382,51 +268,48 @@ export const constructQuery = {
  */
 export const describeQuery = {
     name: 'describeQuery',
-    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, MANY, OPTION, OR }) => () => {
-        CONSUME(l.describe);
+    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, CONSUME, OPTION, OR }) => (C) => {
+        const describe = CONSUME(l.describe);
         const variables = OR([
             { ALT: () => {
                     const variables = [];
                     AT_LEAST_ONE(() => {
-                        variables.push(SUBRULE(varOrIri, undefined));
+                        variables.push(SUBRULE1(varOrIri, undefined));
                     });
                     return variables;
                 } },
             { ALT: () => {
-                    CONSUME(l.symbols.star);
-                    return [new Wildcard()];
+                    const star = CONSUME(l.symbols.star);
+                    return [ACTION(() => C.factory.wildcard(C.factory.sourceLocation(star)))];
                 } },
         ]);
-        const from = extractFromOfDataSetClauses(ACTION, MANY, SUBRULE);
-        const where = OPTION(() => SUBRULE(whereClause, undefined));
-        const modifiers = SUBRULE(solutionModifier, undefined);
+        const from = SUBRULE1(datasetClauseStar, undefined);
+        const where = OPTION(() => SUBRULE1(whereClause, undefined));
+        const modifiers = SUBRULE1(solutionModifier, undefined);
         return ACTION(() => ({
-            ...modifiers,
-            queryType: 'DESCRIBE',
+            subType: 'describe',
             variables,
-            from,
-            where,
+            datasets: from,
+            ...(where && { where: where.val }),
+            solutionModifiers: modifiers,
+            loc: C.factory.sourceLocation(describe, ...variables, from, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset),
         }));
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const builder = ['DESCRIBE'];
-        for (const variable of ast.variables) {
-            if (variable.termType === 'Wildcard') {
-                builder.push('*');
-            }
-            else {
-                builder.push(SUBRULE(varOrTerm, variable, undefined));
-            }
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('DESCRIBE'));
+        if (F.isWildcard(ast.variables[0])) {
+            F.printFilter(ast, () => PRINT_WORD('*'));
         }
-        if (ast.from) {
-            builder.push(ast.from.default.map(clause => `FROM ${SUBRULE(iri, clause, undefined)}`).join(' '));
-            builder.push(ast.from.named.map(clause => `FROM NAMED ${SUBRULE(iri, clause, undefined)}`).join(' '));
+        else {
+            for (const variable of ast.variables) {
+                SUBRULE(varOrTerm, variable, undefined);
+            }
         }
+        SUBRULE(datasetClauseStar, ast.datasets, undefined);
         if (ast.where) {
-            builder.push(`WHERE ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.where }, undefined)}`);
+            SUBRULE(whereClause, F.wrap(ast.where, ast.loc), undefined);
         }
-        builder.push(SUBRULE(solutionModifier, ast, undefined));
-        return builder.join(' ');
+        SUBRULE(solutionModifier, ast.solutionModifiers, undefined);
     },
 };
 /**
@@ -434,29 +317,24 @@ export const describeQuery = {
  */
 export const askQuery = {
     name: 'askQuery',
-    impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => () => {
-        CONSUME(l.ask);
-        const from = extractFromOfDataSetClauses(ACTION, MANY, SUBRULE);
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const ask = CONSUME(l.ask);
+        const from = SUBRULE(datasetClauseStar, undefined);
         const where = SUBRULE(whereClause, undefined);
         const modifiers = SUBRULE(solutionModifier, undefined);
         return ACTION(() => ({
-            ...modifiers,
-            queryType: 'ASK',
-            from,
-            where,
+            subType: 'ask',
+            datasets: from,
+            where: where.val,
+            solutionModifiers: modifiers,
+            loc: C.factory.sourceLocation(ask, from, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset),
         }));
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const builder = ['ASK'];
-        if (ast.from) {
-            builder.push(ast.from.default.map(clause => `FROM ${SUBRULE(iri, clause, undefined)}`).join(' '));
-            builder.push(ast.from.named.map(clause => `FROM NAMED ${SUBRULE(iri, clause, undefined)}`).join(' '));
-        }
-        if (ast.where) {
-            builder.push(`WHERE ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.where }, undefined)}`);
-        }
-        builder.push(SUBRULE(solutionModifier, ast, undefined));
-        return builder.join(' ');
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('ASK'));
+        SUBRULE(datasetClauseStar, ast.datasets, undefined);
+        SUBRULE(whereClause, F.wrap(ast.where, ast.loc), undefined);
+        SUBRULE(solutionModifier, ast.solutionModifiers, undefined);
     },
 };
 /**
@@ -464,31 +342,19 @@ export const askQuery = {
  */
 export const valuesClause = {
     name: 'valuesClause',
-    impl: ({ SUBRULE, CONSUME, OPTION }) => () => OPTION(() => {
-        CONSUME(l.values);
-        return SUBRULE(dataBlock, undefined);
-    }),
-    gImpl: ({ SUBRULE }) => (ast) => {
-        if (ast) {
-            return `${SUBRULE(inlineDataFull, ast, undefined)}`;
-        }
-        return '';
-    },
+    impl: ({ OPTION, SUBRULE }) => () => OPTION(() => SUBRULE(inlineData, undefined)),
 };
 /**
  * [[73]](https://www.w3.org/TR/sparql11-query/#ConstructTemplate)
  */
 export const constructTemplate = {
     name: 'constructTemplate',
-    impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
-        CONSUME(l.symbols.LCurly);
-        const triples = OPTION(() => SUBRULE(constructTriples, undefined));
-        CONSUME(l.symbols.RCurly);
-        return triples;
+    impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+        const open = CONSUME(l.symbols.LCurly);
+        const triples = OPTION(() => SUBRULE1(constructTriples, undefined));
+        const close = CONSUME(l.symbols.RCurly);
+        return ACTION(() => C.factory.wrap(triples ?? C.factory.patternBgp([], C.factory.sourceLocation()), C.factory.sourceLocation(open, close)));
     },
-    gImpl: ({ SUBRULE }) => ast => `{
-${ast ? SUBRULE(triplesBlock, { type: 'bgp', triples: ast }, undefined) : ''}
-}`,
 };
 /**
  * [[12]](https://www.w3.org/TR/sparql11-query/#rConstructTriples)