@comake/skl-js-engine 1.3.7 → 1.3.9

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

@@ -14,6 +14,7 @@ exports.SparqlQueryBuilder = void 0;
 /* 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");
@@ -25,81 +26,96 @@ class SparqlQueryBuilder {
         this.variableGenerator = new VariableGenerator_1.VariableGenerator();
     }
     buildEntitySelectPatternsFromOptions(subject, options) {
-        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 ]) ])
-                ); */
+        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);
             }
-            else {
+            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);
-                // patterns.push(createSparqlGraphPattern(subject, [ createSparqlBasicGraphPattern([ entityGraphTriple ]) ]));
-                patterns.push(entityGraphFilterPattern);
+                const entityIsGraphFilter = (0, SparqlUtil_1.createSparqlExistsOperation)([entityGraphFilterPattern]);
+                whereQueryData.filters.push(entityIsGraphFilter);
             }
-        }
-        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
+            // 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 }
             };
-        });
-        const orders = selectVariables.map((selectVar, index) => ({
-            expression: selectVar.variable,
-            descending: orderQueryData.orders[index].descending
-        }));
-        if (orders.length > 0) {
-            orders.push({
-                expression: SparqlUtil_1.entityVariable
+            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;
         }
-        selectVariables.push(...(whereQueryData.selectVariables ?? []));
-        // eslint-disable-next-line max-len
-        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;
+        catch (error) {
+            PerformanceLogger_1.PerformanceLogger.endSpan(span, { error: true });
+            throw error;
         }
-        return returnData;
     }
     createSubQueryPatterns(subQueries) {
         return subQueries.map((subQuery) => {
@@ -129,37 +145,46 @@ class SparqlQueryBuilder {
         return (0, SparqlUtil_1.createSparqlGraphPattern)(subject, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([entityFilterTriple])]);
     }
     buildConstructFromEntitySelectQuery(graphWhere, graphSelectionTriples, select, selectVariables) {
-        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;
+        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 {
-                where = [
-                    ...graphWhere,
-                    (0, SparqlUtil_1.createSparqlGraphPattern)(SparqlUtil_1.entityVariable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])])
-                ];
+                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;
         }
-        // // Add select variables to the query
-        // if (selectVariables?.length) {
-        //   where = [
-        //     ...where,
-        //     ...selectVariables.map(({ variable, expression }) => ({
-        //       type: 'bind' as const,
-        //       expression,
-        //       variable,
-        //     })),
-        //   ];
-        // }
-        return (0, SparqlUtil_1.createSparqlConstructQuery)(triples, where);
     }
     createWhereQueryData(subject, where, isTopLevel = false) {
         if (isTopLevel && Object.keys(where ?? {}).length === 1 && 'id' in where) {
@@ -655,7 +680,8 @@ class SparqlQueryBuilder {
     }
     createOrderQueryData(subject, order, isNested = false) {
         if (!order) {
-            return { triples: [], orders: [], filters: [] };
+            // Default is descending by id
+            return { triples: [], orders: [{ expression: subject, descending: true }], filters: [] };
         }
         return Object.entries(order).reduce((obj, [property, orderValue]) => {
             const orderQueryData = this.createOrderQueryDataForProperty(subject, property, orderValue, isNested);
@@ -924,97 +950,112 @@ class SparqlQueryBuilder {
         };
     }
     async buildGroupByQuery(options) {
-        const entityVariable = data_model_1.default.variable('entity');
-        const queryData = this.buildEntitySelectPatternsFromOptions(entityVariable, {
-            where: options.where || {}
+        const span = PerformanceLogger_1.PerformanceLogger.startSpan('QueryBuilder.buildGroupBy', {
+            hasGroupBy: !!options.groupBy,
+            hasDateRange: !!options.dateRange
         });
-        // 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);
+        try {
+            const entityVariable = data_model_1.default.variable('entity');
+            const queryData = this.buildEntitySelectPatternsFromOptions(entityVariable, {
+                where: options.where || {}
             });
-        }
-        // 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)]
-                        },
+            // 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: [
                         {
-                            type: 'operation',
-                            operator: '<=',
-                            args: [dateVar, data_model_1.default.literal(options.dateRange.end, constants_1.XSD.dateTime)]
+                            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);
                 }
-            };
-            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
+            // 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
                 },
-                variable: entityIdsVar
-            }
-        ], combinedWhere, [], // Orders
-        groupVariables.length > 0 ? groupVariables : undefined, // Group by
-        options.limit, options.offset);
-        return { query: selectQuery, variableMapping };
+                {
+                    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) {