@comake/skl-js-engine 1.5.4 → 1.5.6

package/dist/storage/query-adapter/sparql/SparqlQueryBuilder.js

@@ -0,0 +1,1210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparqlQueryBuilder = void 0;
+/* eslint-disable no-inline-comments */
+/* eslint-disable line-comment-position */
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable multiline-comment-style */
+/* eslint-disable capitalized-comments */
+/* eslint-disable indent */
+const data_model_1 = __importDefault(require("@rdfjs/data-model"));
+const constants_1 = require("../../../constants");
+const PerformanceLogger_1 = require("../../../util/PerformanceLogger");
+const SparqlUtil_1 = require("../../../util/SparqlUtil");
+const TripleUtil_1 = require("../../../util/TripleUtil");
+const Util_1 = require("../../../util/Util");
+const Vocabularies_1 = require("../../../util/Vocabularies");
+const FindOperator_1 = require("../../FindOperator");
+const VariableGenerator_1 = require("./VariableGenerator");
+class SparqlQueryBuilder {
+    constructor() {
+        this.variableGenerator = new VariableGenerator_1.VariableGenerator();
+    }
+    buildEntitySelectPatternsFromOptions(subject, options) {
+        const span = PerformanceLogger_1.PerformanceLogger.startSpan('QueryBuilder.buildSelect', {
+            hasWhere: !!options?.where,
+            hasRelations: !!options?.relations
+        });
+        try {
+            const relations = options?.select ? undefined : options?.relations;
+            const whereQueryData = this.createWhereQueryData(subject, options?.where, true);
+            const orderQueryData = this.createOrderQueryData(subject, options?.order);
+            const relationsQueryData = this.createRelationsQueryData(subject, relations);
+            // Handle subqueries
+            if (options?.subQueries && options.subQueries.length > 0) {
+                const subQueryPatterns = this.createSubQueryPatterns(options.subQueries);
+                whereQueryData.values.unshift(...subQueryPatterns);
+            }
+            const patterns = whereQueryData.values;
+            if (whereQueryData.triples.length === 0 &&
+                (whereQueryData.filters.length > 0 ||
+                    orderQueryData.triples.length > 0 ||
+                    (whereQueryData.values.length === 0 &&
+                        whereQueryData.graphValues.length === 0 &&
+                        whereQueryData.graphTriples.length === 0))) {
+                if (relationsQueryData.unionPatterns.length > 0) {
+                    /* relationsQueryData.unionPatterns.push(
+                      createSparqlGraphPattern(subject, [ createSparqlBasicGraphPattern([ entityGraphTriple ]) ])
+                    ); */
+                }
+                else {
+                    const entityGraphFilterPattern = this.createEntityGraphFilterPattern(subject);
+                    // patterns.push(createSparqlGraphPattern(subject, [ createSparqlBasicGraphPattern([ entityGraphTriple ]) ]));
+                    patterns.push(entityGraphFilterPattern);
+                }
+            }
+            else if (!options?.where?.id) {
+                const entityGraphFilterPattern = this.createEntityGraphFilterPattern(subject);
+                const entityIsGraphFilter = (0, SparqlUtil_1.createSparqlExistsOperation)([entityGraphFilterPattern]);
+                whereQueryData.filters.push(entityIsGraphFilter);
+            }
+            // Add union patterns to the patterns
+            if (relationsQueryData.unionPatterns.length > 0) {
+                patterns.push((0, SparqlUtil_1.createSparqlUnion)(relationsQueryData.unionPatterns));
+            }
+            const wherePatterns = this.createWherePatternsFromQueryData(patterns, whereQueryData.triples, whereQueryData.filters, orderQueryData.triples, orderQueryData.filters, whereQueryData.patterns ?? [], undefined, whereQueryData.binds);
+            // For ID-only queries, we need to include union patterns in graphWhere
+            // because that's what gets used in the CONSTRUCT query
+            const graphWhereRelationsPatterns = relationsQueryData.unionPatterns.length > 0
+                ? [(0, SparqlUtil_1.createSparqlUnion)(relationsQueryData.unionPatterns), ...relationsQueryData.patterns]
+                : relationsQueryData.patterns;
+            const graphWherePatterns = this.createWherePatternsFromQueryData(whereQueryData.graphValues, whereQueryData.graphTriples, whereQueryData.graphFilters, undefined, undefined, graphWhereRelationsPatterns);
+            // Create variables for each order expression and update the orders to use them
+            const selectVariables = orderQueryData.orders.map(order => {
+                const variable = this.createVariable();
+                return {
+                    variable,
+                    expression: order.expression
+                };
+            });
+            const orders = selectVariables.map((selectVar, index) => ({
+                expression: selectVar.variable,
+                descending: orderQueryData.orders[index].descending
+            }));
+            if (orders.length === 0) {
+                orders.push({
+                    expression: SparqlUtil_1.entityVariable
+                });
+            }
+            selectVariables.push(...(whereQueryData.selectVariables ?? []));
+            const isRelationsQueryDataEmpty = relationsQueryData.unionPatterns.length === 0 && relationsQueryData.patterns.length === 0 && relationsQueryData.selectionTriples.length === 0;
+            const returnData = {
+                where: wherePatterns,
+                orders,
+                ...orderQueryData.groupByParent ? { group: subject } : {},
+                graphWhere: graphWherePatterns,
+                graphSelectionTriples: relationsQueryData.selectionTriples,
+                ...isRelationsQueryDataEmpty ? {} : { relationsQueryData }
+            };
+            if (selectVariables.length > 0) {
+                returnData.selectVariables = selectVariables;
+            }
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, {
+                patternCount: wherePatterns.length,
+                tripleCount: whereQueryData.triples.length,
+                hasFilters: whereQueryData.filters.length > 0,
+                hasOrders: orders.length > 0
+            });
+            return returnData;
+        }
+        catch (error) {
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, { error: true });
+            throw error;
+        }
+    }
+    createSubQueryPatterns(subQueries) {
+        return subQueries.map((subQuery) => {
+            const subQueryWhere = this.createWhereQueryData(SparqlUtil_1.entityVariable, subQuery.where);
+            const queryGroup = [];
+            if (subQuery.groupBy && Array.isArray(subQuery.groupBy)) {
+                subQuery.groupBy.forEach((group) => {
+                    queryGroup.push({
+                        expression: data_model_1.default.variable(group)
+                    });
+                });
+            }
+            const selectQuery = {
+                type: 'query',
+                queryType: 'SELECT',
+                variables: subQuery.select,
+                where: this.createWherePatternsFromQueryData(subQueryWhere.values, subQueryWhere.triples, subQueryWhere.filters, undefined, undefined, subQueryWhere.patterns ?? []),
+                group: queryGroup.length > 0 ? queryGroup : undefined,
+                having: subQuery.having ? this.createWhereQueryData(SparqlUtil_1.entityVariable, subQuery.having).filters : undefined,
+                prefixes: {}
+            };
+            return (0, SparqlUtil_1.createSparqlSelectGroup)([selectQuery]);
+        });
+    }
+    createEntityGraphFilterPattern(subject) {
+        const entityFilterTriple = { subject, predicate: this.createVariable(), object: this.createVariable() };
+        return (0, SparqlUtil_1.createSparqlGraphPattern)(subject, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([entityFilterTriple])]);
+    }
+    buildConstructFromEntitySelectQuery(graphWhere, graphSelectionTriples, select, selectVariables) {
+        const span = PerformanceLogger_1.PerformanceLogger.startSpan('QueryBuilder.buildConstruct', { hasSelect: !!select });
+        try {
+            let triples;
+            let where = [];
+            if (select) {
+                triples = this.createSelectPattern(select, SparqlUtil_1.entityVariable);
+                where = [(0, SparqlUtil_1.createSparqlOptional)([(0, SparqlUtil_1.createSparqlBasicGraphPattern)(triples)]), ...graphWhere];
+            }
+            else {
+                triples = [SparqlUtil_1.entityGraphTriple, ...graphSelectionTriples];
+                /* Skip if the where contains a union pattern */
+                if (graphWhere.some(pattern => pattern.type === 'union')) {
+                    where = graphWhere;
+                }
+                else {
+                    where = [
+                        ...graphWhere,
+                        (0, SparqlUtil_1.createSparqlGraphPattern)(SparqlUtil_1.entityVariable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])])
+                    ];
+                }
+            }
+            // // Add select variables to the query
+            // if (selectVariables?.length) {
+            //   where = [
+            //     ...where,
+            //     ...selectVariables.map(({ variable, expression }) => ({
+            //       type: 'bind' as const,
+            //       expression,
+            //       variable,
+            //     })),
+            //   ];
+            // }
+            const result = (0, SparqlUtil_1.createSparqlConstructQuery)(triples, where);
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, { tripleCount: triples.length, patternCount: where.length });
+            return result;
+        }
+        catch (error) {
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, { error: true });
+            throw error;
+        }
+    }
+    createWhereQueryData(subject, where, isTopLevel = false) {
+        // Optimization: if the top-level where contains an ID constraint plus additional filters,
+        // also push the ID constraint into graphWhere. This allows the outer CONSTRUCT query
+        // to be restricted by VALUES (?entity) which can be substantially faster on some SPARQL backends.
+        //
+        // Non-breaking: keep the existing behavior where `id` participates in the main WHERE too.
+        if (isTopLevel && where && 'id' in where && Object.keys(where).length > 1) {
+            const { id, ...restWhere } = where;
+            if (id !== undefined) {
+                const idQueryData = this.createWhereQueryDataForIdValue(subject, id);
+                const restQueryData = this.createWhereQueryData(subject, restWhere, false);
+                return {
+                    ...restQueryData,
+                    values: [...idQueryData.values, ...restQueryData.values],
+                    filters: [...idQueryData.filters, ...restQueryData.filters],
+                    triples: [...idQueryData.triples, ...restQueryData.triples],
+                    graphValues: [...idQueryData.values, ...restQueryData.graphValues],
+                    graphFilters: [...idQueryData.filters, ...restQueryData.graphFilters],
+                    graphTriples: [...idQueryData.triples, ...restQueryData.graphTriples]
+                };
+            }
+        }
+        if (isTopLevel && Object.keys(where ?? {}).length === 1 && 'id' in where) {
+            const { values, filters, triples } = this.createWhereQueryDataForIdValue(subject, where.id);
+            return {
+                values: [],
+                filters: [],
+                triples: [],
+                graphValues: values,
+                graphFilters: filters,
+                graphTriples: triples,
+                binds: []
+            };
+        }
+        // Handle binds if specified in where options
+        const binds = [];
+        if (where?.binds) {
+            binds.push(...where.binds.map((bind) => ({
+                type: 'bind',
+                expression: bind.expression,
+                variable: bind.variable
+            })));
+            // Delete binds from where as it's a special key
+            const { binds: _, ...restWhere } = where;
+            where = restWhere;
+        }
+        const whereQueryData = Object.entries(where ?? {}).reduce((obj, [key, value]) => {
+            const whereQueryDataForField = this.createWhereQueryDataForField(subject, key, value);
+            return {
+                values: [...obj.values, ...whereQueryDataForField.values],
+                triples: [...obj.triples, ...whereQueryDataForField.triples],
+                filters: [...obj.filters, ...whereQueryDataForField.filters],
+                patterns: [...obj.patterns ?? [], ...whereQueryDataForField.patterns ?? []],
+                binds: [...obj.binds ?? [], ...whereQueryDataForField.binds ?? []]
+            };
+        }, { values: [], triples: [], filters: [], patterns: [], binds });
+        return {
+            ...whereQueryData,
+            graphValues: [],
+            graphFilters: [],
+            graphTriples: [],
+            patterns: whereQueryData.patterns ?? [],
+            binds: whereQueryData.binds ?? []
+        };
+    }
+    createWhereQueryDataForField(subject, field, value) {
+        if (field === 'id') {
+            return this.createWhereQueryDataForIdValue(subject, value);
+        }
+        if (field === 'type') {
+            return this.createWhereQueryDataForType(subject, value);
+        }
+        if (field === 'and') {
+            return this.createWhereQueryDataForAndClause(subject, value);
+        }
+        if (field === 'or') {
+            return this.createWhereQueryDataForOrClause(subject, value);
+        }
+        const predicate = data_model_1.default.namedNode(field);
+        return this.createWhereQueryDataFromKeyValue(subject, predicate, value);
+    }
+    createWhereQueryDataForAndClause(subject, whereClauses) {
+        // Combine all nested where conditions - all must match
+        return whereClauses.reduce((acc, nestedWhere) => {
+            const nestedData = this.createWhereQueryData(subject, nestedWhere);
+            return {
+                values: [...acc.values, ...nestedData.values],
+                triples: [...acc.triples, ...nestedData.triples],
+                filters: [...acc.filters, ...nestedData.filters],
+                patterns: [...acc.patterns ?? [], ...nestedData.patterns ?? []],
+                binds: [...acc.binds ?? [], ...nestedData.binds ?? []]
+            };
+        }, { values: [], triples: [], filters: [], patterns: [], binds: [] });
+    }
+    createWhereQueryDataForOrClause(subject, whereClauses) {
+        // Create UNION patterns - any condition can match
+        const unionPatterns = whereClauses.map((nestedWhere) => {
+            const nestedData = this.createWhereQueryData(subject, nestedWhere);
+            const patterns = [];
+            // Add values patterns
+            if (nestedData.values.length > 0) {
+                patterns.push(...nestedData.values);
+            }
+            // Add triples as basic graph pattern
+            if (nestedData.triples.length > 0) {
+                patterns.push((0, SparqlUtil_1.createSparqlBasicGraphPattern)(nestedData.triples));
+            }
+            // Add nested patterns (for deeply nested and/or)
+            if (nestedData.patterns && nestedData.patterns.length > 0) {
+                patterns.push(...nestedData.patterns);
+            }
+            // Add filters
+            if (nestedData.filters.length > 0) {
+                patterns.push((0, SparqlUtil_1.createFilterPatternFromFilters)(nestedData.filters));
+            }
+            // Add binds
+            if (nestedData.binds && nestedData.binds.length > 0) {
+                patterns.push(...nestedData.binds);
+            }
+            return (0, SparqlUtil_1.createSparqlSelectGroup)(patterns);
+        });
+        return {
+            values: [],
+            triples: [],
+            filters: [],
+            patterns: [(0, SparqlUtil_1.createSparqlUnion)(unionPatterns)],
+            binds: []
+        };
+    }
+    createWhereQueryDataForIdValue(term, value) {
+        let filters = [];
+        let values = [];
+        let triples = [];
+        if (FindOperator_1.FindOperator.isFindOperator(value)) {
+            ({ filters, values, triples } = this.resolveFindOperatorAsExpressionForId(term, value));
+        }
+        else {
+            values = [
+                {
+                    type: 'values',
+                    values: [
+                        {
+                            [`?${term.value}`]: data_model_1.default.namedNode(value)
+                        }
+                    ]
+                }
+            ];
+        }
+        return {
+            values,
+            filters,
+            triples
+        };
+    }
+    createWhereQueryDataForType(subject, value) {
+        if (FindOperator_1.FindOperator.isFindOperator(value)) {
+            if (value.operator === 'and') {
+                // For AND on types, generate a triple for each type
+                const typeValues = value.value;
+                // Create a triple for each value in the array, safely converting to string
+                const triples = typeValues.map((typeVal) => {
+                    const typeStr = typeof typeVal === 'string' ? typeVal : typeVal?.toString() || '';
+                    return {
+                        subject,
+                        predicate: SparqlUtil_1.allTypesAndSuperTypesPath,
+                        object: data_model_1.default.namedNode(typeStr)
+                    };
+                });
+                return {
+                    values: [],
+                    filters: [],
+                    triples: [
+                        ...triples
+                    ]
+                };
+            }
+            if (value.operator === 'inverse') {
+                const inversePredicate = (0, SparqlUtil_1.createSparqlInversePredicate)([SparqlUtil_1.allTypesAndSuperTypesPath]);
+                const inverseWhereQueryData = this.createWhereQueryDataFromKeyValue(subject, inversePredicate, value.value);
+                const variable = this.createVariable();
+                return {
+                    values: inverseWhereQueryData.values,
+                    filters: inverseWhereQueryData.filters,
+                    triples: inverseWhereQueryData.triples
+                };
+            }
+            if (value.operator === 'sequence') {
+                const sequencePredicate = (0, SparqlUtil_1.createSparqlSequencePredicate)([SparqlUtil_1.allTypesAndSuperTypesPath]);
+                return this.createWhereQueryDataFromKeyValue(subject, sequencePredicate, value.value);
+            }
+            if (Array.isArray(value)) {
+                const triples = value.map(typeVal => ({
+                    subject,
+                    predicate: SparqlUtil_1.allTypesAndSuperTypesPath,
+                    object: typeof typeVal === 'string' ? data_model_1.default.namedNode(typeVal) : data_model_1.default.namedNode(typeVal.toString())
+                }));
+                return {
+                    values: [],
+                    filters: [],
+                    triples: [
+                        ...triples
+                    ]
+                };
+            }
+            const variable = this.createVariable();
+            const triple = { subject, predicate: SparqlUtil_1.allTypesAndSuperTypesPath, object: variable };
+            const { filter, valuePattern, tripleInFilter } = this.resolveFindOperatorAsExpressionWithMultipleValues(variable, value, triple);
+            return {
+                values: valuePattern ? [valuePattern] : [],
+                filters: filter ? [filter] : [],
+                triples: tripleInFilter ? [] : [triple]
+            };
+        }
+        return {
+            values: [],
+            filters: [],
+            triples: [
+                {
+                    subject,
+                    predicate: SparqlUtil_1.allTypesAndSuperTypesPath,
+                    object: data_model_1.default.namedNode(value)
+                }
+            ]
+        };
+    }
+    createWhereQueryDataFromKeyValue(subject, predicate, value) {
+        if (Array.isArray(value) && FindOperator_1.FindOperator.isFindOperator(value[0])) {
+            return this.createWhereQueryDataForMultipleFindOperators(subject, predicate, value);
+        }
+        if (FindOperator_1.FindOperator.isFindOperator(value)) {
+            return this.createWhereQueryDataForFindOperator(subject, predicate, value);
+        }
+        if (Array.isArray(value)) {
+            return value.reduce((obj, valueItem) => {
+                const valueWhereQueryData = this.createWhereQueryDataFromKeyValue(subject, predicate, valueItem);
+                return {
+                    values: [...obj.values, ...valueWhereQueryData.values],
+                    filters: [...obj.filters, ...valueWhereQueryData.filters],
+                    triples: [...obj.triples, ...valueWhereQueryData.triples],
+                    patterns: [...obj.patterns ?? [], ...valueWhereQueryData.patterns ?? []]
+                };
+            }, { values: [], filters: [], triples: [], patterns: [] });
+        }
+        if (typeof value === 'object') {
+            if ('@value' in value) {
+                return this.createWhereQueryDataForValueObject('subject' in value ? value.subject : subject, predicate, value);
+            }
+            return this.createWhereQueryDataForNestedWhere(subject, predicate, value);
+        }
+        const term = this.resolveValueToTerm(value);
+        return {
+            values: [],
+            filters: [],
+            triples: [{ subject, predicate, object: term }]
+        };
+    }
+    createWhereQueryDataForFindOperator(subject, predicate, operator) {
+        if (operator.operator === 'inverse') {
+            const inversePredicate = (0, SparqlUtil_1.createSparqlInversePredicate)([predicate]);
+            return this.createWhereQueryDataFromKeyValue(operator.subject ? operator.subject : subject, inversePredicate, operator.value);
+        }
+        if (operator.operator === 'sequence') {
+            const sequencePredicate = (0, SparqlUtil_1.createSparqlSequencePredicate)([predicate]);
+            return this.createWhereQueryDataFromKeyValue(operator.subject ? operator.subject : subject, sequencePredicate, operator.value);
+        }
+        if (FindOperator_1.FindOperator.isPathOperator(operator)) {
+            const pathPredicate = this.pathOperatorToPropertyPath(operator);
+            const combinedPredicate = (0, SparqlUtil_1.createSparqlSequencePredicate)([predicate, pathPredicate]);
+            return this.createWhereQueryDataFromKeyValue(subject, combinedPredicate, operator.value.value);
+        }
+        const variable = this.createVariable();
+        const triple = { subject, predicate, object: variable };
+        const { filter, valuePattern, tripleInFilter } = this.resolveFindOperatorAsExpressionWithMultipleValues(variable, operator, triple);
+        return {
+            values: valuePattern ? [valuePattern] : [],
+            filters: filter ? [filter] : [],
+            triples: tripleInFilter ? [] : [triple]
+        };
+    }
+    pathOperatorToPropertyPath(operator) {
+        if (operator.operator === 'inversePath') {
+            let subPredicate;
+            const { subPath } = operator.value;
+            if (typeof subPath === 'string') {
+                subPredicate = data_model_1.default.namedNode(subPath);
+            }
+            else {
+                subPredicate = this.pathOperatorToPropertyPath(subPath);
+            }
+            return (0, SparqlUtil_1.createSparqlInversePredicate)([subPredicate]);
+        }
+        if (operator.operator === 'sequencePath') {
+            const { subPath } = operator.value;
+            const subPredicates = subPath.map((sequencePart) => {
+                if (typeof sequencePart === 'string') {
+                    return data_model_1.default.namedNode(sequencePart);
+                }
+                return this.pathOperatorToPropertyPath(sequencePart);
+            });
+            return (0, SparqlUtil_1.createSparqlSequencePredicate)(subPredicates);
+        }
+        if (operator.operator === 'zeroOrMorePath') {
+            const { subPath } = operator.value;
+            let subPredicate;
+            if (typeof subPath === 'string') {
+                subPredicate = data_model_1.default.namedNode(subPath);
+            }
+            else {
+                subPredicate = this.pathOperatorToPropertyPath(subPath);
+            }
+            return (0, SparqlUtil_1.createSparqlZeroOrMorePredicate)([subPredicate]);
+        }
+        if (operator.operator === 'oneOrMorePath') {
+            const { subPath } = operator.value;
+            let subPredicate;
+            if (typeof subPath === 'string') {
+                subPredicate = data_model_1.default.namedNode(subPath);
+            }
+            else {
+                subPredicate = this.pathOperatorToPropertyPath(subPath);
+            }
+            return (0, SparqlUtil_1.createSparqlOneOrMorePredicate)([subPredicate]);
+        }
+        throw new Error(`Operator ${operator.operator} not supported`);
+    }
+    createWhereQueryDataForMultipleFindOperators(subject, predicate, operators) {
+        const variable = this.createVariable();
+        const triple = { subject, predicate, object: variable };
+        const whereQueryData = {
+            values: [],
+            filters: [],
+            triples: [triple]
+        };
+        return operators.reduce((obj, operator) => {
+            const { filter, valuePattern } = this.resolveFindOperatorAsExpressionWithMultipleValues(variable, operator, triple);
+            if (valuePattern) {
+                obj.values.push(valuePattern);
+            }
+            if (filter) {
+                obj.filters.push(filter);
+            }
+            return obj;
+        }, whereQueryData);
+    }
+    createWhereQueryDataForNestedWhere(subject, predicate, where) {
+        const subNodeVariable = this.createVariable();
+        const subWhereQueryData = this.createWhereQueryData(subNodeVariable, where);
+        return {
+            values: [...subWhereQueryData.values, ...subWhereQueryData.graphValues],
+            filters: subWhereQueryData.filters,
+            triples: [{ subject, predicate, object: subNodeVariable }, ...subWhereQueryData.triples],
+            patterns: [...subWhereQueryData.patterns ?? []]
+        };
+    }
+    createWhereQueryDataForValueObject(subject, predicate, valueObject) {
+        const term = this.valueObjectToTerm(valueObject);
+        if (valueObject.isOptional) {
+            return {
+                values: [],
+                filters: [],
+                triples: [],
+                patterns: [(0, SparqlUtil_1.createSparqlOptional)([(0, SparqlUtil_1.createSparqlBasicGraphPattern)([{ subject, predicate, object: term }])])]
+            };
+        }
+        return {
+            values: [],
+            filters: [],
+            triples: [{ subject, predicate, object: term }]
+        };
+    }
+    valueObjectToTerm(valueObject) {
+        let typeOrLanguage;
+        let value;
+        if ('@type' in valueObject && valueObject['@type'] === '@json') {
+            typeOrLanguage = Vocabularies_1.RDF.JSON;
+            value = JSON.stringify(valueObject['@value']);
+        }
+        else {
+            typeOrLanguage = ('@type' in valueObject ? valueObject['@type'] : valueObject['@language']);
+            value = valueObject['@value'].toString();
+        }
+        return (0, TripleUtil_1.valueToLiteral)(value, typeOrLanguage);
+    }
+    resolveFindOperatorAsExpressionWithMultipleValues(leftSide, operator, triple, dontUseValuePattern = false) {
+        if (operator.operator === 'and') {
+            // For AND operators, we'll create an AND filter with multiple equality comparisons
+            const values = operator.value;
+            if (values.length === 0) {
+                // No conditions to add
+                return {};
+            }
+            if (values.length === 1) {
+                // If only one value, treat as equality
+                return {
+                    filter: (0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, this.resolveValueToExpression(values[0]))
+                };
+            }
+            // Create individual equality conditions for each value
+            const equalityConditions = values.map(val => (0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, this.resolveValueToExpression(val)));
+            // Combine with AND operation
+            return {
+                filter: {
+                    type: 'operation',
+                    operator: '&&',
+                    args: equalityConditions
+                }
+            };
+        }
+        if (operator.operator === 'in') {
+            const resolvedValue = this.resolveValueToExpression(operator.value);
+            if (Array.isArray(resolvedValue) && !dontUseValuePattern) {
+                return {
+                    valuePattern: {
+                        type: 'values',
+                        values: resolvedValue.map((value) => ({ [`?${leftSide.value}`]: value }))
+                    }
+                };
+            }
+            return {
+                filter: (0, SparqlUtil_1.createSparqlInOperation)(leftSide, resolvedValue)
+            };
+        }
+        if (operator.operator === 'not') {
+            const resolvedExpression = this.resolveValueToExpression(operator.value);
+            return {
+                filter: this.buildNotOperationForMultiValued(leftSide, resolvedExpression, triple),
+                tripleInFilter: true
+            };
+        }
+        if (operator.operator === 'exists') {
+            return {
+                filter: (0, SparqlUtil_1.createSparqlExistsOperation)([(0, SparqlUtil_1.createSparqlBasicGraphPattern)([triple])]),
+                tripleInFilter: true
+            };
+        }
+        if (operator.operator === 'contains') {
+            const searchString = this.resolveValueToExpression(operator.value);
+            const filter = (0, SparqlUtil_1.createSparqlContainsOperation)(
+            // Directly use the variable as an expression
+            (0, SparqlUtil_1.createSparqlLcaseOperation)(data_model_1.default.variable(leftSide.value)), (0, SparqlUtil_1.createSparqlLcaseOperation)(data_model_1.default.literal(searchString.value.toLowerCase())));
+            return {
+                filter
+            };
+        }
+        const resolvedExpression = this.resolveValueToExpression(operator.value);
+        switch (operator.operator) {
+            case 'equal':
+                return { filter: (0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, resolvedExpression) };
+            case 'gt':
+                return { filter: (0, SparqlUtil_1.createSparqlGtOperation)(leftSide, resolvedExpression) };
+            case 'gte':
+                return { filter: (0, SparqlUtil_1.createSparqlGteOperation)(leftSide, resolvedExpression) };
+            case 'lt':
+                return { filter: (0, SparqlUtil_1.createSparqlLtOperation)(leftSide, resolvedExpression) };
+            case 'lte':
+                return { filter: (0, SparqlUtil_1.createSparqlLteOperation)(leftSide, resolvedExpression) };
+            default:
+                throw new Error(`Unsupported operator "${operator.operator}"`);
+        }
+    }
+    resolveFindOperatorAsExpressionForId(leftSide, operator) {
+        switch (operator.operator) {
+            case 'inversePath': {
+                const predicate = this.pathOperatorToPropertyPath(operator);
+                return this.createWhereQueryDataFromKeyValue(leftSide, predicate, operator.value.value);
+            }
+            case 'in': {
+                const resolvedValue = this.resolveValueToExpression(operator.value);
+                return {
+                    triples: [],
+                    filters: [],
+                    values: [
+                        {
+                            type: 'values',
+                            values: resolvedValue.map((value) => ({ [`?${leftSide.value}`]: value }))
+                        }
+                    ]
+                };
+            }
+            case 'not':
+                return {
+                    triples: [],
+                    values: [],
+                    filters: [
+                        this.buildNotOperationForId(leftSide, this.resolveValueToExpression(operator.value))
+                    ]
+                };
+            case 'equal':
+                return {
+                    triples: [],
+                    values: [],
+                    filters: [(0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, this.resolveValueToExpression(operator.value))]
+                };
+            default:
+                throw new Error(`Unsupported operator "${operator.operator}"`);
+        }
+    }
+    resolveValueToExpression(value) {
+        if (FindOperator_1.FindOperator.isFindOperator(value)) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((valueItem) => this.resolveValueToTerm(valueItem));
+        }
+        return this.resolveValueToTerm(value);
+    }
+    buildNotOperationForMultiValued(leftSide, rightSide, triple) {
+        let filterExpression;
+        const isFindOperator = FindOperator_1.FindOperator.isFindOperator(rightSide);
+        if (isFindOperator && rightSide.operator === 'exists') {
+            return (0, SparqlUtil_1.createSparqlNotExistsOperation)([(0, SparqlUtil_1.createSparqlBasicGraphPattern)([triple])]);
+        }
+        if (isFindOperator) {
+            let expression;
+            try {
+                ({ filter: expression } = this.resolveFindOperatorAsExpressionWithMultipleValues(leftSide, rightSide, triple, true));
+            }
+            catch {
+                throw new Error(`Unsupported Not sub operator "${rightSide.operator}"`);
+            }
+            filterExpression = (0, SparqlUtil_1.createSparqlFilterWithExpression)(expression);
+        }
+        else {
+            filterExpression = (0, SparqlUtil_1.createSparqlFilterWithExpression)((0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, rightSide));
+        }
+        return (0, SparqlUtil_1.createSparqlNotExistsOperation)([
+            (0, SparqlUtil_1.createSparqlSelectGroup)([(0, SparqlUtil_1.createSparqlBasicGraphPattern)([triple]), filterExpression])
+        ]);
+    }
+    buildNotOperationForId(leftSide, rightSide) {
+        if (FindOperator_1.FindOperator.isFindOperator(rightSide)) {
+            const resolvedValue = this.resolveValueToExpression(rightSide.value);
+            switch (rightSide.operator) {
+                case 'in':
+                    return (0, SparqlUtil_1.createSparqlNotInOperation)(leftSide, resolvedValue);
+                case 'equal':
+                    return (0, SparqlUtil_1.createSparqlNotEqualOperation)(leftSide, resolvedValue);
+                default:
+                    throw new Error(`Unsupported Not sub operator "${rightSide.operator}"`);
+            }
+        }
+        return (0, SparqlUtil_1.createSparqlNotEqualOperation)(leftSide, rightSide);
+    }
+    resolveValueToTerm(value) {
+        if (typeof value === 'object' && '@value' in value) {
+            return (0, TripleUtil_1.valueToLiteral)(value['@value'], '@type' in value ? value['@type'] : undefined);
+        }
+        if ((0, Util_1.isUrl)(value)) {
+            return data_model_1.default.namedNode(value);
+        }
+        return (0, TripleUtil_1.valueToLiteral)(value);
+    }
+    createOrderQueryData(subject, order, isNested = false) {
+        if (!order) {
+            // Default is descending by id
+            return { triples: [], orders: [], filters: [] };
+        }
+        return Object.entries(order).reduce((obj, [property, orderValue]) => {
+            const orderQueryData = this.createOrderQueryDataForProperty(subject, property, orderValue, isNested);
+            obj.orders = [...obj.orders, ...orderQueryData.orders];
+            obj.triples = [...obj.triples, ...orderQueryData.triples];
+            obj.filters = [...obj.filters, ...orderQueryData.filters];
+            obj.groupByParent = obj.groupByParent ?? orderQueryData.groupByParent;
+            return obj;
+        }, { triples: [], orders: [], filters: [] });
+    }
+    createOrderQueryDataForProperty(subject, property, orderValue, isNested = false) {
+        const predicate = data_model_1.default.namedNode(property);
+        if (FindOperator_1.FindOperator.isFindOperator(orderValue)) {
+            const variable = this.createVariable();
+            const inverseRelationTriple = {
+                subject,
+                predicate: (0, SparqlUtil_1.createSparqlInversePredicate)([predicate]),
+                object: variable
+            };
+            const subRelationOperatorValue = orderValue
+                .value;
+            const subRelationOrderQueryData = this.createOrderQueryData(variable, subRelationOperatorValue.order, true);
+            const subRelationWhereQueryData = this.createWhereQueryData(variable, subRelationOperatorValue.where);
+            // Create aggregate expressions for each order, but don't nest aggregates
+            const aggregateOrders = subRelationOrderQueryData.orders.map(order => {
+                const baseExpression = 'type' in order.expression && order.expression.type === 'aggregate'
+                    ? order.expression.expression
+                    : order.expression;
+                // Create the aggregate expression first
+                const aggregateExpression = {
+                    type: 'aggregate',
+                    expression: baseExpression,
+                    aggregation: order.descending ? 'max' : 'min'
+                };
+                return {
+                    expression: aggregateExpression,
+                    descending: order.descending
+                };
+            });
+            return {
+                triples: [inverseRelationTriple, ...subRelationOrderQueryData.triples, ...subRelationWhereQueryData.triples],
+                filters: subRelationWhereQueryData.filters,
+                orders: aggregateOrders,
+                groupByParent: true,
+                patterns: [...subRelationWhereQueryData.patterns ?? [], ...subRelationOrderQueryData.patterns ?? []]
+            };
+        }
+        if (property === 'id') {
+            return {
+                triples: [],
+                filters: [],
+                orders: [
+                    {
+                        expression: subject,
+                        descending: orderValue === 'DESC' || orderValue === 'desc'
+                    }
+                ]
+            };
+        }
+        const variable = this.createVariable();
+        const isDescending = orderValue === 'DESC' || orderValue === 'desc';
+        return {
+            triples: [{ subject, predicate, object: variable }],
+            filters: [],
+            orders: [
+                {
+                    expression: isNested
+                        ? {
+                            type: 'aggregate',
+                            expression: variable,
+                            aggregation: isDescending ? 'max' : 'min'
+                        }
+                        : variable,
+                    descending: isDescending
+                }
+            ]
+        };
+    }
+    createRelationsQueryData(subject, relations) {
+        if (!relations) {
+            return { patterns: [], selectionTriples: [], unionPatterns: [] };
+        }
+        const response = Object.entries(relations).reduce((obj, [property, relationsValue]) => {
+            const predicate = data_model_1.default.namedNode(property);
+            if (typeof relationsValue === 'object') {
+                if (FindOperator_1.FindOperator.isFindOperator(relationsValue)) {
+                    const { patterns, selectionTriples, unionPatterns } = this.createRelationsQueryDataForInverseRelation(subject, predicate, relationsValue);
+                    return {
+                        patterns: [...obj.patterns, ...patterns],
+                        selectionTriples: [...obj.selectionTriples, ...selectionTriples],
+                        unionPatterns: [...obj.unionPatterns ?? [], ...unionPatterns ?? []]
+                    };
+                }
+                const { patterns, selectionTriples, unionPatterns } = this.createRelationsQueryDataForNestedRelation(subject, predicate, relationsValue);
+                return {
+                    patterns: [...obj.patterns, ...patterns],
+                    selectionTriples: [...obj.selectionTriples, ...selectionTriples],
+                    unionPatterns: [
+                        ...obj.unionPatterns ?? [],
+                        ...unionPatterns ?? []
+                    ]
+                };
+            }
+            const variable = this.createVariable();
+            const relationPattern = (0, SparqlUtil_1.createSparqlSelectGroup)([
+                (0, SparqlUtil_1.createSparqlBasicGraphPattern)([{ subject, predicate, object: variable }]),
+                (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])])
+            ]);
+            return {
+                unionPatterns: [...obj.unionPatterns ?? [], relationPattern],
+                patterns: [...obj.patterns],
+                selectionTriples: [...obj.selectionTriples]
+            };
+        }, { patterns: [], selectionTriples: [], unionPatterns: [] });
+        return {
+            patterns: [...response?.patterns ?? []],
+            selectionTriples: [...response?.selectionTriples ?? []],
+            unionPatterns: [...response?.unionPatterns ?? []]
+        };
+    }
+    createRelationsQueryDataForInverseRelation(subject, predicate, relationsValue) {
+        const variable = this.createVariable();
+        const inverseRelationTriple = {
+            subject,
+            predicate: (0, SparqlUtil_1.createSparqlInversePredicate)([predicate]),
+            object: variable
+        };
+        if (typeof relationsValue.value === 'object' && relationsValue.value.relations) {
+            const subRelationsQueryData = this.createRelationsQueryData(variable, relationsValue.value.relations);
+            const unionPatterns = [];
+            unionPatterns.push((0, SparqlUtil_1.createSparqlSelectGroup)([
+                (0, SparqlUtil_1.createSparqlBasicGraphPattern)([inverseRelationTriple]),
+                (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])])
+            ]));
+            for (const subRelationUnionPattern of subRelationsQueryData.unionPatterns) {
+                unionPatterns.push((0, SparqlUtil_1.createSparqlSelectGroup)([
+                    (0, SparqlUtil_1.createSparqlBasicGraphPattern)([inverseRelationTriple]),
+                    ...subRelationUnionPattern.type === 'group'
+                        ? subRelationUnionPattern.patterns
+                        : [subRelationUnionPattern]
+                ]));
+            }
+            return {
+                patterns: [],
+                selectionTriples: [...subRelationsQueryData.selectionTriples],
+                unionPatterns
+            };
+        }
+        const unionPatterns = [];
+        unionPatterns.push((0, SparqlUtil_1.createSparqlSelectGroup)([
+            (0, SparqlUtil_1.createSparqlBasicGraphPattern)([inverseRelationTriple]),
+            (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])])
+        ]));
+        return {
+            patterns: [],
+            selectionTriples: [],
+            unionPatterns
+        };
+    }
+    createRelationsQueryDataForNestedRelation(subject, predicate, relationsValue) {
+        const variable = this.createVariable();
+        const relationTriple = { subject, predicate, object: variable };
+        const unionPatterns = [];
+        const subRelationsQueryData = this.createRelationsQueryData(variable, relationsValue);
+        // subRelationsQueryData.patterns.push(createSparqlBasicGraphPattern([ relationTriple ]));
+        // unionPatterns.push(...subRelationsQueryData.patterns);
+        // unionPatterns.push(
+        //   createSparqlGraphPattern(variable, [ createSparqlBasicGraphPattern([ entityGraphTriple ]) ])
+        // );
+        /* const relationPattern = subRelationsQueryData.patterns.length > 0
+          ? createSparqlSelectGroup([
+            ...patterns,
+            ...subRelationsQueryData.patterns,
+            ...subRelationsQueryData.unionPatterns
+          ])
+          : undefined; */
+        /* We always need to include the first level of the property in the union patterns */
+        unionPatterns.push((0, SparqlUtil_1.createSparqlSelectGroup)([
+            (0, SparqlUtil_1.createSparqlBasicGraphPattern)([relationTriple]),
+            (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])])
+        ]));
+        for (const subRelationUnionPattern of subRelationsQueryData.unionPatterns) {
+            unionPatterns.push((0, SparqlUtil_1.createSparqlSelectGroup)([
+                (0, SparqlUtil_1.createSparqlBasicGraphPattern)([relationTriple]),
+                ...subRelationUnionPattern.type === 'group' ? subRelationUnionPattern.patterns : [subRelationUnionPattern]
+            ]));
+        }
+        return {
+            patterns: [],
+            selectionTriples: [...subRelationsQueryData.selectionTriples],
+            unionPatterns
+        };
+    }
+    createVariable() {
+        return data_model_1.default.variable(this.variableGenerator.getNext());
+    }
+    createSelectPattern(select, subject) {
+        if (Array.isArray(select)) {
+            return select.map((selectPredicate) => ({
+                subject,
+                predicate: data_model_1.default.namedNode(selectPredicate),
+                object: this.createVariable()
+            }));
+        }
+        return Object.entries(select).reduce((arr, [key, value]) => {
+            const variable = this.createVariable();
+            arr.push({ subject, predicate: data_model_1.default.namedNode(key), object: variable });
+            if (typeof value === 'object') {
+                arr = [...arr, ...this.createSelectPattern(value, variable)];
+            }
+            return arr;
+        }, []);
+    }
+    createWherePatternsFromQueryData(initialPatterns, triples, filters, orderTriples, orderFilters, additionalPatterns, serviceTriples, binds) {
+        let patterns = initialPatterns;
+        // Add binds at the beginning if they exist
+        if (binds && binds.length > 0) {
+            patterns = [...patterns, ...binds];
+        }
+        if (triples.length > 0) {
+            patterns.push((0, SparqlUtil_1.createSparqlBasicGraphPattern)(triples));
+        }
+        if (orderTriples && orderTriples.length > 0) {
+            const optionalPatterns = [(0, SparqlUtil_1.createSparqlBasicGraphPattern)(orderTriples)];
+            if (orderFilters && orderFilters.length > 0) {
+                optionalPatterns.push((0, SparqlUtil_1.createFilterPatternFromFilters)(orderFilters));
+            }
+            patterns.push((0, SparqlUtil_1.createSparqlOptional)(optionalPatterns));
+        }
+        if (filters.length > 0) {
+            patterns.push((0, SparqlUtil_1.createFilterPatternFromFilters)(filters));
+        }
+        if (serviceTriples) {
+            for (const [service, sTriples] of Object.entries(serviceTriples)) {
+                patterns.unshift((0, SparqlUtil_1.createSparqlServicePattern)(service, sTriples));
+            }
+        }
+        if (additionalPatterns) {
+            patterns = [...patterns, ...additionalPatterns];
+        }
+        return patterns;
+    }
+    createGroupPatternForPath(entityVariable, path) {
+        const segments = path.split('~');
+        let currentSubject = entityVariable;
+        const patterns = [];
+        // Create a chain of patterns for each segment
+        segments.forEach((predicate, index) => {
+            const object = this.createVariable();
+            patterns.push({
+                type: 'bgp',
+                triples: [
+                    {
+                        subject: currentSubject,
+                        predicate: data_model_1.default.namedNode(predicate),
+                        object
+                    }
+                ]
+            });
+            currentSubject = object;
+        });
+        // Return the final variable (last object) and all patterns
+        return {
+            variable: currentSubject,
+            patterns
+        };
+    }
+    async buildGroupByQuery(options) {
+        const span = PerformanceLogger_1.PerformanceLogger.startSpan('QueryBuilder.buildGroupBy', {
+            hasGroupBy: !!options.groupBy,
+            hasDateRange: !!options.dateRange
+        });
+        try {
+            const entityVariable = data_model_1.default.variable('entity');
+            const queryData = this.buildEntitySelectPatternsFromOptions(entityVariable, {
+                where: options.where || {}
+            });
+            // Add group variables and patterns with mapping
+            const groupVariables = [];
+            const groupPatterns = [];
+            const variableMapping = {};
+            if (options.groupBy) {
+                options.groupBy.forEach(path => {
+                    const { variable: groupVar, patterns } = this.createGroupPatternForPath(entityVariable, path);
+                    groupVariables.push(groupVar);
+                    variableMapping[groupVar.value] = path;
+                    groupPatterns.push(...patterns);
+                });
+            }
+            // Add date handling if specified
+            if (options.dateRange) {
+                const dateVar = this.createVariable();
+                variableMapping[dateVar.value] = 'date';
+                const datePattern = {
+                    type: 'bgp',
+                    triples: [
+                        {
+                            subject: entityVariable,
+                            predicate: data_model_1.default.namedNode(constants_1.EngineConstants.prop.dateCreated),
+                            object: dateVar
+                        }
+                    ]
+                };
+                const dateFilter = {
+                    type: 'filter',
+                    expression: {
+                        type: 'operation',
+                        operator: '&&',
+                        args: [
+                            {
+                                type: 'operation',
+                                operator: '>=',
+                                args: [dateVar, data_model_1.default.literal(options.dateRange.start, constants_1.XSD.dateTime)]
+                            },
+                            {
+                                type: 'operation',
+                                operator: '<=',
+                                args: [dateVar, data_model_1.default.literal(options.dateRange.end, constants_1.XSD.dateTime)]
+                            }
+                        ]
+                    }
+                };
+                groupPatterns.push(datePattern, dateFilter);
+                if (options.dateGrouping) {
+                    const dateGroupVar = this.createVariable();
+                    groupVariables.push(dateGroupVar);
+                    variableMapping[dateGroupVar.value] = 'dateGroup';
+                    const dateGroupBind = this.createDateGroupingBind(dateVar, dateGroupVar, options.dateGrouping);
+                    groupPatterns.push(dateGroupBind);
+                }
+            }
+            // Create count and entityIds variables
+            const countVar = this.createVariable();
+            const entityIdsVar = this.createVariable();
+            variableMapping[countVar.value] = 'count';
+            variableMapping[entityIdsVar.value] = 'entityIds';
+            // Combine all patterns
+            const combinedWhere = [...queryData.where, ...groupPatterns];
+            // Create select query with aggregations
+            const selectQuery = (0, SparqlUtil_1.createSparqlSelectQuery)([
+                ...groupVariables,
+                {
+                    expression: {
+                        type: 'aggregate',
+                        aggregation: 'count',
+                        distinct: true,
+                        expression: entityVariable
+                    },
+                    variable: countVar
+                },
+                {
+                    expression: {
+                        type: 'aggregate',
+                        aggregation: 'group_concat',
+                        distinct: true,
+                        separator: ' ',
+                        expression: entityVariable
+                    },
+                    variable: entityIdsVar
+                }
+            ], combinedWhere, [], // Orders
+            groupVariables.length > 0 ? groupVariables : undefined, // Group by
+            options.limit, options.offset);
+            const result = { query: selectQuery, variableMapping };
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, {
+                groupCount: groupVariables.length,
+                hasDateGrouping: !!options.dateGrouping
+            });
+            return result;
+        }
+        catch (error) {
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, { error: true });
+            throw error;
+        }
+    }
+    // Helper function for date grouping
+    createDateGroupingBind(dateVar, dateGroupVar, grouping) {
+        return {
+            type: 'bind',
+            expression: {
+                type: 'operation',
+                operator: 'CONCAT',
+                args: [
+                    this.createYearExpression(dateVar),
+                    data_model_1.default.literal('-'),
+                    this.createMonthExpression(dateVar),
+                    ...this.createDayExpressionParts(dateVar, grouping)
+                ]
+            },
+            variable: dateGroupVar
+        };
+    }
+    createYearExpression(dateVar) {
+        return {
+            type: 'operation',
+            operator: 'STR',
+            args: [
+                {
+                    type: 'operation',
+                    operator: 'YEAR',
+                    args: [dateVar]
+                }
+            ]
+        };
+    }
+    createMonthExpression(dateVar) {
+        return this.createPaddedDatePartExpression(dateVar, 'MONTH');
+    }
+    createDayExpression(dateVar) {
+        return this.createPaddedDatePartExpression(dateVar, 'DAY');
+    }
+    createPaddedDatePartExpression(dateVar, datePart) {
+        const comparisonValue = data_model_1.default.literal('10', constants_1.XSD.integer);
+        return {
+            type: 'operation',
+            operator: 'IF',
+            args: [
+                this.createLessThanComparison(dateVar, datePart, comparisonValue),
+                this.createPaddedStringExpression(dateVar, datePart),
+                this.createUnpaddedStringExpression(dateVar, datePart)
+            ]
+        };
+    }
+    createLessThanComparison(dateVar, datePart, comparisonValue) {
+        return {
+            type: 'operation',
+            operator: '<',
+            args: [
+                {
+                    type: 'operation',
+                    operator: datePart,
+                    args: [dateVar]
+                },
+                comparisonValue
+            ]
+        };
+    }
+    createPaddedStringExpression(dateVar, datePart) {
+        return {
+            type: 'operation',
+            operator: 'CONCAT',
+            args: [data_model_1.default.literal('0'), this.createUnpaddedStringExpression(dateVar, datePart)]
+        };
+    }
+    createUnpaddedStringExpression(dateVar, datePart) {
+        return {
+            type: 'operation',
+            operator: 'STR',
+            args: [
+                {
+                    type: 'operation',
+                    operator: datePart,
+                    args: [dateVar]
+                }
+            ]
+        };
+    }
+    createDayExpressionParts(dateVar, grouping) {
+        if (grouping === 'day') {
+            return [data_model_1.default.literal('-'), this.createDayExpression(dateVar)];
+        }
+        return [data_model_1.default.literal('')];
+    }
+}
+exports.SparqlQueryBuilder = SparqlQueryBuilder;
+//# sourceMappingURL=SparqlQueryBuilder.js.map