leangraph 1.0.1 → 1.1.1

package/dist/executor.js

@@ -59,12 +59,16 @@ function createEmptyContext() {
 /**
  * Clone a phase context
  */
-function cloneContext(ctx) {
+/**
+ * Clone a phase context with optimized row cloning
+ * For read-only operations, we can avoid the expensive row cloning
+ */
+function cloneContext(ctx, cloneRows = true) {
     return {
         nodeIds: new Map(ctx.nodeIds),
         edgeIds: new Map(ctx.edgeIds),
         values: new Map(ctx.values),
-        rows: ctx.rows.map(row => new Map(row)),
+        rows: cloneRows ? ctx.rows.map(row => new Map(row)) : ctx.rows,
     };
 }
 // ============================================================================
@@ -72,14 +76,113 @@ function cloneContext(ctx) {
 // ============================================================================
 export class Executor {
     db;
+    propertyCache = new Map();
+    edgePropertyCache = new Map();
+    // Cache for full edge info (type, source_id, target_id) - populated by batchGetEdgeInfo
+    edgeInfoCache = new Map();
     constructor(db) {
         this.db = db;
     }
+    /**
+     * Get node properties from cache or parse from JSON string and cache them
+     */
+    getNodeProperties(nodeId, propsJson) {
+        let props = this.propertyCache.get(nodeId);
+        if (!props) {
+            props = typeof propsJson === "string" ? JSON.parse(propsJson) : propsJson;
+            if (props && typeof props === "object" && !Array.isArray(props)) {
+                this.propertyCache.set(nodeId, props);
+            }
+            else {
+                // Fallback for invalid data
+                props = {};
+            }
+        }
+        return props || {};
+    }
+    /**
+     * Get edge properties from cache or parse from JSON string and cache them
+     */
+    getEdgeProperties(edgeId, propsJson) {
+        let props = this.edgePropertyCache.get(edgeId);
+        if (!props) {
+            props = typeof propsJson === "string" ? JSON.parse(propsJson) : propsJson;
+            if (props && typeof props === "object" && !Array.isArray(props)) {
+                this.edgePropertyCache.set(edgeId, props);
+            }
+            else {
+                // Fallback for invalid data
+                props = {};
+            }
+        }
+        return props || {};
+    }
+    /**
+     * Invalidate cached properties for a node or edge after it has been updated
+     */
+    invalidatePropertyCache(id) {
+        this.propertyCache.delete(id);
+        this.edgePropertyCache.delete(id);
+    }
+    /**
+     * Extract edge ID from various representations (object with _nf_id/id, JSON string, or raw ID)
+     */
+    extractEdgeId(rel) {
+        if (typeof rel === "object" && rel !== null) {
+            const relObj = rel;
+            return (relObj._nf_id || relObj.id);
+        }
+        else if (typeof rel === "string") {
+            try {
+                const parsed = JSON.parse(rel);
+                if (typeof parsed === "object" && parsed !== null) {
+                    return (parsed._nf_id || parsed.id);
+                }
+            }
+            catch {
+                // Not JSON, assume it's a raw ID
+                return rel;
+            }
+        }
+        return null;
+    }
+    /**
+     * Batch fetch edge info for multiple edge IDs in a single query
+     * Returns a Map from edge ID to edge info (id, type, source_id, target_id, properties)
+     */
+    batchGetEdgeInfo(edgeIds) {
+        const result = new Map();
+        if (edgeIds.length === 0)
+            return result;
+        // Batch query with IN clause
+        const placeholders = edgeIds.map(() => '?').join(',');
+        const queryResult = this.db.execute(`SELECT id, type, source_id, target_id, properties FROM edges WHERE id IN (${placeholders})`, edgeIds);
+        for (const row of queryResult.rows) {
+            const id = row.id;
+            const type = row.type;
+            const source_id = row.source_id;
+            const target_id = row.target_id;
+            result.set(id, {
+                id,
+                type,
+                source_id,
+                target_id,
+                properties: this.getEdgeProperties(id, row.properties)
+            });
+            // Also populate edge info cache for type()/startNode()/endNode() lookups
+            this.edgeInfoCache.set(id, { type, source_id, target_id });
+        }
+        return result;
+    }
     /**
      * Execute a Cypher query and return formatted results
      */
     execute(cypher, params = {}) {
         const startTime = performance.now();
+        // Clear property caches at start of each query execution
+        this.propertyCache.clear();
+        this.edgePropertyCache.clear();
+        this.edgeInfoCache.clear();
         try {
             // 1. Parse the Cypher query
             const parseResult = parse(cypher);
@@ -94,124 +197,94 @@ export class Executor {
                     },
                 };
             }
-            // 2. Try phase-based execution for complex multi-phase queries
-            const phasedResult = this.tryPhasedExecution(parseResult.query, params);
-            if (phasedResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: phasedResult,
-                    meta: {
-                        count: phasedResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
-            }
-            // 2.1. Check for UNWIND with CREATE pattern (needs special handling)
-            const unwindCreateResult = this.tryUnwindCreateExecution(parseResult.query, params);
-            if (unwindCreateResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: unwindCreateResult,
-                    meta: {
-                        count: unwindCreateResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
-            }
-            // 2.2. Check for UNWIND with MERGE pattern (needs special handling)
-            const unwindMergeResult = this.tryUnwindMergeExecution(parseResult.query, params);
-            if (unwindMergeResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: unwindMergeResult,
-                    meta: {
-                        count: unwindMergeResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
-            }
-            // 2.3. Check for MATCH+WITH(COLLECT)+UNWIND+RETURN pattern (needs subquery for aggregates)
-            const collectUnwindResult = this.tryCollectUnwindExecution(parseResult.query, params);
-            if (collectUnwindResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: collectUnwindResult,
-                    meta: {
-                        count: collectUnwindResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
+            // 2. Classify query with single-pass and dispatch to appropriate handler
+            const { pattern, flags } = this.classifyQuery(parseResult.query);
+            // 3. Run semantic validations only when relevant clauses are present
+            //    (avoids extra iteration overhead for simple queries)
+            if (flags.hasMerge) {
+                this.validateMergeVariables(parseResult.query);
             }
-            // 2.4. Check for MATCH+WITH(COLLECT)+DELETE[expr] pattern
-            const collectDeleteResult = this.tryCollectDeleteExecution(parseResult.query, params);
-            if (collectDeleteResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: collectDeleteResult,
-                    meta: {
-                        count: collectDeleteResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
+            if (flags.hasSet) {
+                this.validateSetClauseValueVariables(parseResult.query, params);
             }
-            // 2.5. Check for CREATE...RETURN pattern (needs special handling)
-            const createReturnResult = this.tryCreateReturnExecution(parseResult.query, params);
-            if (createReturnResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: createReturnResult,
-                    meta: {
-                        count: createReturnResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
+            if (flags.hasWith || flags.hasReturn) {
+                this.validateOrderByVariables(parseResult.query, params);
             }
-            // 2.5. Check for MERGE with ON CREATE SET / ON MATCH SET (needs special handling)
-            const mergeResult = this.tryMergeExecution(parseResult.query, params);
-            if (mergeResult !== null) {
+            // Helper to return successful result
+            const makeResult = (data) => {
                 const endTime = performance.now();
                 return {
                     success: true,
-                    data: mergeResult,
+                    data,
                     meta: {
-                        count: mergeResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
-            }
-            // 2.6. Check for MATCH...WITH...MATCH pattern with bound relationship list
-            // e.g., MATCH ()-[r1]->()-[r2]->() WITH [r1, r2] AS rs MATCH (a)-[rs*]->(b) RETURN a, b
-            const boundRelListResult = this.tryBoundRelationshipListExecution(parseResult.query, params);
-            if (boundRelListResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: boundRelListResult,
-                    meta: {
-                        count: boundRelListResult.length,
-                        time_ms: Math.round((endTime - startTime) * 100) / 100,
-                    },
-                };
-            }
-            // 3. Check if this is a pattern that needs multi-phase execution
-            // (MATCH...CREATE, MATCH...SET, MATCH...DELETE with relationship patterns)
-            const multiPhaseResult = this.tryMultiPhaseExecution(parseResult.query, params);
-            if (multiPhaseResult !== null) {
-                const endTime = performance.now();
-                return {
-                    success: true,
-                    data: multiPhaseResult,
-                    meta: {
-                        count: multiPhaseResult.length,
+                        count: data.length,
                         time_ms: Math.round((endTime - startTime) * 100) / 100,
                     },
                 };
+            };
+            // Dispatch based on pattern (each try* method still validates and may return null)
+            switch (pattern) {
+                case "PHASED": {
+                    const result = this.tryPhasedExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "UNWIND_CREATE": {
+                    const result = this.tryUnwindCreateExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "UNWIND_MERGE": {
+                    const result = this.tryUnwindMergeExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "COLLECT_UNWIND": {
+                    const result = this.tryCollectUnwindExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "COLLECT_DELETE": {
+                    const result = this.tryCollectDeleteExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "CREATE_RETURN": {
+                    const result = this.tryCreateReturnExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "BOUND_REL_LIST": {
+                    const result = this.tryBoundRelationshipListExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "MERGE": {
+                    const result = this.tryMergeExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "MULTI_PHASE": {
+                    const result = this.tryMultiPhaseExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                case "FOREACH": {
+                    const result = this.tryForeachExecution(parseResult.query, params);
+                    if (result !== null)
+                        return makeResult(result);
+                    break;
+                }
+                // STANDARD falls through to SQL translation below
             }
             // 3. Standard single-phase execution: Translate to SQL
             const translator = new Translator(params);
@@ -250,6 +323,300 @@ export class Executor {
         }
     }
     // ============================================================================
+    // Query Classification (Single-Pass)
+    // ============================================================================
+    /**
+     * Single-pass query classifier - scans clauses once to determine execution pattern
+     *
+     * This replaces the sequential try*Execution() calls that each scanned all clauses.
+     * By doing one pass and collecting all needed flags, we avoid O(n*m) complexity
+     * where n is number of clauses and m is number of try* methods.
+     */
+    classifyQuery(query) {
+        const flags = {
+            // Clause presence
+            hasMatch: false,
+            hasOptionalMatch: false,
+            hasCreate: false,
+            hasMerge: false,
+            hasSet: false,
+            hasDelete: false,
+            hasUnwind: false,
+            hasWith: false,
+            hasReturn: false,
+            hasForeach: false,
+            // Detailed flags
+            mergeHasSetClauses: false,
+            mergeHasRelationshipPattern: false,
+            mergeHasPathExpressions: false,
+            withHasCollect: false,
+            matchHasRelationshipPattern: false,
+            hasMutations: false,
+            // Counts
+            mergeCount: 0,
+            withCount: 0,
+            matchCount: 0,
+            // Pre-categorized clauses
+            matchClauses: [],
+            createClauses: [],
+            mergeClauses: [],
+            setClauses: [],
+            deleteClauses: [],
+            withClauses: [],
+            unwindClauses: [],
+            returnClause: null,
+            // Merge details
+            firstMergeClause: null,
+            // WITH COLLECT detection
+            singleWithCollectAlias: null,
+            // Bound list detection
+            boundListVar: null,
+            boundListExprVars: [],
+        };
+        // Single pass through all clauses
+        for (const clause of query.clauses) {
+            switch (clause.type) {
+                case "MATCH":
+                    flags.hasMatch = true;
+                    flags.matchCount++;
+                    flags.matchClauses.push(clause);
+                    // Check for relationship patterns
+                    if (clause.patterns.some(p => this.isRelationshipPattern(p))) {
+                        flags.matchHasRelationshipPattern = true;
+                    }
+                    break;
+                case "OPTIONAL_MATCH":
+                    flags.hasOptionalMatch = true;
+                    flags.matchCount++;
+                    // OPTIONAL_MATCH is stored as MatchClause with isOptional flag
+                    flags.matchClauses.push(clause);
+                    break;
+                case "CREATE":
+                    flags.hasCreate = true;
+                    flags.createClauses.push(clause);
+                    break;
+                case "MERGE": {
+                    flags.hasMerge = true;
+                    flags.mergeCount++;
+                    flags.mergeClauses.push(clause);
+                    if (!flags.firstMergeClause) {
+                        flags.firstMergeClause = clause;
+                    }
+                    // Check for ON CREATE SET / ON MATCH SET
+                    if (clause.onCreateSet || clause.onMatchSet) {
+                        flags.mergeHasSetClauses = true;
+                    }
+                    // Check for relationship patterns
+                    if (clause.patterns.some(p => this.isRelationshipPattern(p))) {
+                        flags.mergeHasRelationshipPattern = true;
+                    }
+                    // Check for path expressions
+                    if (clause.pathExpressions && clause.pathExpressions.length > 0) {
+                        flags.mergeHasPathExpressions = true;
+                    }
+                    break;
+                }
+                case "SET":
+                    flags.hasSet = true;
+                    flags.setClauses.push(clause);
+                    break;
+                case "DELETE":
+                    flags.hasDelete = true;
+                    flags.deleteClauses.push(clause);
+                    break;
+                case "UNWIND":
+                    flags.hasUnwind = true;
+                    flags.unwindClauses.push(clause);
+                    break;
+                case "WITH": {
+                    flags.hasWith = true;
+                    flags.withCount++;
+                    flags.withClauses.push(clause);
+                    // Check for COLLECT function
+                    if (clause.items.length === 1) {
+                        const item = clause.items[0];
+                        if (item.expression.type === "function" &&
+                            item.expression.functionName?.toUpperCase() === "COLLECT" &&
+                            item.alias) {
+                            flags.withHasCollect = true;
+                            flags.singleWithCollectAlias = item.alias;
+                        }
+                    }
+                    // Check for list literal pattern [r1, r2] for bound relationship list detection
+                    for (const item of clause.items) {
+                        if (item.alias && item.expression.type === "function" &&
+                            item.expression.functionName === "LIST" && item.expression.args) {
+                            flags.boundListVar = item.alias;
+                            flags.boundListExprVars = [];
+                            for (const elem of item.expression.args) {
+                                if (elem.type === "variable" && elem.variable) {
+                                    flags.boundListExprVars.push(elem.variable);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+                case "RETURN":
+                    flags.hasReturn = true;
+                    flags.returnClause = clause;
+                    break;
+                case "FOREACH":
+                    flags.hasForeach = true;
+                    break;
+            }
+        }
+        // Derived flags
+        flags.hasMutations = flags.hasCreate || flags.hasSet || flags.hasDelete;
+        // Determine pattern using the collected flags
+        const pattern = this.determineQueryPattern(query, flags);
+        return { pattern, flags };
+    }
+    /**
+     * Determine execution pattern from collected flags
+     * Order matters - patterns are checked in priority order
+     */
+    determineQueryPattern(query, flags) {
+        // 0. FOREACH - Queries with FOREACH clause (checked first, high priority)
+        if (flags.hasForeach) {
+            return "FOREACH";
+        }
+        // 1. PHASED - Complex multi-phase queries with phase boundaries
+        const phases = this.detectPhases(query);
+        const needsMergePhasedExecution = (flags.hasMatch || flags.hasCreate) &&
+            flags.hasMerge &&
+            !flags.mergeHasSetClauses;
+        const needsCreateWithPhasedExecution = flags.hasCreate && flags.hasWith && !flags.hasMatch;
+        if (phases.length > 1 || needsMergePhasedExecution || needsCreateWithPhasedExecution) {
+            return "PHASED";
+        }
+        // 2. UNWIND_CREATE - UNWIND + CREATE without MATCH
+        if (flags.hasUnwind && flags.hasCreate && !flags.hasMatch) {
+            return "UNWIND_CREATE";
+        }
+        // 3. UNWIND_MERGE - UNWIND + MERGE without MATCH or CREATE
+        if (flags.hasUnwind && flags.hasMerge && !flags.hasMatch && !flags.hasCreate) {
+            return "UNWIND_MERGE";
+        }
+        // 4. COLLECT_UNWIND - MATCH + WITH(COLLECT) + UNWIND + RETURN
+        if (flags.hasMatch && flags.withHasCollect && flags.hasUnwind && flags.hasReturn) {
+            // Additional validation: WITH must have exactly one COLLECT item
+            // and UNWIND must reference the COLLECT alias
+            const lastUnwind = flags.unwindClauses[flags.unwindClauses.length - 1];
+            if (lastUnwind &&
+                lastUnwind.expression.type === "variable" &&
+                lastUnwind.expression.variable === flags.singleWithCollectAlias) {
+                return "COLLECT_UNWIND";
+            }
+        }
+        // 5. COLLECT_DELETE - MATCH + WITH(COLLECT) + DELETE
+        if (flags.hasMatch && flags.withHasCollect && flags.hasDelete &&
+            flags.deleteClauses[0]?.expressions && flags.deleteClauses[0].expressions.length > 0) {
+            return "COLLECT_DELETE";
+        }
+        // 6. CREATE_RETURN - CREATE + RETURN without MATCH or MERGE
+        if (flags.hasCreate && flags.hasReturn && !flags.hasMatch && !flags.hasMerge) {
+            return "CREATE_RETURN";
+        }
+        // 7. BOUND_REL_LIST - MATCH + WITH + MATCH with bound list pattern
+        if (flags.matchCount >= 2 && flags.hasWith && flags.boundListVar &&
+            flags.boundListExprVars.length > 0 && flags.hasReturn) {
+            return "BOUND_REL_LIST";
+        }
+        // 8. MERGE - MERGE with special handling needs
+        if (flags.hasMerge) {
+            const hasSpecialMerge = flags.mergeHasRelationshipPattern ||
+                flags.mergeHasSetClauses ||
+                flags.mergeHasPathExpressions ||
+                flags.hasReturn ||
+                flags.mergeCount > 1;
+            if (hasSpecialMerge) {
+                return "MERGE";
+            }
+        }
+        // 10. MULTI_PHASE - MATCH with mutations (CREATE/SET/DELETE)
+        if (flags.hasMatch && flags.hasMutations) {
+            return "MULTI_PHASE";
+        }
+        // 10. UNWIND + MATCH where MATCH references UNWIND variables
+        // This handles: UNWIND list AS x MATCH (n {prop: x}) RETURN n
+        // The MATCH property constraints reference UNWIND variables
+        if (flags.hasUnwind && flags.hasMatch) {
+            const unwindAliases = new Set();
+            for (const clause of query.clauses) {
+                if (clause.type === "UNWIND") {
+                    unwindAliases.add(clause.alias);
+                }
+            }
+            // Check if any MATCH pattern references UNWIND variables
+            for (const clause of query.clauses) {
+                if (clause.type === "MATCH" || clause.type === "OPTIONAL_MATCH") {
+                    for (const pattern of clause.patterns) {
+                        if (this.patternReferencesVariables(pattern, unwindAliases)) {
+                            return "PHASED";
+                        }
+                    }
+                }
+            }
+        }
+        // 11. STANDARD - Default SQL translation
+        return "STANDARD";
+    }
+    /**
+     * Check if a pattern references any of the given variables
+     */
+    patternReferencesVariables(pattern, variables) {
+        // Check if this is a relationship pattern
+        if ('source' in pattern && 'edge' in pattern && 'target' in pattern) {
+            const relPattern = pattern;
+            return this.nodePropertiesReferenceVariables(relPattern.source, variables) ||
+                this.nodePropertiesReferenceVariables(relPattern.target, variables) ||
+                this.edgePropertiesReferenceVariables(relPattern.edge, variables);
+        }
+        else {
+            return this.nodePropertiesReferenceVariables(pattern, variables);
+        }
+    }
+    /**
+     * Check if node properties reference any of the given variables
+     */
+    nodePropertiesReferenceVariables(node, variables) {
+        if (!node.properties)
+            return false;
+        for (const value of Object.values(node.properties)) {
+            if (this.propertyValueReferencesVariables(value, variables)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if edge properties reference any of the given variables
+     */
+    edgePropertiesReferenceVariables(edge, variables) {
+        if (!edge.properties)
+            return false;
+        for (const value of Object.values(edge.properties)) {
+            if (this.propertyValueReferencesVariables(value, variables)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a property value references any of the given variables
+     */
+    propertyValueReferencesVariables(value, variables) {
+        if (value === null || typeof value !== 'object')
+            return false;
+        if ('type' in value) {
+            if (value.type === 'variable' && 'name' in value && typeof value.name === 'string') {
+                return variables.has(value.name);
+            }
+        }
+        return false;
+    }
+    // ============================================================================
     // Phase-Based Execution
     // ============================================================================
     /**
@@ -264,12 +631,8 @@ export class Executor {
      */
     tryPhasedExecution(query, params) {
         const phases = this.detectPhases(query);
-        // Semantic validation: Check if MERGE tries to use a variable already bound by MATCH
-        this.validateMergeVariables(query);
-        // Semantic validation: SET expressions cannot reference undefined variables
-        this.validateSetClauseValueVariables(query, params);
-        // Semantic validation: ORDER BY expressions cannot reference undefined or out-of-scope variables
-        this.validateOrderByVariables(query, params);
+        // Note: Semantic validations (validateMergeVariables, validateSetClauseValueVariables,
+        // validateOrderByVariables) are now called in execute() before classification
         // Check if we need phased execution for MATCH + MERGE combinations
         // These need special handling for proper Cartesian product semantics
         // BUT: If MERGE has ON CREATE SET or ON MATCH SET, let tryMergeExecution handle it
@@ -761,6 +1124,30 @@ export class Executor {
                         break;
                     }
                 }
+                // Track UNWIND alias as a known variable
+                knownVariables.add(clause.alias);
+            }
+            // Check if MATCH pattern properties reference UNWIND variables - needs phase boundary
+            // This handles: UNWIND list AS x MATCH (n {prop: x}) RETURN n
+            // The MATCH needs to be executed for each UNWIND row, which requires phased execution
+            if ((clause.type === "MATCH" || clause.type === "OPTIONAL_MATCH") && i > 0) {
+                // Collect all UNWIND aliases from previous clauses
+                const unwindAliases = new Set();
+                for (let j = 0; j < i; j++) {
+                    const prevClause = clauses[j];
+                    if (prevClause.type === "UNWIND") {
+                        unwindAliases.add(prevClause.alias);
+                    }
+                }
+                // Check if MATCH pattern properties reference any UNWIND variables
+                if (unwindAliases.size > 0) {
+                    for (const pattern of clause.patterns) {
+                        if (this.patternReferencesVariables(pattern, unwindAliases)) {
+                            needsNewPhase = true;
+                            break;
+                        }
+                    }
+                }
             }
             // Check if MATCH after a WITH with aggregates - needs phase boundary
             // This handles patterns like:
@@ -1269,7 +1656,9 @@ export class Executor {
      * Execute a single phase with the given context
      */
     executePhase(clauses, inputContext, params, isLastPhase) {
-        let context = cloneContext(inputContext);
+        // Check if this phase contains only read-only clauses
+        const hasWriteClauses = clauses.some(clause => !this.isReadOnlyClause(clause));
+        let context = cloneContext(inputContext, hasWriteClauses);
         for (const clause of clauses) {
             context = this.executeClause(clause, context, params);
         }
@@ -1278,25 +1667,32 @@ export class Executor {
     /**
      * Execute a single clause and update context
      */
+    isReadOnlyClause(clause) {
+        // These clauses are read-only and don't modify the context structure
+        return clause.type === "MATCH" || clause.type === "OPTIONAL_MATCH" || clause.type === "RETURN";
+    }
     executeClause(clause, context, params) {
+        // For read-only clauses, avoid the expensive row cloning operation
+        const cloneRows = !this.isReadOnlyClause(clause);
+        const newContext = cloneContext(context, cloneRows);
         switch (clause.type) {
             case "CREATE":
-                return this.executeCreateClause(clause, context, params);
+                return this.executeCreateClause(clause, newContext, params);
             case "MERGE":
-                return this.executeMergeClause(clause, context, params);
+                return this.executeMergeClause(clause, newContext, params);
             case "WITH":
-                return this.executeWithClause(clause, context, params);
+                return this.executeWithClause(clause, newContext, params);
             case "UNWIND":
-                return this.executeUnwindClause(clause, context, params);
+                return this.executeUnwindClause(clause, newContext, params);
             case "MATCH":
             case "OPTIONAL_MATCH":
-                return this.executeMatchClause(clause, context, params);
+                return this.executeMatchClause(clause, newContext, params);
             case "RETURN":
-                return this.executeReturnClause(clause, context, params);
+                return this.executeReturnClause(clause, newContext, params);
             case "SET":
-                return this.executeSetClause(clause, context, params);
+                return this.executeSetClause(clause, newContext, params);
             case "DELETE":
-                return this.executeDeleteClause(clause, context, params);
+                return this.executeDeleteClause(clause, newContext, params);
             default:
                 // For unsupported clause types, return context unchanged
                 return context;
@@ -1424,12 +1820,12 @@ export class Executor {
         // Build query to find existing matching nodes
         const conditions = [];
         const conditionParams = [];
-        // Label condition
+        // Label condition (uses primary label index with fallback for secondary labels)
         if (pattern.label) {
             const labels = Array.isArray(pattern.label) ? pattern.label : [pattern.label];
             for (const label of labels) {
-                conditions.push(`EXISTS (SELECT 1 FROM json_each(label) WHERE value = ?)`);
-                conditionParams.push(label);
+                conditions.push(`(json_extract(label, '$[0]') = ? OR EXISTS (SELECT 1 FROM json_each(label) WHERE value = ? AND json_extract(label, '$[0]') != ?))`);
+                conditionParams.push(label, label, label);
             }
         }
         // Property conditions
@@ -1448,9 +1844,7 @@ export class Executor {
             for (const row of findResult.rows) {
                 const outputRow = new Map(inputRow);
                 if (pattern.variable) {
-                    const nodeProps = typeof row.properties === "string"
-                        ? JSON.parse(row.properties)
-                        : row.properties;
+                    const nodeProps = this.getNodeProperties(typeof row.id === "string" ? row.id : "", typeof row.properties === "string" || (typeof row.properties === "object" && row.properties !== null) ? row.properties : "{}");
                     const nodeObj = { ...nodeProps, _nf_id: row.id };
                     outputRow.set(pattern.variable, nodeObj);
                 }
@@ -1544,9 +1938,7 @@ export class Executor {
             for (const edgeRow of findResult.rows) {
                 const outputRow = new Map(inputRow);
                 if (pattern.edge.variable) {
-                    const props = typeof edgeRow.properties === "string"
-                        ? JSON.parse(edgeRow.properties)
-                        : edgeRow.properties;
+                    const props = this.getEdgeProperties(edgeRow.id, edgeRow.properties);
                     // Include _nf_start and _nf_end for startNode() and endNode() functions
                     // Use the actual source/target from the found edge (may be reversed for undirected)
                     outputRow.set(pattern.edge.variable, {
@@ -1983,7 +2375,9 @@ export class Executor {
         // Get variables referenced in WHERE that are context variables
         const whereReferencesContext = clause.where ?
             this.whereReferencesContextVars(clause.where, contextVarNames, introducedVars) : false;
-        if (boundVars.size > 0 || whereReferencesContext) {
+        // Check if pattern properties reference context variables (e.g., MATCH (n {prop: x}) where x is from UNWIND)
+        const patternPropertiesReferenceContext = clause.patterns.some(pattern => this.patternReferencesVariables(pattern, contextVarNames));
+        if (boundVars.size > 0 || whereReferencesContext || patternPropertiesReferenceContext) {
             // For complex patterns (multi-hop, anonymous nodes), use SQL translation with 
             // constraints for bound variables. This handles patterns like:
             // WITH me, you MATCH (me)-[r1:ATE]->()<-[r2:ATE]-(you) 
@@ -2122,9 +2516,7 @@ export class Executor {
                     for (const row of edgeResult.rows) {
                         const matchRow = new Map();
                         if (edgeVar) {
-                            const edgeProps = typeof row.properties === "string"
-                                ? JSON.parse(row.properties)
-                                : row.properties;
+                            const edgeProps = this.getEdgeProperties(row.id, row.properties);
                             matchRow.set(edgeVar, { ...edgeProps, _nf_id: row.id });
                         }
                         results.push(matchRow);
@@ -2159,9 +2551,55 @@ export class Executor {
         // Transform the clause to substitute context variable references with parameters
         // This handles cases like: WITH x AS foo MATCH (n) WHERE n.id = foo
         const transformedClause = this.transformClauseForContext(clause, contextVarNames);
+        // For OPTIONAL MATCH with bound source variable BUT new target variable, we need 
+        // to prepend a regular MATCH clause to bind the source first. This ensures the 
+        // translator includes the source node in the FROM clause.
+        // e.g., "OPTIONAL MATCH (n)-[r]->() WHERE id(n) = ?" becomes
+        //       "MATCH (n) WHERE id(n) = ? OPTIONAL MATCH (n)-[r]->()"
+        // Note: When BOTH source and target are bound, we don't need prefix MATCHes - the
+        // WHERE constraints added by transformClauseForContext are sufficient.
+        const prefixMatchClauses = [];
+        if (clause.type === "OPTIONAL_MATCH") {
+            for (const pattern of clause.patterns) {
+                if ('source' in pattern && 'edge' in pattern && 'target' in pattern) {
+                    const relPattern = pattern;
+                    const sourceVar = relPattern.source?.variable;
+                    const targetVar = relPattern.target?.variable;
+                    const sourceIsBound = sourceVar && contextVarNames.has(sourceVar);
+                    const targetIsBound = targetVar && contextVarNames.has(targetVar);
+                    // Only add prefix MATCH when source is bound but target is new
+                    // This handles: WITH n OPTIONAL MATCH (n)-[r]->() where n is bound, target is new
+                    if (sourceIsBound && !targetIsBound) {
+                        const nodeId = this.extractNodeId(inputRow.get(sourceVar));
+                        if (nodeId) {
+                            prefixMatchClauses.push({
+                                type: "MATCH",
+                                patterns: [{
+                                        variable: sourceVar
+                                    }],
+                                where: {
+                                    type: "comparison",
+                                    left: {
+                                        type: "function",
+                                        functionName: "ID",
+                                        args: [{ type: "variable", variable: sourceVar }]
+                                    },
+                                    operator: "=",
+                                    right: {
+                                        type: "parameter",
+                                        name: `_ctx_${sourceVar}`
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        }
         // Build a MATCH + RETURN query for all pattern variables
         const matchQuery = {
             clauses: [
+                ...prefixMatchClauses,
                 transformedClause,
                 {
                     type: "RETURN",
@@ -2170,9 +2608,17 @@ export class Executor {
             ],
         };
         // Create params with context values prefixed with _ctx_
+        // For node variables, extract the node ID for use in id() comparisons
         const mergedParams = { ...params };
         for (const [key, value] of inputRow) {
-            mergedParams[`_ctx_${key}`] = value;
+            // If value is a node object, extract its ID for the parameter
+            const nodeId = this.extractNodeId(value);
+            if (nodeId) {
+                mergedParams[`_ctx_${key}`] = nodeId;
+            }
+            else {
+                mergedParams[`_ctx_${key}`] = value;
+            }
         }
         // Translate to SQL with merged parameters
         const translator = new Translator(mergedParams);
@@ -2237,19 +2683,126 @@ export class Executor {
      * Transform a MATCH clause to substitute context variable references with parameter references.
      * This converts WHERE conditions like `n.id = foo` (where foo is from context)
      * to `n.id = $_ctx_foo` so the translator can handle it.
+     * Also transforms pattern properties like {name: foo} to use context parameters.
+     *
+     * For bound variables that appear as sources in relationship patterns, we add
+     * WHERE constraints like `id(n) = $_ctx_n` so the translator knows to include
+     * the node in the FROM clause.
      */
     transformClauseForContext(clause, contextVars) {
-        if (!clause.where) {
-            return clause;
-        }
         // Deep clone the clause
         const transformed = JSON.parse(JSON.stringify(clause));
+        // Transform pattern properties to use parameter references for context variables
+        // This handles MATCH (n:Label {prop: contextVar}) from UNWIND
+        for (const pattern of transformed.patterns) {
+            this.transformPatternPropertiesForContext(pattern, contextVars);
+        }
         // Transform WHERE condition to use parameter references for context variables
         if (transformed.where) {
             transformed.where = this.transformWhereForContext(transformed.where, contextVars);
         }
+        // For OPTIONAL MATCH with bound source but new target, add WHERE constraints 
+        // to ensure the source node is properly included in the SQL FROM clause.
+        // This handles: WITH n OPTIONAL MATCH (n)-[r:REL]->() where n is bound but target is new
+        // Note: When BOTH source and target are bound, we don't add WHERE constraints here
+        // because the translator can handle that case and adding constraints causes bad SQL
+        // (referencing tables before they're joined).
+        const boundSourceVars = new Set();
+        for (const pattern of transformed.patterns) {
+            if ('source' in pattern && 'edge' in pattern && 'target' in pattern) {
+                const relPattern = pattern;
+                const sourceVar = relPattern.source?.variable;
+                const targetVar = relPattern.target?.variable;
+                const sourceIsBound = sourceVar && contextVars.has(sourceVar);
+                const targetIsBound = targetVar && contextVars.has(targetVar);
+                // Only add constraint when source is bound but target is new
+                if (sourceIsBound && !targetIsBound) {
+                    boundSourceVars.add(sourceVar);
+                }
+            }
+        }
+        // Add WHERE constraints for bound source variables: id(varName) = $_ctx_varName
+        if (boundSourceVars.size > 0) {
+            const idConditions = [];
+            for (const varName of boundSourceVars) {
+                idConditions.push({
+                    type: "comparison",
+                    left: {
+                        type: "function",
+                        functionName: "ID",
+                        args: [{ type: "variable", variable: varName }]
+                    },
+                    operator: "=",
+                    right: {
+                        type: "parameter",
+                        name: `_ctx_${varName}`
+                    }
+                });
+            }
+            // Combine with existing WHERE using conditions array
+            if (transformed.where) {
+                // Combine all conditions into a single AND clause
+                transformed.where = {
+                    type: "and",
+                    conditions: [...idConditions, transformed.where]
+                };
+            }
+            else {
+                // Just use the ID conditions
+                if (idConditions.length === 1) {
+                    transformed.where = idConditions[0];
+                }
+                else {
+                    transformed.where = {
+                        type: "and",
+                        conditions: idConditions
+                    };
+                }
+            }
+        }
         return transformed;
     }
+    /**
+     * Transform pattern properties to use context parameter references
+     */
+    transformPatternPropertiesForContext(pattern, contextVars) {
+        // Check if this is a relationship pattern with source/edge/target
+        if ('source' in pattern && 'edge' in pattern && 'target' in pattern) {
+            this.transformNodePropertiesForContext(pattern.source, contextVars);
+            this.transformNodePropertiesForContext(pattern.target, contextVars);
+            if (pattern.edge.properties) {
+                this.transformPropertiesMapForContext(pattern.edge.properties, contextVars);
+            }
+        }
+        else {
+            // Simple node pattern
+            this.transformNodePropertiesForContext(pattern, contextVars);
+        }
+    }
+    /**
+     * Transform node properties to use context parameter references
+     */
+    transformNodePropertiesForContext(node, contextVars) {
+        if (node.properties) {
+            this.transformPropertiesMapForContext(node.properties, contextVars);
+        }
+    }
+    /**
+     * Transform a properties map to use context parameter references
+     */
+    transformPropertiesMapForContext(properties, contextVars) {
+        for (const [key, value] of Object.entries(properties)) {
+            if (value && typeof value === 'object' && 'type' in value &&
+                value.type === "variable" && 'name' in value &&
+                typeof value.name === 'string' && contextVars.has(value.name)) {
+                // Replace with parameter reference
+                properties[key] = {
+                    type: "parameter",
+                    name: `_ctx_${value.name}`,
+                };
+            }
+        }
+    }
     /**
      * Transform a WHERE condition to substitute context variable references with parameter references
      */
@@ -2406,56 +2959,24 @@ export class Executor {
             }
             // Follow the sequence of relationships to find the path endpoints
             // Each relationship in the list is either an edge object or edge ID
+            // Batch collect all edge IDs first
+            const edgeIds = [];
+            for (const rel of relList) {
+                const edgeId = this.extractEdgeId(rel);
+                if (edgeId)
+                    edgeIds.push(edgeId);
+            }
+            // Batch fetch all edge info in a single query
+            const edgeInfoMap = this.batchGetEdgeInfo(edgeIds);
             let currentNodeId = null;
             let firstNodeId = null;
             let lastNodeId = null;
             let valid = true;
             for (let i = 0; i < relList.length; i++) {
                 const rel = relList[i];
-                // Extract edge info - could be object with id, source_id, target_id or string ID
-                let edgeInfo = null;
-                if (typeof rel === "object" && rel !== null) {
-                    // Edge object from MATCH - may have _nf_id instead of id
-                    const relObj = rel;
-                    const edgeId = (relObj._nf_id || relObj.id);
-                    if (edgeId) {
-                        // Look up the edge to get source/target
-                        const edgeResult = this.db.execute("SELECT id, source_id, target_id FROM edges WHERE id = ?", [edgeId]);
-                        if (edgeResult.rows.length > 0) {
-                            const row = edgeResult.rows[0];
-                            edgeInfo = {
-                                id: row.id,
-                                source_id: row.source_id,
-                                target_id: row.target_id
-                            };
-                        }
-                    }
-                }
-                else if (typeof rel === "string") {
-                    // Could be a JSON string like '{"_nf_id":"uuid"}' or a raw UUID string
-                    let edgeId = null;
-                    try {
-                        const parsed = JSON.parse(rel);
-                        if (typeof parsed === "object" && parsed !== null) {
-                            edgeId = (parsed._nf_id || parsed.id);
-                        }
-                    }
-                    catch {
-                        // Not JSON, assume it's a raw ID
-                        edgeId = rel;
-                    }
-                    if (edgeId) {
-                        const edgeResult = this.db.execute("SELECT id, source_id, target_id FROM edges WHERE id = ?", [edgeId]);
-                        if (edgeResult.rows.length > 0) {
-                            const row = edgeResult.rows[0];
-                            edgeInfo = {
-                                id: row.id,
-                                source_id: row.source_id,
-                                target_id: row.target_id
-                            };
-                        }
-                    }
-                }
+                // Extract edge ID and get info from batch result
+                const edgeId = this.extractEdgeId(rel);
+                const edgeInfo = edgeId ? edgeInfoMap.get(edgeId) : null;
                 if (!edgeInfo) {
                     valid = false;
                     break;
@@ -2533,12 +3054,8 @@ export class Executor {
             const firstNode = firstNodeResult.rows[0];
             const lastNode = lastNodeResult.rows[0];
             // Format nodes like the translator does (with _nf_id embedded)
-            const firstProps = typeof firstNode.properties === "string"
-                ? JSON.parse(firstNode.properties)
-                : firstNode.properties;
-            const lastProps = typeof lastNode.properties === "string"
-                ? JSON.parse(lastNode.properties)
-                : lastNode.properties;
+            const firstProps = this.getNodeProperties(firstNode.id, firstNode.properties);
+            const lastProps = this.getNodeProperties(lastNode.id, lastNode.properties);
             outputRow.set(boundInfo.sourceVar, { ...firstProps, _nf_id: firstNode.id });
             outputRow.set(boundInfo.targetVar, { ...lastProps, _nf_id: lastNode.id });
             newRows.push(outputRow);
@@ -2712,6 +3229,8 @@ export class Executor {
                 if (assignment.property && assignment.value) {
                     const value = this.evaluateExpressionInRow(assignment.value, row, params);
                     this.db.execute(`UPDATE nodes SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), nodeId]);
+                    // Invalidate cache after UPDATE
+                    this.invalidatePropertyCache(nodeId);
                 }
             }
         }
@@ -2723,7 +3242,9 @@ export class Executor {
     executeDeleteClause(clause, context, params) {
         for (const row of context.rows) {
             for (const variable of clause.variables) {
-                const id = row.get(variable);
+                const value = row.get(variable);
+                // Extract node/edge ID from the value (could be object with _nf_id or string ID)
+                const id = this.extractNodeId(value);
                 if (!id)
                     continue;
                 if (clause.detach) {
@@ -2899,6 +3420,27 @@ export class Executor {
                         return null;
                 }
             }
+            case "reduce": {
+                // Evaluate reduce expression: reduce(acc = init, x IN list | expr)
+                const listValue = this.evaluateExpressionInRow(expr.listExpr, row, params);
+                if (!Array.isArray(listValue))
+                    return null;
+                // Start with the initial value
+                let accumulator = this.evaluateExpressionInRow(expr.initialValue, row, params);
+                for (const item of listValue) {
+                    // Create a new row with both the accumulator and loop variable
+                    const itemRow = new Map(row);
+                    if (expr.accumulator) {
+                        itemRow.set(expr.accumulator, accumulator);
+                    }
+                    if (expr.variable) {
+                        itemRow.set(expr.variable, item);
+                    }
+                    // Evaluate the reduce expression to get the new accumulator value
+                    accumulator = this.evaluateExpressionInRow(expr.reduceExpr, itemRow, params);
+                }
+                return accumulator;
+            }
             case "comparison": {
                 // Evaluate comparison expression: left op right
                 const left = this.evaluateExpressionInRow(expr.left, row, params);
@@ -3007,7 +3549,12 @@ export class Executor {
                 }
                 if (!edgeId)
                     return null;
-                // Look up edge type from database
+                // Check edge info cache first (populated by batchGetEdgeInfo)
+                const cachedInfo = this.edgeInfoCache.get(edgeId);
+                if (cachedInfo) {
+                    return cachedInfo.type;
+                }
+                // Fall back to database lookup
                 const result = this.db.execute("SELECT type FROM edges WHERE id = ?", [edgeId]);
                 if (result.rows.length > 0) {
                     return result.rows[0].type;
@@ -3026,10 +3573,17 @@ export class Executor {
                         startNodeId = edgeObj._nf_start;
                     }
                     else if ("_nf_id" in edgeObj) {
-                        // Look up edge from database to get source_id
-                        const edgeResult = this.db.execute("SELECT source_id FROM edges WHERE id = ?", [edgeObj._nf_id]);
-                        if (edgeResult.rows.length > 0) {
-                            startNodeId = edgeResult.rows[0].source_id;
+                        // Check edge info cache first (populated by batchGetEdgeInfo)
+                        const cachedInfo = this.edgeInfoCache.get(edgeObj._nf_id);
+                        if (cachedInfo) {
+                            startNodeId = cachedInfo.source_id;
+                        }
+                        else {
+                            // Fall back to database lookup
+                            const edgeResult = this.db.execute("SELECT source_id FROM edges WHERE id = ?", [edgeObj._nf_id]);
+                            if (edgeResult.rows.length > 0) {
+                                startNodeId = edgeResult.rows[0].source_id;
+                            }
                         }
                     }
                 }
@@ -3038,9 +3592,7 @@ export class Executor {
                 // Look up node from database
                 const nodeResult = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [startNodeId]);
                 if (nodeResult.rows.length > 0) {
-                    const nodeProps = typeof nodeResult.rows[0].properties === "string"
-                        ? JSON.parse(nodeResult.rows[0].properties)
-                        : nodeResult.rows[0].properties;
+                    const nodeProps = this.getNodeProperties(nodeResult.rows[0].id, nodeResult.rows[0].properties);
                     return { ...nodeProps, _nf_id: nodeResult.rows[0].id };
                 }
                 return null;
@@ -3057,10 +3609,17 @@ export class Executor {
                         endNodeId = edgeObj._nf_end;
                     }
                     else if ("_nf_id" in edgeObj) {
-                        // Look up edge from database to get target_id
-                        const edgeResult = this.db.execute("SELECT target_id FROM edges WHERE id = ?", [edgeObj._nf_id]);
-                        if (edgeResult.rows.length > 0) {
-                            endNodeId = edgeResult.rows[0].target_id;
+                        // Check edge info cache first (populated by batchGetEdgeInfo)
+                        const cachedInfo = this.edgeInfoCache.get(edgeObj._nf_id);
+                        if (cachedInfo) {
+                            endNodeId = cachedInfo.target_id;
+                        }
+                        else {
+                            // Fall back to database lookup
+                            const edgeResult = this.db.execute("SELECT target_id FROM edges WHERE id = ?", [edgeObj._nf_id]);
+                            if (edgeResult.rows.length > 0) {
+                                endNodeId = edgeResult.rows[0].target_id;
+                            }
                         }
                     }
                 }
@@ -3069,9 +3628,7 @@ export class Executor {
                 // Look up node from database
                 const nodeResult = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [endNodeId]);
                 if (nodeResult.rows.length > 0) {
-                    const nodeProps = typeof nodeResult.rows[0].properties === "string"
-                        ? JSON.parse(nodeResult.rows[0].properties)
-                        : nodeResult.rows[0].properties;
+                    const nodeProps = this.getNodeProperties(nodeResult.rows[0].id, nodeResult.rows[0].properties);
                     return { ...nodeProps, _nf_id: nodeResult.rows[0].id };
                 }
                 return null;
@@ -3558,27 +4115,66 @@ export class Executor {
         // Also collect values for WITH aggregates (can be numbers or objects for collect)
         const withAggregateValues = new Map();
         this.db.transaction(() => {
-            for (const combination of combinations) {
+            // Collect all node inserts for batching
+            const nodeInserts = [];
+            // Collect all edge inserts for batching
+            const edgeInserts = [];
+            // Cache edge info for RETURN lookups before batch insert
+            const pendingEdgeInfo = new Map();
+            for (let comboIndex = 0; comboIndex < combinations.length; comboIndex++) {
+                const combination = combinations[comboIndex];
                 // Build a map of unwind variable -> current value
                 const unwindContext = {};
                 for (let i = 0; i < unwindClauses.length; i++) {
                     unwindContext[unwindClauses[i].alias] = combination[i];
                 }
-                // Execute CREATE with the unwind context
-                const createdIds = new Map();
                 for (const createClause of createClauses) {
                     for (const pattern of createClause.patterns) {
-                        if (this.isRelationshipPattern(pattern)) {
-                            this.executeCreateRelationshipPatternWithUnwind(pattern, createdIds, params, unwindContext);
-                        }
-                        else {
+                        if (!this.isRelationshipPattern(pattern)) {
+                            // Only collect node patterns in this pass; relationships handled after nodes are inserted
                             const id = crypto.randomUUID();
                             const labelJson = this.normalizeLabelToJson(pattern.label);
                             const props = this.resolvePropertiesWithUnwind(pattern.properties || {}, params, unwindContext);
-                            this.db.execute("INSERT INTO nodes (id, label, properties) VALUES (?, ?, ?)", [id, labelJson, JSON.stringify(props)]);
-                            if (pattern.variable) {
-                                createdIds.set(pattern.variable, id);
-                            }
+                            nodeInserts.push({
+                                id,
+                                labelJson,
+                                propsJson: JSON.stringify(props),
+                                variable: pattern.variable,
+                                combinationIndex: comboIndex
+                            });
+                        }
+                    }
+                }
+            }
+            // Batch insert nodes (cap at 500 rows per statement)
+            const BATCH_SIZE = 500;
+            for (let i = 0; i < nodeInserts.length; i += BATCH_SIZE) {
+                const batch = nodeInserts.slice(i, i + BATCH_SIZE);
+                const placeholders = batch.map(() => '(?, ?, ?)').join(',');
+                const values = batch.flatMap(insert => [insert.id, insert.labelJson, insert.propsJson]);
+                this.db.execute(`INSERT INTO nodes (id, label, properties) VALUES ${placeholders}`, values);
+            }
+            // Process each combination with batched inserts
+            for (let comboIndex = 0; comboIndex < combinations.length; comboIndex++) {
+                const combination = combinations[comboIndex];
+                // Build a map of unwind variable -> current value
+                const unwindContext = {};
+                for (let i = 0; i < unwindClauses.length; i++) {
+                    unwindContext[unwindClauses[i].alias] = combination[i];
+                }
+                // Execute CREATE with the unwind context
+                const createdIds = new Map();
+                // Add nodes from batch insert to createdIds
+                for (const insert of nodeInserts) {
+                    if (insert.combinationIndex === comboIndex && insert.variable) {
+                        createdIds.set(insert.variable, insert.id);
+                    }
+                }
+                // Handle relationships (they may reference nodes created in this combination)
+                for (const createClause of createClauses) {
+                    for (const pattern of createClause.patterns) {
+                        if (this.isRelationshipPattern(pattern)) {
+                            this.executeCreateRelationshipPatternWithUnwind(pattern, createdIds, params, unwindContext, edgeInserts, pendingEdgeInfo);
                         }
                     }
                 }
@@ -3602,23 +4198,37 @@ export class Executor {
                                 let value;
                                 const id = createdIds.get(aggInfo.argVariable);
                                 if (id) {
-                                    let result = this.db.execute("SELECT properties FROM nodes WHERE id = ?", [id]);
-                                    if (result.rows.length === 0) {
-                                        result = this.db.execute("SELECT properties FROM edges WHERE id = ?", [id]);
-                                    }
-                                    if (result.rows.length > 0) {
-                                        const props = typeof result.rows[0].properties === "string"
-                                            ? JSON.parse(result.rows[0].properties)
-                                            : result.rows[0].properties;
+                                    // Check pendingEdgeInfo first (edges not yet batch-inserted)
+                                    const pendingEdge = pendingEdgeInfo.get(id);
+                                    if (pendingEdge) {
+                                        const props = pendingEdge.properties;
                                         if (aggInfo.argProperty) {
-                                            // Collect property value
                                             value = props[aggInfo.argProperty];
                                         }
                                         else {
-                                            // Collect the whole node object (for collect(n))
                                             value = props;
                                         }
                                     }
+                                    else {
+                                        let result = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [id]);
+                                        let isNode = result.rows.length > 0;
+                                        if (!isNode) {
+                                            result = this.db.execute("SELECT id, properties FROM edges WHERE id = ?", [id]);
+                                        }
+                                        if (result.rows.length > 0) {
+                                            const props = isNode
+                                                ? this.getNodeProperties(result.rows[0].id, result.rows[0].properties)
+                                                : this.getEdgeProperties(result.rows[0].id, result.rows[0].properties);
+                                            if (aggInfo.argProperty) {
+                                                // Collect property value
+                                                value = props[aggInfo.argProperty];
+                                            }
+                                            else {
+                                                // Collect the whole node object (for collect(n))
+                                                value = props;
+                                            }
+                                        }
+                                    }
                                 }
                                 if (value !== undefined) {
                                     if (!withAggregateValues.has(alias)) {
@@ -3643,17 +4253,25 @@ export class Executor {
                                             const property = arg.property;
                                             const id = createdIds.get(variable);
                                             if (id) {
-                                                // Try nodes first, then edges
-                                                let result = this.db.execute("SELECT properties FROM nodes WHERE id = ?", [id]);
-                                                if (result.rows.length === 0) {
-                                                    // Try edges table
-                                                    result = this.db.execute("SELECT properties FROM edges WHERE id = ?", [id]);
+                                                // Check pendingEdgeInfo first (edges not yet batch-inserted)
+                                                const pendingEdge = pendingEdgeInfo.get(id);
+                                                if (pendingEdge) {
+                                                    value = pendingEdge.properties[property];
                                                 }
-                                                if (result.rows.length > 0) {
-                                                    const props = typeof result.rows[0].properties === "string"
-                                                        ? JSON.parse(result.rows[0].properties)
-                                                        : result.rows[0].properties;
-                                                    value = props[property];
+                                                else {
+                                                    // Try nodes first, then edges
+                                                    let result = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [id]);
+                                                    let isNode = result.rows.length > 0;
+                                                    if (!isNode) {
+                                                        // Try edges table
+                                                        result = this.db.execute("SELECT id, properties FROM edges WHERE id = ?", [id]);
+                                                    }
+                                                    if (result.rows.length > 0) {
+                                                        const props = isNode
+                                                            ? this.getNodeProperties(result.rows[0].id, result.rows[0].properties)
+                                                            : this.getEdgeProperties(result.rows[0].id, result.rows[0].properties);
+                                                        value = props[property];
+                                                    }
                                                 }
                                             }
                                         }
@@ -3688,9 +4306,7 @@ export class Executor {
                                     if (nodeResult.rows.length > 0) {
                                         const row = nodeResult.rows[0];
                                         // Neo4j 3.5 format: return properties directly
-                                        resultRow[alias] = typeof row.properties === "string"
-                                            ? JSON.parse(row.properties)
-                                            : row.properties;
+                                        resultRow[alias] = this.getNodeProperties(row.id, row.properties);
                                     }
                                 }
                             }
@@ -3700,17 +4316,25 @@ export class Executor {
                                 const property = item.expression.property;
                                 const id = createdIds.get(variable);
                                 if (id) {
-                                    // Try nodes first, then edges
-                                    let nodeResult = this.db.execute("SELECT properties FROM nodes WHERE id = ?", [id]);
-                                    if (nodeResult.rows.length === 0) {
-                                        // Try edges table
-                                        nodeResult = this.db.execute("SELECT properties FROM edges WHERE id = ?", [id]);
+                                    // Check pendingEdgeInfo first (edges not yet batch-inserted)
+                                    const pendingEdge = pendingEdgeInfo.get(id);
+                                    if (pendingEdge) {
+                                        resultRow[alias] = pendingEdge.properties[property];
                                     }
-                                    if (nodeResult.rows.length > 0) {
-                                        const props = typeof nodeResult.rows[0].properties === "string"
-                                            ? JSON.parse(nodeResult.rows[0].properties)
-                                            : nodeResult.rows[0].properties;
-                                        resultRow[alias] = props[property];
+                                    else {
+                                        // Try nodes first, then edges
+                                        let nodeResult = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [id]);
+                                        let isNode = nodeResult.rows.length > 0;
+                                        if (!isNode) {
+                                            // Try edges table
+                                            nodeResult = this.db.execute("SELECT id, properties FROM edges WHERE id = ?", [id]);
+                                        }
+                                        if (nodeResult.rows.length > 0) {
+                                            const props = isNode
+                                                ? this.getNodeProperties(nodeResult.rows[0].id, nodeResult.rows[0].properties)
+                                                : this.getEdgeProperties(nodeResult.rows[0].id, nodeResult.rows[0].properties);
+                                            resultRow[alias] = props[property];
+                                        }
                                     }
                                 }
                             }
@@ -3721,6 +4345,14 @@ export class Executor {
                     }
                 }
             }
+            // Batch insert edges (cap at 500 rows per statement)
+            const EDGE_BATCH_SIZE = 500;
+            for (let i = 0; i < edgeInserts.length; i += EDGE_BATCH_SIZE) {
+                const batch = edgeInserts.slice(i, i + EDGE_BATCH_SIZE);
+                const placeholders = batch.map(() => '(?, ?, ?, ?, ?)').join(',');
+                const values = batch.flatMap(insert => [insert.id, insert.type, insert.sourceId, insert.targetId, insert.propsJson]);
+                this.db.execute(`INSERT INTO edges (id, type, source_id, target_id, properties) VALUES ${placeholders}`, values);
+            }
         });
         // Compute WITH aggregate results if RETURN references them
         if (returnsWithAggregateAliases && returnClause) {
@@ -3899,14 +4531,15 @@ export class Executor {
             const id = resolvedIds[variable];
             if (id) {
                 // Try nodes first, then edges
-                let result = this.db.execute("SELECT properties FROM nodes WHERE id = ?", [id]);
-                if (result.rows.length === 0) {
-                    result = this.db.execute("SELECT properties FROM edges WHERE id = ?", [id]);
+                let result = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [id]);
+                let isNode = result.rows.length > 0;
+                if (!isNode) {
+                    result = this.db.execute("SELECT id, properties FROM edges WHERE id = ?", [id]);
                 }
                 if (result.rows.length > 0) {
-                    const props = typeof result.rows[0].properties === "string"
-                        ? JSON.parse(result.rows[0].properties)
-                        : result.rows[0].properties;
+                    const props = isNode
+                        ? this.getNodeProperties(result.rows[0].id, result.rows[0].properties)
+                        : this.getEdgeProperties(result.rows[0].id, result.rows[0].properties);
                     return props[property];
                 }
             }
@@ -3942,15 +4575,16 @@ export class Executor {
             const id = createdIds.get(variable);
             if (id) {
                 // Try nodes first, then edges
-                let result = this.db.execute("SELECT properties FROM nodes WHERE id = ?", [id]);
-                if (result.rows.length === 0) {
+                let result = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [id]);
+                let isNode = result.rows.length > 0;
+                if (!isNode) {
                     // Try edges table
-                    result = this.db.execute("SELECT properties FROM edges WHERE id = ?", [id]);
+                    result = this.db.execute("SELECT id, properties FROM edges WHERE id = ?", [id]);
                 }
                 if (result.rows.length > 0) {
-                    const props = typeof result.rows[0].properties === "string"
-                        ? JSON.parse(result.rows[0].properties)
-                        : result.rows[0].properties;
+                    const props = isNode
+                        ? this.getNodeProperties(result.rows[0].id, result.rows[0].properties)
+                        : this.getEdgeProperties(result.rows[0].id, result.rows[0].properties);
                     return props[property];
                 }
             }
@@ -4038,8 +4672,9 @@ export class Executor {
                         let whereConditions = [];
                         let whereParams = [];
                         if (nodePattern.label) {
-                            whereConditions.push("EXISTS (SELECT 1 FROM json_each(label) WHERE value = ?)");
-                            whereParams.push(nodePattern.label);
+                            // Use primary label index with fallback for secondary labels
+                            whereConditions.push("(json_extract(label, '$[0]') = ? OR EXISTS (SELECT 1 FROM json_each(label) WHERE value = ? AND json_extract(label, '$[0]') != ?))");
+                            whereParams.push(nodePattern.label, nodePattern.label, nodePattern.label);
                         }
                         for (const [key, value] of Object.entries(props)) {
                             whereConditions.push(`json_extract(properties, '$.${key}') = ?`);
@@ -4989,7 +5624,7 @@ export class Executor {
     /**
      * Execute CREATE relationship pattern with unwind context
      */
-    executeCreateRelationshipPatternWithUnwind(rel, createdIds, params, unwindContext) {
+    executeCreateRelationshipPatternWithUnwind(rel, createdIds, params, unwindContext, edgeInserts, pendingEdgeInfo) {
         let sourceId;
         let targetId;
         // Determine source node ID
@@ -5032,7 +5667,30 @@ export class Executor {
         const edgeId = crypto.randomUUID();
         const edgeType = rel.edge.type || "";
         const edgeProps = this.resolvePropertiesWithUnwind(rel.edge.properties || {}, params, unwindContext);
-        this.db.execute("INSERT INTO edges (id, type, source_id, target_id, properties) VALUES (?, ?, ?, ?, ?)", [edgeId, edgeType, actualSource, actualTarget, JSON.stringify(edgeProps)]);
+        if (edgeInserts) {
+            // Collect for batch insert
+            edgeInserts.push({
+                id: edgeId,
+                type: edgeType,
+                sourceId: actualSource,
+                targetId: actualTarget,
+                propsJson: JSON.stringify(edgeProps),
+                variable: rel.edge.variable
+            });
+            // Cache for RETURN lookups before batch insert
+            if (pendingEdgeInfo) {
+                pendingEdgeInfo.set(edgeId, {
+                    type: edgeType,
+                    sourceId: actualSource,
+                    targetId: actualTarget,
+                    properties: edgeProps
+                });
+            }
+        }
+        else {
+            // Direct insert (for non-batched callers)
+            this.db.execute("INSERT INTO edges (id, type, source_id, target_id, properties) VALUES (?, ?, ?, ?, ?)", [edgeId, edgeType, actualSource, actualTarget, JSON.stringify(edgeProps)]);
+        }
         if (rel.edge.variable) {
             createdIds.set(rel.edge.variable, edgeId);
         }
@@ -5116,9 +5774,7 @@ export class Executor {
                     if (nodeResult.rows.length > 0) {
                         const row = nodeResult.rows[0];
                         // Neo4j 3.5 format: return properties directly
-                        resultRow[alias] = typeof row.properties === "string"
-                            ? JSON.parse(row.properties)
-                            : row.properties;
+                        resultRow[alias] = this.getNodeProperties(row.id, row.properties);
                     }
                 }
             }
@@ -5358,6 +6014,15 @@ export class Executor {
             }
             if (relList.length === 0)
                 continue;
+            // Batch collect all edge IDs first
+            const edgeIds = [];
+            for (const rel of relList) {
+                const edgeId = this.extractEdgeId(rel);
+                if (edgeId)
+                    edgeIds.push(edgeId);
+            }
+            // Batch fetch all edge info in a single query
+            const edgeInfoMap = this.batchGetEdgeInfo(edgeIds);
             // Follow the sequence of relationships to find endpoints
             let currentNodeId = null;
             let firstNodeId = null;
@@ -5365,45 +6030,9 @@ export class Executor {
             let valid = true;
             for (let i = 0; i < relList.length; i++) {
                 const rel = relList[i];
-                // Extract edge info
-                let edgeInfo = null;
-                if (typeof rel === "object" && rel !== null) {
-                    const relObj = rel;
-                    const edgeId = (relObj._nf_id || relObj.id);
-                    if (edgeId) {
-                        const edgeResult = this.db.execute("SELECT id, source_id, target_id FROM edges WHERE id = ?", [edgeId]);
-                        if (edgeResult.rows.length > 0) {
-                            const r = edgeResult.rows[0];
-                            edgeInfo = {
-                                id: r.id,
-                                source_id: r.source_id,
-                                target_id: r.target_id
-                            };
-                        }
-                    }
-                }
-                else if (typeof rel === "string") {
-                    // Could be a JSON string like '{"_nf_id":"uuid"}' or a raw edge ID
-                    let edgeId = rel;
-                    try {
-                        const parsed = JSON.parse(rel);
-                        if (typeof parsed === "object" && parsed !== null && (parsed._nf_id || parsed.id)) {
-                            edgeId = (parsed._nf_id || parsed.id);
-                        }
-                    }
-                    catch {
-                        // Not JSON, use as-is
-                    }
-                    const edgeResult = this.db.execute("SELECT id, source_id, target_id FROM edges WHERE id = ?", [edgeId]);
-                    if (edgeResult.rows.length > 0) {
-                        const r = edgeResult.rows[0];
-                        edgeInfo = {
-                            id: r.id,
-                            source_id: r.source_id,
-                            target_id: r.target_id
-                        };
-                    }
-                }
+                // Extract edge ID and get info from batch result
+                const edgeId = this.extractEdgeId(rel);
+                const edgeInfo = edgeId ? edgeInfoMap.get(edgeId) : null;
                 if (!edgeInfo) {
                     valid = false;
                     break;
@@ -5454,12 +6083,8 @@ export class Executor {
             }
             const firstNode = firstNodeResult.rows[0];
             const lastNode = lastNodeResult.rows[0];
-            const firstProps = typeof firstNode.properties === "string"
-                ? JSON.parse(firstNode.properties)
-                : firstNode.properties;
-            const lastProps = typeof lastNode.properties === "string"
-                ? JSON.parse(lastNode.properties)
-                : lastNode.properties;
+            const firstProps = this.getNodeProperties(firstNode.id, firstNode.properties);
+            const lastProps = this.getNodeProperties(lastNode.id, lastNode.properties);
             // Build result based on RETURN items
             const resultRow = {};
             for (const item of returnClause.items) {
@@ -5575,7 +6200,7 @@ export class Executor {
                         matchedNodes.set(nodePattern.variable, {
                             id: row.id,
                             label: row.label,
-                            properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                            properties: this.getNodeProperties(typeof row.id === "string" ? row.id : "", typeof row.properties === "string" || (typeof row.properties === "object" && row.properties !== null) ? row.properties : "{}"),
                         });
                     }
                 }
@@ -5690,6 +6315,8 @@ export class Executor {
                         continue;
                     const value = this.evaluateExpressionWithMatchedNodes(assignment.value, params, matchedNodes);
                     this.db.execute(`UPDATE nodes SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), nodeId]);
+                    // Invalidate cache after UPDATE
+                    this.invalidatePropertyCache(nodeId);
                 }
             }
         }
@@ -5701,7 +6328,7 @@ export class Executor {
                 matchedNodes.set(pattern.variable, {
                     id: row.id,
                     label: row.label,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getNodeProperties(row.id, row.properties),
                 });
             }
         }
@@ -5766,7 +6393,7 @@ export class Executor {
                     type: row.type,
                     source_id: row.source_id,
                     target_id: row.target_id,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getEdgeProperties(row.id, row.properties),
                 });
             }
         }
@@ -6039,7 +6666,7 @@ export class Executor {
                             newRow.set(nodePattern.variable, {
                                 id: sqlRow.id,
                                 label: labelValue,
-                                properties: typeof sqlRow.properties === "string" ? JSON.parse(sqlRow.properties) : sqlRow.properties,
+                                properties: this.getNodeProperties(sqlRow.id, sqlRow.properties),
                             });
                         }
                         newMatchRows.push(newRow);
@@ -6188,6 +6815,8 @@ export class Executor {
                         continue;
                     const value = this.evaluateExpressionWithMatchedNodes(assignment.value, params, matchedNodes);
                     this.db.execute(`UPDATE nodes SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), nodeId]);
+                    // Invalidate cache after UPDATE
+                    this.invalidatePropertyCache(nodeId);
                 }
             }
         }
@@ -6199,7 +6828,7 @@ export class Executor {
                 matchedNodes.set(pattern.variable, {
                     id: row.id,
                     label: row.label,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getNodeProperties(row.id, row.properties),
                 });
             }
         }
@@ -6322,7 +6951,7 @@ export class Executor {
                     type: row.type,
                     source_id: row.source_id,
                     target_id: row.target_id,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getEdgeProperties(row.id, row.properties),
                 });
             }
         }
@@ -6526,6 +7155,8 @@ export class Executor {
                         ? this.evaluateExpressionWithContext(assignment.value, params, resolvedIds)
                         : this.evaluateExpression(assignment.value, params);
                     this.db.execute(`UPDATE nodes SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), nodeId]);
+                    // Invalidate cache after UPDATE
+                    this.invalidatePropertyCache(nodeId);
                 }
             }
         }
@@ -6537,7 +7168,7 @@ export class Executor {
                 matchedNodes.set(pattern.variable, {
                     id: row.id,
                     label: row.label,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getNodeProperties(row.id, row.properties),
                 });
             }
         }
@@ -6635,6 +7266,8 @@ export class Executor {
                     const value = this.evaluateExpression(assignment.value, params);
                     // Update target node with ON CREATE SET
                     this.db.execute(`UPDATE nodes SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), targetNodeId]);
+                    // Invalidate cache after UPDATE
+                    this.invalidatePropertyCache(targetNodeId);
                 }
             }
             this.db.execute("INSERT INTO edges (id, type, source_id, target_id, properties) VALUES (?, ?, ?, ?, ?)", [edgeId, edgeType, sourceNodeId, targetNodeId, JSON.stringify(finalEdgeProps)]);
@@ -6652,6 +7285,8 @@ export class Executor {
                     const value = this.evaluateExpression(assignment.value, params);
                     // Update target node with ON MATCH SET
                     this.db.execute(`UPDATE nodes SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), targetNodeId]);
+                    // Invalidate cache after UPDATE
+                    this.invalidatePropertyCache(targetNodeId);
                 }
             }
         }
@@ -6665,7 +7300,7 @@ export class Executor {
                     type: row.type,
                     source_id: row.source_id,
                     target_id: row.target_id,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getEdgeProperties(row.id, row.properties),
                 });
             }
         }
@@ -6677,7 +7312,7 @@ export class Executor {
                 matchedNodes.set(targetVar, {
                     id: row.id,
                     label: row.label,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getNodeProperties(row.id, row.properties),
                 });
             }
         }
@@ -6712,7 +7347,7 @@ export class Executor {
                 return {
                     id: row.id,
                     label: typeof row.label === "string" ? JSON.parse(row.label) : row.label,
-                    properties: typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties,
+                    properties: this.getNodeProperties(row.id, row.properties),
                 };
             }
         }
@@ -6971,7 +7606,7 @@ export class Executor {
             case "variable":
                 return expr.variable;
             case "property":
-                return `${expr.variable}_${expr.property}`;
+                return `${expr.variable}.${expr.property}`;
             case "function": {
                 // Build function expression like count(a) or count(*)
                 const funcName = expr.functionName.toLowerCase();
@@ -7010,6 +7645,236 @@ export class Executor {
                 return "expr";
         }
     }
+    /**
+     * Execute queries with FOREACH clause.
+     * FOREACH iterates over a list and executes mutation clauses for each item.
+     * Pattern: ... FOREACH (var IN list | SET/CREATE/DELETE...) ...
+     */
+    tryForeachExecution(query, params) {
+        // Execute query with phased approach using PhaseContext
+        let context = createEmptyContext();
+        this.db.transaction(() => {
+            for (const clause of query.clauses) {
+                if (clause.type === "FOREACH") {
+                    // Execute FOREACH for the current context
+                    this.executeForeachClause(clause, context, params);
+                }
+                else if (clause.type === "RETURN") {
+                    // RETURN is handled after transaction
+                }
+                else if (clause.type === "CREATE") {
+                    context = this.executeCreateClause(clause, context, params);
+                }
+                else if (clause.type === "WITH") {
+                    context = this.executeWithClause(clause, context, params);
+                }
+                else if (clause.type === "SET") {
+                    this.executeForeachSetClause(clause, context, params);
+                }
+                // Other clauses could be added as needed
+            }
+        });
+        // Handle RETURN clause if present
+        const returnClause = query.clauses.find((c) => c.type === "RETURN");
+        if (returnClause) {
+            return this.executeForeachReturn(returnClause, context, params);
+        }
+        return [];
+    }
+    /**
+     * Execute a FOREACH clause within PhaseContext.
+     */
+    executeForeachClause(foreachClause, context, params) {
+        for (const row of context.rows) {
+            // Evaluate the list expression in the current row context
+            const listValue = this.evaluateExpressionInRow(foreachClause.expression, row, params);
+            if (!Array.isArray(listValue)) {
+                continue;
+            }
+            // For each item in the list, execute the body clauses
+            for (const item of listValue) {
+                // Create a row context with the iteration variable bound
+                const iterationRow = new Map(row);
+                iterationRow.set(foreachClause.variable, item);
+                // Execute each body clause
+                for (const bodyClause of foreachClause.body) {
+                    this.executeForeachBodyClause(bodyClause, iterationRow, context, params);
+                }
+            }
+        }
+    }
+    /**
+     * Execute a single clause within FOREACH body.
+     */
+    executeForeachBodyClause(clause, row, context, params) {
+        switch (clause.type) {
+            case "SET":
+                this.executeForeachSetInRow(clause, row, params);
+                break;
+            case "CREATE":
+                this.executeForeachCreateInRow(clause, row, params);
+                break;
+            case "DELETE":
+                this.executeForeachDeleteInRow(clause, row);
+                break;
+            case "FOREACH":
+                // Nested FOREACH - create temporary context with single row
+                const tempContext = {
+                    nodeIds: new Map(context.nodeIds),
+                    edgeIds: new Map(context.edgeIds),
+                    values: new Map(context.values),
+                    rows: [row],
+                };
+                this.executeForeachClause(clause, tempContext, params);
+                break;
+            default:
+                throw new Error(`Unsupported clause type '${clause.type}' in FOREACH body`);
+        }
+    }
+    /**
+     * Execute SET within FOREACH context using Map-based row.
+     */
+    executeForeachSetInRow(clause, row, params) {
+        for (const assignment of clause.assignments) {
+            const targetVar = assignment.variable;
+            const targetObj = row.get(targetVar);
+            if (!targetObj || typeof targetObj !== "object") {
+                continue;
+            }
+            const target = targetObj;
+            // Support both _nf_id (node) and _id (edge)
+            const nodeId = target._nf_id || target._id;
+            if (!nodeId) {
+                continue;
+            }
+            // Determine if this is a node or edge based on which id field exists
+            const isNode = "_nf_id" in target;
+            const table = isNode ? "nodes" : "edges";
+            if (assignment.value) {
+                const newValue = this.evaluateExpressionInRow(assignment.value, row, params);
+                if (assignment.property) {
+                    // SET n.prop = value
+                    const propName = assignment.property;
+                    const sql = `UPDATE ${table} SET properties = json_set(properties, '$.${propName}', json(?)) WHERE id = ?`;
+                    this.db.execute(sql, [JSON.stringify(newValue), nodeId]);
+                    // Update the row object so subsequent iterations see the new value
+                    target[propName] = newValue;
+                }
+                else if (assignment.mergeProps) {
+                    // SET n += {...}
+                    if (typeof newValue === "object" && newValue !== null) {
+                        const propsJson = JSON.stringify(newValue);
+                        const sql = `UPDATE ${table} SET properties = json_patch(properties, ?) WHERE id = ?`;
+                        this.db.execute(sql, [propsJson, nodeId]);
+                    }
+                }
+                else if (assignment.replaceProps) {
+                    // SET n = {...}
+                    if (typeof newValue === "object" && newValue !== null) {
+                        const propsJson = JSON.stringify(newValue);
+                        const sql = `UPDATE ${table} SET properties = ? WHERE id = ?`;
+                        this.db.execute(sql, [propsJson, nodeId]);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Execute CREATE within FOREACH context using Map-based row.
+     */
+    executeForeachCreateInRow(clause, row, _params) {
+        for (const pattern of clause.patterns) {
+            if (this.isRelationshipPattern(pattern)) {
+                const relPattern = pattern;
+                const sourceNode = row.get(relPattern.source.variable ?? "");
+                const targetNode = row.get(relPattern.target.variable ?? "");
+                if (sourceNode?._id && targetNode?._id && relPattern.edge.type) {
+                    const props = relPattern.edge.properties || {};
+                    const propsJson = JSON.stringify(props);
+                    this.db.execute("INSERT INTO edges (source, target, type, properties) VALUES (?, ?, ?, ?)", [sourceNode._id, targetNode._id, relPattern.edge.type, propsJson]);
+                }
+            }
+            else {
+                const nodePattern = pattern;
+                const label = nodePattern.label;
+                const labels = Array.isArray(label) ? label : (label ? [label] : []);
+                const props = nodePattern.properties || {};
+                const propsJson = JSON.stringify(props);
+                const labelsJson = JSON.stringify(labels);
+                const result = this.db.execute("INSERT INTO nodes (labels, properties) VALUES (?, ?)", [labelsJson, propsJson]);
+                if (nodePattern.variable && result.lastInsertRowid) {
+                    row.set(nodePattern.variable, {
+                        _id: result.lastInsertRowid,
+                        _labels: labels,
+                        ...props,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Execute DELETE within FOREACH context using Map-based row.
+     */
+    executeForeachDeleteInRow(clause, row) {
+        if (!clause.expressions)
+            return;
+        for (const expr of clause.expressions) {
+            if (expr.type === "variable" && expr.variable) {
+                const target = row.get(expr.variable);
+                if (target?._id !== undefined) {
+                    const isNode = "_labels" in target;
+                    if (isNode) {
+                        if (clause.detach) {
+                            this.db.execute("DELETE FROM edges WHERE source = ? OR target = ?", [target._id, target._id]);
+                        }
+                        this.db.execute("DELETE FROM nodes WHERE id = ?", [target._id]);
+                    }
+                    else {
+                        this.db.execute("DELETE FROM edges WHERE id = ?", [target._id]);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Execute SET clause within PhaseContext (not inside FOREACH iteration).
+     */
+    executeForeachSetClause(clause, context, params) {
+        for (const row of context.rows) {
+            this.executeForeachSetInRow(clause, row, params);
+        }
+    }
+    /**
+     * Execute RETURN clause for FOREACH execution path.
+     */
+    executeForeachReturn(clause, context, params) {
+        const resultRows = [];
+        for (const row of context.rows) {
+            const resultRow = {};
+            for (const item of clause.items) {
+                const alias = item.alias || this.getForeachExpressionName(item.expression);
+                const value = this.evaluateExpressionInRow(item.expression, row, params);
+                resultRow[alias] = value;
+            }
+            resultRows.push(resultRow);
+        }
+        return resultRows;
+    }
+    /**
+     * Get expression name for FOREACH return aliases.
+     */
+    getForeachExpressionName(expr) {
+        switch (expr.type) {
+            case "variable":
+                return expr.variable || "value";
+            case "property":
+                return `${expr.variable}.${expr.property}`;
+            case "function":
+                return expr.functionName?.toLowerCase() || "value";
+            default:
+                return "value";
+        }
+    }
     /**
      * Detect and handle patterns that need multi-phase execution:
      * - MATCH...CREATE that references matched variables
@@ -7770,10 +8635,10 @@ export class Executor {
                             for (const resolvedIds of allResolvedIds) {
                                 const nodeId = resolvedIds[varName];
                                 if (nodeId) {
-                                    const nodeResult = this.db.execute("SELECT properties FROM nodes WHERE id = ?", [nodeId]);
+                                    const nodeResult = this.db.execute("SELECT id, properties FROM nodes WHERE id = ?", [nodeId]);
                                     if (nodeResult.rows.length > 0) {
                                         const row = nodeResult.rows[0];
-                                        values.push(typeof row.properties === "string" ? JSON.parse(row.properties) : row.properties);
+                                        values.push(this.getNodeProperties(row.id, row.properties));
                                     }
                                 }
                             }
@@ -7879,9 +8744,7 @@ export class Executor {
                             if (nodeResult.rows.length > 0) {
                                 const row = nodeResult.rows[0];
                                 // Neo4j 3.5 format: return properties directly
-                                resultRow[alias] = typeof row.properties === "string"
-                                    ? JSON.parse(row.properties)
-                                    : row.properties;
+                                resultRow[alias] = this.getNodeProperties(row.id, row.properties);
                             }
                             else {
                                 // Try edges
@@ -7889,9 +8752,7 @@ export class Executor {
                                 if (edgeResult.rows.length > 0) {
                                     const row = edgeResult.rows[0];
                                     // Neo4j 3.5 format: return properties directly
-                                    resultRow[alias] = typeof row.properties === "string"
-                                        ? JSON.parse(row.properties)
-                                        : row.properties;
+                                    resultRow[alias] = this.getEdgeProperties(row.id, row.properties);
                                 }
                             }
                         }
@@ -8104,6 +8965,8 @@ export class Executor {
                 if (nodeResult.changes === 0) {
                     this.db.execute(`UPDATE edges SET properties = ? WHERE id = ?`, [JSON.stringify(filteredProps), nodeId]);
                 }
+                // Invalidate cache after UPDATE
+                this.invalidatePropertyCache(nodeId);
                 continue;
             }
             // Handle SET n += {props} - merge properties
@@ -8137,6 +9000,8 @@ export class Executor {
                         this.db.execute(`UPDATE edges SET properties = json_patch(properties, ?) WHERE id = ?`, [JSON.stringify(nonNullProps), nodeId]);
                     }
                 }
+                // Invalidate cache after UPDATE
+                this.invalidatePropertyCache(nodeId);
                 continue;
             }
             // Handle property assignments
@@ -8144,7 +9009,7 @@ export class Executor {
                 throw new Error(`Invalid SET assignment for variable: ${assignment.variable}`);
             }
             // Use context-aware evaluation for expressions that may reference properties
-            const value = assignment.value.type === "binary" || assignment.value.type === "property"
+            const value = assignment.value.type === "binary" || assignment.value.type === "property" || assignment.value.type === "case"
                 ? this.evaluateExpressionWithContext(assignment.value, params, resolvedIds)
                 : this.evaluateExpression(assignment.value, params);
             // If value is null, remove the property instead of setting it to null
@@ -8164,6 +9029,8 @@ export class Executor {
                     this.db.execute(`UPDATE edges SET properties = json_set(properties, '$.${assignment.property}', json(?)) WHERE id = ?`, [JSON.stringify(value), nodeId]);
                 }
             }
+            // Invalidate cache after UPDATE
+            this.invalidatePropertyCache(nodeId);
         }
     }
     /**
@@ -8219,6 +9086,28 @@ export class Executor {
         }
         return deletedVariables;
     }
+    /**
+     * Build a row context from resolved node/edge IDs for condition evaluation
+     */
+    buildRowFromResolvedIds(resolvedIds) {
+        const row = {};
+        for (const [varName, entityId] of Object.entries(resolvedIds)) {
+            // Try to get properties from nodes first
+            const nodeResult = this.db.execute(`SELECT properties FROM nodes WHERE id = ?`, [entityId]);
+            if (nodeResult.rows.length > 0) {
+                const props = JSON.parse(nodeResult.rows[0].properties || "{}");
+                row[varName] = props;
+                continue;
+            }
+            // Try edges
+            const edgeResult = this.db.execute(`SELECT properties FROM edges WHERE id = ?`, [entityId]);
+            if (edgeResult.rows.length > 0) {
+                const props = JSON.parse(edgeResult.rows[0].properties || "{}");
+                row[varName] = props;
+            }
+        }
+        return row;
+    }
     /**
      * Evaluate an expression to get its value
      * Note: For property and binary expressions that reference nodes, use evaluateExpressionWithContext
@@ -8329,6 +9218,19 @@ export class Executor {
                 const args = expr.args || [];
                 return this.evaluateFunctionInProperty(funcName, args, params, {});
             }
+            case "case": {
+                // Evaluate CASE WHEN ... THEN ... ELSE ... END
+                // Build a row context from resolvedIds for condition evaluation
+                const row = this.buildRowFromResolvedIds(resolvedIds);
+                if (expr.whens) {
+                    for (const when of expr.whens) {
+                        if (this.evaluateWhereConditionOnRow(when.condition, row, params)) {
+                            return this.evaluateExpressionWithContext(when.result, params, resolvedIds);
+                        }
+                    }
+                }
+                return expr.elseExpr ? this.evaluateExpressionWithContext(expr.elseExpr, params, resolvedIds) : null;
+            }
             default:
                 throw new Error(`Cannot evaluate expression of type ${expr.type}`);
         }
@@ -8518,21 +9420,26 @@ export class Executor {
     /**
      * Generate SQL condition for label matching
      * Supports both single and multiple labels
+     * Uses primary label index with fallback for secondary labels
      */
     generateLabelCondition(label) {
         const labels = Array.isArray(label) ? label : [label];
         if (labels.length === 1) {
             return {
-                sql: `EXISTS (SELECT 1 FROM json_each(label) WHERE value = ?)`,
-                params: [labels[0]]
+                sql: `(json_extract(label, '$[0]') = ? OR EXISTS (SELECT 1 FROM json_each(label) WHERE value = ? AND json_extract(label, '$[0]') != ?))`,
+                params: [labels[0], labels[0], labels[0]]
             };
         }
         else {
-            // Multiple labels: all must exist
-            const conditions = labels.map(() => `EXISTS (SELECT 1 FROM json_each(label) WHERE value = ?)`);
+            // Multiple labels: all must exist (each uses indexed primary label check with fallback)
+            const conditions = labels.map(() => `(json_extract(label, '$[0]') = ? OR EXISTS (SELECT 1 FROM json_each(label) WHERE value = ? AND json_extract(label, '$[0]') != ?))`);
+            const params = [];
+            for (const l of labels) {
+                params.push(l, l, l);
+            }
             return {
                 sql: conditions.join(" AND "),
-                params: labels
+                params
             };
         }
     }