bunsane 0.2.4 → 0.2.7

package/query/ComponentInclusionNode.ts

@@ -3,7 +3,33 @@ import type { QueryResult } from "./QueryNode";
 import { QueryContext } from "./QueryContext";
 import { shouldUseLateralJoins, shouldUseDirectPartition } from "../core/Config";
 import { FilterBuilderRegistry } from "./FilterBuilderRegistry";
-import {ComponentRegistry} from "../core/components";
+import { ComponentRegistry } from "../core/components";
+import { getMetadataStorage } from "../core/metadata";
+
+/**
+ * Check if a component property is numeric based on metadata
+ * Used to apply proper casting in ORDER BY clauses for index usage
+ */
+function isNumericProperty(componentName: string, propertyName: string): boolean {
+    const storage = getMetadataStorage();
+    const typeId = storage.getComponentId(componentName);
+
+    // Check indexed fields first (most reliable)
+    const indexedFields = storage.getIndexedFields(typeId);
+    const indexedField = indexedFields.find(f => f.propertyKey === propertyName);
+    if (indexedField?.indexType === 'numeric') {
+        return true;
+    }
+
+    // Check property metadata for Number type
+    const props = storage.getComponentProperties(typeId);
+    const prop = props.find(p => p.propertyKey === propertyName);
+    if (prop?.propertyType === Number) {
+        return true;
+    }
+
+    return false;
+}
 
 export class ComponentInclusionNode extends QueryNode {
     private getComponentTableName(compId: string): string {
@@ -108,7 +134,10 @@ export class ComponentInclusionNode extends QueryNode {
             }
 
             // Apply component filters for single component (normal path)
-            sql = this.applyComponentFilters(context, componentIds, useCTE, useLateralJoins, lateralJoins, lateralConditions, sql, new Map());
+            // For single component, alias is 'ec' (or CTE name if using CTE)
+            // Single component queries have WHERE from the initial select, so pass true
+            const singleCompHasWhere = sql.includes(' WHERE ');
+            sql = this.applyComponentFilters(context, componentIds, useCTE, useLateralJoins, lateralJoins, lateralConditions, sql, new Map(), useCTE ? context.cteName : "ec", singleCompHasWhere);
 
             // Apply sorting with component data joins if sortOrders are specified
             if (hasSortOrders) {
@@ -145,17 +174,11 @@ export class ComponentInclusionNode extends QueryNode {
             // Multiple components case
             // Create parameter indices for component IDs to avoid duplicates
             const componentParamIndices: Map<string, number> = new Map();
-            const componentPlaceholders = componentIds.map((id) => {
-                if (!componentParamIndices.has(id)) {
-                    componentParamIndices.set(id, context.addParam(id));
-                }
-                return `$${componentParamIndices.get(id)}::text`;
-            }).join(', ');
-            
+
             if (useCTE) {
                 // Use CTE for base entity filtering
                 sql = `SELECT DISTINCT ${context.cteName}.entity_id as id FROM ${context.cteName}`;
-                
+
                 // Ensure all required components are present
                 sql += ` WHERE (`;
                 const componentChecks = componentIds.map(compId => {
@@ -171,57 +194,77 @@ export class ComponentInclusionNode extends QueryNode {
                 });
                 sql += componentChecks.join(' AND ') + `)`;
             } else {
-                sql = `SELECT DISTINCT ec.entity_id as id FROM entity_components ec WHERE ec.type_id IN (${componentPlaceholders}) AND ec.deleted_at IS NULL`;
+                // Use INTERSECT for multi-component queries (much faster than GROUP BY + HAVING)
+                // INTERSECT lets PostgreSQL use index scans independently on each component type
+                // then merge the results efficiently with a hash or merge join
+                const intersectQueries = componentIds.map((compId) => {
+                    if (!componentParamIndices.has(compId)) {
+                        componentParamIndices.set(compId, context.addParam(compId));
+                    }
+                    return `SELECT ec.entity_id FROM entity_components ec WHERE ec.type_id = $${componentParamIndices.get(compId)}::text AND ec.deleted_at IS NULL`;
+                });
+                sql = `SELECT intersected.entity_id as id FROM (${intersectQueries.join(' INTERSECT ')}) AS intersected`;
             }
 
+            // For INTERSECT queries, the alias is 'intersected', not 'ec'
+            const multiCompAlias = useCTE ? context.cteName : "intersected";
+
+            // Track if outer query has WHERE clause (don't count WHERE inside INTERSECT subqueries)
+            // For INTERSECT queries, the outer query starts without WHERE
+            let outerHasWhere = useCTE && sql.indexOf('WHERE', sql.lastIndexOf('FROM')) > -1;
+
             if (context.withId) {
-                const tableAlias = useCTE ? context.cteName : "ec";
-                const whereKeyword = sql.includes('WHERE') ? 'AND' : 'WHERE';
-                sql += ` ${whereKeyword} ${tableAlias}.entity_id = $${context.addParam(context.withId)}`;
+                const whereKeyword = outerHasWhere ? 'AND' : 'WHERE';
+                sql += ` ${whereKeyword} ${multiCompAlias}.entity_id = $${context.addParam(context.withId)}`;
+                outerHasWhere = true;
             }
 
             // Add exclusions
             if (excludedIds.length > 0) {
-                const tableAlias = useCTE ? context.cteName : "ec";
-                const whereKeyword = sql.includes('WHERE') ? 'AND' : 'WHERE';
+                const whereKeyword = outerHasWhere ? 'AND' : 'WHERE';
                 const excludedPlaceholders = excludedIds.map((id) => `$${context.addParam(id)}`).join(', ');
                 sql += ` ${whereKeyword} NOT EXISTS (
                     SELECT 1 FROM entity_components ec_ex
-                    WHERE ec_ex.entity_id = ${tableAlias}.entity_id
+                    WHERE ec_ex.entity_id = ${multiCompAlias}.entity_id
                     AND ec_ex.type_id IN (${excludedPlaceholders})
                     AND ec_ex.deleted_at IS NULL
                 )`;
+                outerHasWhere = true;
             }
 
             // Add entity exclusions
             if (context.excludedEntityIds.size > 0) {
-                const tableAlias = useCTE ? context.cteName : "ec";
-                const whereKeyword = sql.includes('WHERE') ? 'AND' : 'WHERE';
+                const whereKeyword = outerHasWhere ? 'AND' : 'WHERE';
                 const entityExcludedIds = Array.from(context.excludedEntityIds);
                 const entityPlaceholders = entityExcludedIds.map((id) => `$${context.addParam(id)}`).join(', ');
-                sql += ` ${whereKeyword} ${tableAlias}.entity_id NOT IN (${entityPlaceholders})`;
+                sql += ` ${whereKeyword} ${multiCompAlias}.entity_id NOT IN (${entityPlaceholders})`;
+                outerHasWhere = true;
             }
 
             // Apply component filters for multiple components
-            sql = this.applyComponentFilters(context, componentIds, useCTE, useLateralJoins, lateralJoins, lateralConditions, sql, componentParamIndices);
+            // For INTERSECT queries, alias is 'intersected'; for CTE, use cteName
+            // Pass outerHasWhere to correctly track WHERE clause in outer query (not in INTERSECT subqueries)
+            const filterResult = this.applyComponentFiltersWithState(context, componentIds, useCTE, useLateralJoins, lateralJoins, lateralConditions, sql, componentParamIndices, multiCompAlias, outerHasWhere);
+            sql = filterResult.sql;
+            outerHasWhere = filterResult.hasWhere;
+
+            // Note: GROUP BY HAVING removed - INTERSECT already ensures all components are present
 
-            if (!useCTE) {
-                sql += ` GROUP BY ec.entity_id HAVING COUNT(DISTINCT ec.type_id) = $${context.addParam(componentCount)}`;
-            }
-            
             // Apply sorting with component data joins if sortOrders are specified
             if (hasSortOrders) {
                 sql = this.applySortingWithComponentJoins(sql, context);
             } else {
                 // Default: order by entity_id
-                const tableAlias = useCTE ? context.cteName : "ec";
-                const idColumn = useCTE ? `${context.cteName}.entity_id` : `${tableAlias}.entity_id`;
+                // For INTERSECT queries, use 'intersected' alias; for CTE, use cteName
+                const idColumn = `${multiCompAlias}.entity_id`;
 
                 // Apply cursor-based pagination if cursor is set (more efficient than OFFSET)
                 if (context.cursorId !== null && !context.paginationAppliedInCTE) {
                     const operator = context.cursorDirection === 'after' ? '>' : '<';
-                    const whereKeyword = sql.includes('WHERE') ? 'AND' : 'WHERE';
+                    // Use tracked WHERE state for INTERSECT queries
+                    const whereKeyword = outerHasWhere ? 'AND' : 'WHERE';
                     sql += ` ${whereKeyword} ${idColumn} ${operator} $${context.addParam(context.cursorId)}`;
+                    outerHasWhere = true;
                 }
 
                 // Order direction depends on cursor direction
@@ -266,44 +309,48 @@ export class ComponentInclusionNode extends QueryNode {
             if (singlePass) return singlePass;
         }
 
-        // Wrap the base query as a subquery to get entity ids
-        let sql = `SELECT base_entities.id FROM (${baseQuery}) AS base_entities`;
-        
-        // Build LEFT JOINs for each sort order to access component data
-        const sortJoins: string[] = [];
+        // Use scalar subquery approach for sorting to avoid cartesian product explosion
+        // This forces PostgreSQL to evaluate the sort expression for each entity row,
+        // rather than joining all component rows first and filtering later.
+        // This is dramatically faster when base_entities is a small subset of total entities.
         const orderByClauses: string[] = [];
-        
+
         for (let i = 0; i < context.sortOrders.length; i++) {
             const sortOrder = context.sortOrders[i]!;
-            const sortAlias = `sort_${i}`;
-            const compAlias = `comp_${i}`;
-            
+
             // Get the component type ID for this sort order
             const typeId = ComponentRegistry.getComponentId(sortOrder.component);
             if (!typeId) {
                 continue; // Skip if component not registered
             }
-            
-            // LEFT JOIN to entity_components and components to get the sort data
+
             const sortComponentTableName = this.getComponentTableName(typeId);
-            sortJoins.push(`
-                LEFT JOIN entity_components ${sortAlias}
-                    ON ${sortAlias}.entity_id = base_entities.id
-                    AND ${sortAlias}.type_id = $${context.addParam(typeId)}::text
-                    AND ${sortAlias}.deleted_at IS NULL
-                LEFT JOIN ${sortComponentTableName} ${compAlias}
-                    ON ${compAlias}.id = ${sortAlias}.component_id
-                    AND ${compAlias}.deleted_at IS NULL`);
-            
-            // Build ORDER BY clause for this sort order
-            // Access the property from JSONB data
             const nullsClause = sortOrder.nullsFirst ? 'NULLS FIRST' : 'NULLS LAST';
-            orderByClauses.push(`${compAlias}.data->>'${sortOrder.property}' ${sortOrder.direction} ${nullsClause}`);
+            const isNumeric = isNumericProperty(sortOrder.component, sortOrder.property);
+
+            // Build scalar subquery to get sort value for each entity
+            // This avoids nested loop join by forcing row-by-row evaluation
+            const sortExpr = isNumeric
+                ? `(sort_c.data->>'${sortOrder.property}')::numeric`
+                : `sort_c.data->>'${sortOrder.property}'`;
+
+            const subquery = `(
+                SELECT ${sortExpr}
+                FROM entity_components sort_ec
+                JOIN ${sortComponentTableName} sort_c ON sort_c.id = sort_ec.component_id
+                WHERE sort_ec.entity_id = base_entities.id
+                AND sort_ec.type_id = $${context.addParam(typeId)}::text
+                AND sort_ec.deleted_at IS NULL
+                AND sort_c.deleted_at IS NULL
+                LIMIT 1
+            )`;
+
+            orderByClauses.push(`${subquery} ${sortOrder.direction} ${nullsClause}`);
         }
-        
-        // Combine joins
-        sql += sortJoins.join('');
-        
+
+        // Wrap the base query as a subquery to get entity ids
+        let sql = `SELECT base_entities.id FROM (${baseQuery}) AS base_entities`;
+
         // Add ORDER BY clause
         if (orderByClauses.length > 0) {
             sql += ` ORDER BY ${orderByClauses.join(', ')}`;
@@ -311,7 +358,7 @@ export class ComponentInclusionNode extends QueryNode {
             // Fallback to entity id if no valid sort orders
             sql += ` ORDER BY base_entities.id`;
         }
-        
+
         // Add LIMIT and OFFSET only if not already applied in CTE
         // When pagination is applied at CTE level, skip it here to avoid double pagination
         if (!context.paginationAppliedInCTE) {
@@ -334,10 +381,17 @@ export class ComponentInclusionNode extends QueryNode {
      *
      * This is dramatically faster because PostgreSQL can use indexes to find
      * the top N matching rows directly instead of finding ALL matches first.
+     *
+     * NOTE: This optimization cannot be used when multiple component types are required,
+     * because it only queries one component table and would miss the join requirement.
      */
     private applySinglePassFilterSort(context: QueryContext): string | null {
         if (context.sortOrders.length !== 1) return null;
 
+        // Can't use single-pass when multiple components are required
+        // (we need to ensure entities have ALL required components)
+        if (context.componentIds.size > 1) return null;
+
         const sortOrder = context.sortOrders[0]!;
         const sortTypeId = ComponentRegistry.getComponentId(sortOrder.component);
         if (!sortTypeId) return null;
@@ -392,6 +446,10 @@ export class ComponentInclusionNode extends QueryNode {
         }
 
         const nullsClause = sortOrder.nullsFirst ? 'NULLS FIRST' : 'NULLS LAST';
+        const isNumeric = isNumericProperty(sortOrder.component, sortOrder.property);
+        const sortExpr = isNumeric
+            ? `(c.data->>'${sortOrder.property}')::numeric`
+            : `c.data->>'${sortOrder.property}'`;
 
         let sql: string;
         if (useDirectPartition) {
@@ -401,7 +459,7 @@ export class ComponentInclusionNode extends QueryNode {
                 WHERE c.type_id = $${context.addParam(sortTypeId)}::text
                 AND c.deleted_at IS NULL
                 AND ${filterConditions.join(' AND ')}
-                ORDER BY c.data->>'${sortOrder.property}' ${sortOrder.direction} ${nullsClause}`;
+                ORDER BY ${sortExpr} ${sortOrder.direction} ${nullsClause}`;
         } else {
             // Use entity_components junction
             // No DISTINCT needed since each entity has one component of this type
@@ -410,7 +468,7 @@ export class ComponentInclusionNode extends QueryNode {
                 WHERE ec.type_id = $${context.addParam(sortTypeId)}::text
                 AND ec.deleted_at IS NULL
                 AND ${filterConditions.join(' AND ')}
-                ORDER BY c.data->>'${sortOrder.property}' ${sortOrder.direction} ${nullsClause}`;
+                ORDER BY ${sortExpr} ${sortOrder.direction} ${nullsClause}`;
         }
 
         // Add pagination
@@ -427,29 +485,41 @@ export class ComponentInclusionNode extends QueryNode {
     }
 
     /**
-     * Optimized sorting for direct partition access
-     * Queries the partition table directly without going through entity_components for the sort join
+     * Optimized sorting for direct partition access.
+     * Uses scalar subquery to avoid cartesian product explosion when sorting.
+     * Queries the partition table directly without going through entity_components.
      */
     private applySortingOptimized(baseQuery: string, context: QueryContext): string | null {
         if (context.sortOrders.length !== 1) return null;
-        
+
         const sortOrder = context.sortOrders[0]!;
         const typeId = ComponentRegistry.getComponentId(sortOrder.component);
         if (!typeId) return null;
-        
+
         const partitionTable = ComponentRegistry.getPartitionTableName(typeId);
         if (!partitionTable) return null;
-        
+
         const nullsClause = sortOrder.nullsFirst ? 'NULLS FIRST' : 'NULLS LAST';
-        
-        // Optimized query: Direct join to partition table, skip entity_components for sort
-        // This is faster because we go directly to the partition table
+        const isNumeric = isNumericProperty(sortOrder.component, sortOrder.property);
+        const sortExpr = isNumeric
+            ? `(sort_c.data->>'${sortOrder.property}')::numeric`
+            : `sort_c.data->>'${sortOrder.property}'`;
+
+        // Use scalar subquery to avoid cartesian product explosion
+        // This forces PostgreSQL to evaluate sort value per-entity, preventing
+        // the nested loop join that scans all component rows before filtering
+        const sortSubquery = `(
+            SELECT ${sortExpr}
+            FROM ${partitionTable} sort_c
+            WHERE sort_c.entity_id = base.id
+            AND sort_c.type_id = $${context.addParam(typeId)}::text
+            AND sort_c.deleted_at IS NULL
+            LIMIT 1
+        )`;
+
         let sql = `SELECT base.id FROM (${baseQuery}) AS base
-            JOIN ${partitionTable} c ON c.entity_id = base.id 
-                AND c.type_id = $${context.addParam(typeId)}::text 
-                AND c.deleted_at IS NULL
-            ORDER BY c.data->>'${sortOrder.property}' ${sortOrder.direction} ${nullsClause}`;
-        
+            ORDER BY ${sortSubquery} ${sortOrder.direction} ${nullsClause}`;
+
         // Add LIMIT and OFFSET only if not already applied in CTE
         // When pagination is applied at CTE level, skip it here to avoid double pagination
         if (!context.paginationAppliedInCTE) {
@@ -467,6 +537,7 @@ export class ComponentInclusionNode extends QueryNode {
 
     /**
      * Apply component filters using either EXISTS subqueries or LATERAL joins
+     * Wrapper that returns just the SQL string for backward compatibility
      */
     private applyComponentFilters(
         context: QueryContext,
@@ -476,8 +547,34 @@ export class ComponentInclusionNode extends QueryNode {
         lateralJoins: string[],
         lateralConditions: string[],
         sql: string,
-        componentParamIndices: Map<string, number>
+        componentParamIndices: Map<string, number>,
+        entityTableAlias?: string,
+        outerHasWhere: boolean = false
     ): string {
+        return this.applyComponentFiltersWithState(context, componentIds, useCTE, useLateralJoins, lateralJoins, lateralConditions, sql, componentParamIndices, entityTableAlias, outerHasWhere).sql;
+    }
+
+    /**
+     * Apply component filters using either EXISTS subqueries or LATERAL joins
+     * Returns both SQL and updated WHERE state for proper tracking
+     * @param entityTableAlias - The alias for the entity table (e.g., 'ec', 'intersected', or CTE name)
+     * @param outerHasWhere - Track if outer query already has WHERE clause (for INTERSECT queries)
+     */
+    private applyComponentFiltersWithState(
+        context: QueryContext,
+        componentIds: string[],
+        useCTE: boolean,
+        useLateralJoins: boolean,
+        lateralJoins: string[],
+        lateralConditions: string[],
+        sql: string,
+        componentParamIndices: Map<string, number>,
+        entityTableAlias?: string,
+        outerHasWhere: boolean = false
+    ): { sql: string; hasWhere: boolean } {
+        // Track whether we've added WHERE to the outer query
+        let hasOuterWhere = outerHasWhere;
+
         for (const [compId, filters] of context.componentFilters) {
             for (const filter of filters) {
                 let condition: string;
@@ -500,20 +597,11 @@ export class ComponentInclusionNode extends QueryNode {
                     if (filter.value === '' || (typeof filter.value === 'string' && filter.value.trim() === '')) {
                         throw new Error(`Filter value for field "${filter.field}" is an empty string. This would cause PostgreSQL UUID parsing errors.`);
                     }
-                    
+
                     // Check if value looks like a UUID (case-insensitive, with or without hyphens)
                     const valueStr = String(filter.value);
                     const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(valueStr);
-                    
-                    // Debug logging
-                    // console.log('[ComponentInclusionNode] Filter:', { 
-                    //     field: filter.field, 
-                    //     operator: filter.operator, 
-                    //     value: filter.value,
-                    //     valueStr,
-                    //     isUUID 
-                    // });
-                    
+
                     // Build JSON path for nested fields (e.g., "device.unique_id" -> "c.data->'device'->>'unique_id'")
                     let jsonPath: string;
                     if (filter.field.includes('.')) {
@@ -524,7 +612,7 @@ export class ComponentInclusionNode extends QueryNode {
                     } else {
                         jsonPath = `c.data->>'${filter.field}'`;
                     }
-                    
+
                     if (isUUID && filter.operator === '=') {
                         // UUID equality comparison - only cast the parameter, compare as text
                         // This allows matching UUID parameter against both UUID and text fields
@@ -550,12 +638,12 @@ export class ComponentInclusionNode extends QueryNode {
                         // Default: text comparison without casting
                         condition = `${jsonPath} ${filter.operator} $${context.addParam(filter.value)}`;
                     }
-                    
-                    // console.log('[ComponentInclusionNode] Condition:', condition);
                 }
-                
-                const tableAlias = useCTE ? context.cteName : "ec";
-                const whereKeyword = sql.includes('WHERE') ? 'AND' : 'WHERE';
+
+                // Use provided alias, or fall back to CTE name or 'ec'
+                const tableAlias = entityTableAlias || (useCTE ? context.cteName : "ec");
+                // Use tracked WHERE state instead of sql.includes() to handle INTERSECT correctly
+                const whereKeyword = hasOuterWhere ? 'AND' : 'WHERE';
 
                 if (useLateralJoins) {
                     // Use LATERAL join approach
@@ -600,7 +688,7 @@ export class ComponentInclusionNode extends QueryNode {
                     // Use traditional EXISTS subquery
                     const componentTableName = this.getComponentTableName(compId);
                     const useDirectPartition = shouldUseDirectPartition() && componentTableName !== 'components';
-                    
+
                     if (useDirectPartition) {
                         // Direct partition access - query partition table directly by entity_id
                         sql += ` ${whereKeyword} EXISTS (
@@ -622,6 +710,8 @@ export class ComponentInclusionNode extends QueryNode {
                         AND c.deleted_at IS NULL
                     )`;
                     }
+                    // Mark that we've added WHERE to the outer query
+                    hasOuterWhere = true;
                 }
             }
         }
@@ -680,7 +770,7 @@ export class ComponentInclusionNode extends QueryNode {
             }
         }
 
-        return sql;
+        return { sql, hasWhere: hasOuterWhere };
     }
 
     public getNodeType(): string {

package/query/Query.ts

@@ -1,7 +1,7 @@
 import {ComponentRegistry , type BaseComponent, type ComponentDataType } from "../core/components";
 import { Entity } from "../core/Entity";
 import { logger } from "../core/Logger";
-import db from "../database";
+import db, { QUERY_TIMEOUT_MS } from "../database";
 import { timed } from "../core/Decorators";
 import { inList } from "../database/sqlHelpers";
 import { QueryContext, QueryDAG, SourceNode, ComponentInclusionNode } from "./index";
@@ -299,8 +299,8 @@ class Query<TComponents extends readonly ComponentConstructor[] = []> {
         return new Promise<number>((resolve, reject) => {
             const timeout = setTimeout(() => {
                 logger.error(`Query count execution timeout`);
-                reject(new Error(`Query count execution timeout after 30 seconds`));
-            }, 30000);
+                reject(new Error(`Query count execution timeout after ${QUERY_TIMEOUT_MS / 1000} seconds`));
+            }, QUERY_TIMEOUT_MS);
             this.doCount()
                 .then(result => {
                     clearTimeout(timeout);
@@ -455,8 +455,8 @@ class Query<TComponents extends readonly ComponentConstructor[] = []> {
         return new Promise<number>((resolve, reject) => {
             const timeout = setTimeout(() => {
                 logger.error(`Query sum execution timeout`);
-                reject(new Error(`Query sum execution timeout after 30 seconds`));
-            }, 30000);
+                reject(new Error(`Query sum execution timeout after ${QUERY_TIMEOUT_MS / 1000} seconds`));
+            }, QUERY_TIMEOUT_MS);
             this.doAggregate('SUM', componentCtor, field as string)
                 .then(result => {
                     clearTimeout(timeout);
@@ -483,8 +483,8 @@ class Query<TComponents extends readonly ComponentConstructor[] = []> {
         return new Promise<number>((resolve, reject) => {
             const timeout = setTimeout(() => {
                 logger.error(`Query average execution timeout`);
-                reject(new Error(`Query average execution timeout after 30 seconds`));
-            }, 30000);
+                reject(new Error(`Query average execution timeout after ${QUERY_TIMEOUT_MS / 1000} seconds`));
+            }, QUERY_TIMEOUT_MS);
             this.doAggregate('AVG', componentCtor, field as string)
                 .then(result => {
                     clearTimeout(timeout);
@@ -641,8 +641,8 @@ AND c.deleted_at IS NULL`;
             // Add timeout to prevent hanging queries
             const timeout = setTimeout(() => {
                 logger.error(`Query execution timeout`);
-                reject(new Error(`Query execution timeout after 30 seconds`));
-            }, 30000); // 30 second timeout
+                reject(new Error(`Query execution timeout after ${QUERY_TIMEOUT_MS / 1000} seconds`));
+            }, QUERY_TIMEOUT_MS); // 30 second timeout
 
             this.doExec()
                 .then(result => {