leangraph 1.1.1 → 1.1.3

package/dist/translator.js

@@ -102,7 +102,17 @@ export class Translator {
             statements.push({ sql, params });
             returnColumns = [callClause.returnColumn];
         }
-        return { statements, returnColumns };
+        // Handle EXPLAIN and PROFILE - prefix all SELECT statements with EXPLAIN QUERY PLAN
+        if (query.explain || query.profile) {
+            for (const stmt of statements) {
+                if (stmt.sql.trim().toUpperCase().startsWith("SELECT")) {
+                    stmt.sql = `EXPLAIN QUERY PLAN ${stmt.sql}`;
+                }
+            }
+            // For explain/profile, the return columns are the plan columns
+            returnColumns = ["id", "parent", "notused", "detail"];
+        }
+        return { statements, returnColumns, explain: query.explain, profile: query.profile };
     }
     /**
      * Validate and translate a SKIP or LIMIT expression
@@ -151,6 +161,10 @@ export class Translator {
                 return this.translateUnion(clause);
             case "CALL":
                 return this.translateCall(clause);
+            case "CREATE_INDEX":
+                return { statements: this.translateCreateIndex(clause) };
+            case "DROP_INDEX":
+                return { statements: this.translateDropIndex(clause) };
             default:
                 throw new Error(`Unknown clause type: ${clause.type}`);
         }
@@ -188,7 +202,7 @@ export class Translator {
             ? (Array.isArray(node.label) ? node.label : [node.label])
             : [];
         const labelJson = JSON.stringify(labelArray);
-        const properties = this.serializeProperties(node.properties || {});
+        const properties = this.serializeNodePatternProperties(node);
         if (node.variable) {
             this.ctx.variables.set(node.variable, { type: "node", alias: id });
             // Store the resolved properties so later nodes in the same CREATE can reference them
@@ -202,6 +216,24 @@ export class Translator {
             params: [id, labelJson, properties.json],
         };
     }
+    serializeNodePatternProperties(node) {
+        const literal = this.serializeProperties(node.properties || {});
+        if (!node.propertiesParam) {
+            return literal;
+        }
+        const paramValue = this.ctx.paramValues[node.propertiesParam.name];
+        if (paramValue === undefined || paramValue === null) {
+            return literal;
+        }
+        if (typeof paramValue !== "object" || Array.isArray(paramValue)) {
+            throw new Error(`Expected parameter $${node.propertiesParam.name} to be a map`);
+        }
+        const merged = {
+            ...paramValue,
+            ...JSON.parse(literal.json),
+        };
+        return { json: JSON.stringify(merged), params: [] };
+    }
     translateCreateRelationship(rel) {
         const statements = [];
         // Create source node if it has a label (new node)
@@ -211,7 +243,7 @@ export class Translator {
             if (existing) {
                 // Variable already bound - check for label or property conflict
                 // In CREATE, you cannot rebind a variable with new properties/labels
-                if (rel.source.label || rel.source.properties) {
+                if (rel.source.label || rel.source.properties || rel.source.propertiesParam) {
                     throw new Error(`Variable \`${rel.source.variable}\` already declared`);
                 }
                 // Use the actual ID if available (from MERGE), otherwise use alias (from CREATE)
@@ -237,7 +269,7 @@ export class Translator {
             if (existing) {
                 // Variable already bound - check for label or property conflict
                 // In CREATE, you cannot rebind a variable with new properties/labels
-                if (rel.target.label || rel.target.properties) {
+                if (rel.target.label || rel.target.properties || rel.target.propertiesParam) {
                     throw new Error(`Variable \`${rel.target.variable}\` already declared`);
                 }
                 // Use the actual ID if available (from MERGE), otherwise use alias (from CREATE)
@@ -272,6 +304,28 @@ export class Translator {
         return statements;
     }
     // ============================================================================
+    // CREATE INDEX / DROP INDEX
+    // ============================================================================
+    /**
+     * Translate CREATE INDEX to SQL.
+     * Creates a global index on a JSON property (not filtered by label).
+     *
+     * Syntax: CREATE INDEX [name] ON [:Label](property)
+     * The :Label is optional and ignored (global index) - only used if no custom name provided.
+     */
+    translateCreateIndex(clause) {
+        const indexName = clause.indexName || `idx_${clause.property}`;
+        const sql = `CREATE INDEX IF NOT EXISTS ${indexName} ON nodes(json_extract(properties, '$.${clause.property}'))`;
+        return [{ sql, params: [] }];
+    }
+    /**
+     * Translate DROP INDEX to SQL.
+     */
+    translateDropIndex(clause) {
+        const sql = `DROP INDEX IF EXISTS ${clause.indexName}`;
+        return [{ sql, params: [] }];
+    }
+    // ============================================================================
     // MATCH
     // ============================================================================
     translateMatch(clause, optional = false) {
@@ -1068,11 +1122,18 @@ export class Translator {
         // Validate ORDER BY with aggregation
         // When aggregation is used in RETURN/WITH, ORDER BY expressions with mixed aggregate/non-aggregate
         // are not allowed unless the non-aggregate parts are in an implicit GROUP BY
+        // Note: Only validate the RETURN clause's own ORDER BY, not a previous WITH's ORDER BY.
+        // A WITH clause's ORDER BY applies to pre-aggregation rows and was already validated against WITH items.
         const hasAggregation = clause.items.some(item => this.isAggregateExpression(item.expression));
-        const prevWithOrderBy = this.ctx.withOrderBy;
-        const orderByToValidate = clause.orderBy && clause.orderBy.length > 0 ? clause.orderBy : prevWithOrderBy;
-        if (hasAggregation && orderByToValidate && orderByToValidate.length > 0) {
-            this.validateAggregationOrderBy(clause, orderByToValidate);
+        if (hasAggregation && clause.orderBy && clause.orderBy.length > 0) {
+            this.validateAggregationOrderBy(clause, clause.orderBy);
+        }
+        // When RETURN has aggregation and there's a previous WITH ORDER BY (or row ordering),
+        // use that to order values within COLLECT() functions. This enables patterns like:
+        // UNWIND [3,1,2] as n WITH n ORDER BY n RETURN collect(n) -> [1,2,3]
+        const rowOrderBy = this.ctx.rowOrderBy;
+        if (hasAggregation && rowOrderBy && rowOrderBy.length > 0) {
+            this.ctx.collectOrderBy = rowOrderBy;
         }
         const selectParts = [];
         const returnColumns = [];
@@ -1192,11 +1253,28 @@ export class Translator {
                 aggregateAliasesInListPredicates.add(alias);
             }
         }
-        // If we have any aggregate aliases used in list predicates, we need a CTE
-        const needsAggregateCTE = aggregateAliasesInListPredicates.size > 0;
+        // Check for "double aggregation" - when RETURN has aggregates that reference WITH aggregates.
+        // This causes nested aggregate function errors in SQLite (e.g., collect({v: vals}) where vals = collect(...))
+        // We need to materialize the WITH aggregates in a CTE first.
+        const aggregateAliasesInReturnAggregates = new Set();
+        if (hasAggregation && withAliasesForCheck) {
+            for (const item of clause.items) {
+                const aliases = this.collectWithAggregateAliasesFromAggregateExpressions(item.expression, withAliasesForCheck);
+                for (const alias of aliases) {
+                    aggregateAliasesInReturnAggregates.add(alias);
+                }
+            }
+        }
+        // Combine both sets of aliases that need materialization
+        const allAggregateAliasesToMaterialize = new Set([
+            ...aggregateAliasesInListPredicates,
+            ...aggregateAliasesInReturnAggregates
+        ]);
+        // If we have any aggregate aliases that need materialization, we need a CTE
+        const needsAggregateCTE = allAggregateAliasesToMaterialize.size > 0;
         if (needsAggregateCTE) {
             // Mark the context so translateExpression knows to use column references instead of re-translating
-            this.ctx.materializedAggregateAliases = aggregateAliasesInListPredicates;
+            this.ctx.materializedAggregateAliases = allAggregateAliasesToMaterialize;
             // Also mark that we need to use __aggregates__ as the FROM source
             this.ctx.useAggregatesCTE = true;
         }
@@ -1237,7 +1315,7 @@ export class Translator {
             const { sql: exprSql, tables, params: itemParams } = this.translateExpression(item.expression);
             tables.forEach((t) => neededTables.add(t));
             exprParams.push(...itemParams);
-            const alias = item.alias || this.getExpressionName(item.expression);
+            const alias = this.getReturnItemName(item);
             returnAliasExpressions.set(alias, item.expression);
             selectParts.push(`${exprSql} AS ${this.quoteAlias(alias)}`);
             returnColumns.push(alias);
@@ -2319,7 +2397,7 @@ export class Translator {
                         // Computed expression - need to translate it
                         const { sql: exprSql, params: exprParams } = this.translateExpression(item.expression);
                         whereParams.push(...exprParams);
-                        const alias = item.alias || this.getExpressionName(item.expression);
+                        const alias = this.getReturnItemName(item);
                         withSelectParts.push(`${exprSql} AS "${alias}"`);
                     }
                     else {
@@ -2421,6 +2499,12 @@ export class Translator {
                 sql += ` WHERE ${whereParts.join(" AND ")}`;
             }
         }
+        else if (whereParts.length > 0) {
+            // If we have WHERE but no FROM or JOINs, we need a dummy FROM clause
+            // This happens with queries like: WITH [1,2,3] as nums WHERE all(x IN nums WHERE x > 0) RETURN nums
+            sql += ` FROM (SELECT 1) __dummy__`;
+            sql += ` WHERE ${whereParts.join(" AND ")}`;
+        }
         // Add GROUP BY for aggregation (from WITH or RETURN clauses)
         // When we have aggregates mixed with non-aggregates, non-aggregate expressions become GROUP BY keys
         const groupByParts = [];
@@ -2528,44 +2612,123 @@ export class Translator {
         const materializedAggregates = this.ctx.materializedAggregateAliases;
         const useAggregatesCTE = this.ctx.useAggregatesCTE;
         if (materializedAggregates && materializedAggregates.size > 0 && useAggregatesCTE) {
-            // Build the CTE that computes the aggregates
-            const cteSelectParts = [];
-            const cteParams = [];
             const withAliasesFinal = this.ctx.withAliases;
-            for (const aliasName of materializedAggregates) {
-                if (withAliasesFinal && withAliasesFinal.has(aliasName)) {
-                    const originalExpr = withAliasesFinal.get(aliasName);
-                    // Temporarily clear materializedAggregateAliases to get the actual aggregate SQL
+            const lastWithClause = this.ctx.withClauses?.[this.ctx.withClauses.length - 1];
+            // Check if this is a MATCH-based double aggregation (WITH has aggregates from MATCH)
+            // In this case we need to build a complete CTE with all WITH items, FROM, WHERE, GROUP BY
+            // We distinguish between MATCH-based (which uses nodes/edges tables) and UNWIND-based
+            // (which uses json_each). For UNWIND-only queries, we use the original CTE logic.
+            // MATCH creates pattern_${alias} entries in context, while UNWIND does not.
+            const hasMatchPatterns = Object.keys(this.ctx).some(k => k.startsWith("pattern_"));
+            const hasMatchBasedAggregation = lastWithClause &&
+                lastWithClause.items.some(item => this.isAggregateExpression(item.expression)) &&
+                hasMatchPatterns;
+            if (hasMatchBasedAggregation && lastWithClause && withAliasesFinal) {
+                // Build a complete CTE that materializes the entire WITH clause
+                const cteSelectParts = [];
+                const cteGroupByParts = [];
+                const cteParams = [];
+                // Include ALL WITH items in the CTE (both aggregate and non-aggregate)
+                // This is needed so the main query can reference all WITH aliases
+                for (const item of lastWithClause.items) {
+                    const aliasName = this.getReturnItemName(item);
+                    // Temporarily clear materializedAggregateAliases to get the actual SQL
                     this.ctx.materializedAggregateAliases = undefined;
-                    const { sql: aggSql, params: aggParams } = this.translateExpression(originalExpr);
+                    const { sql: itemSql, params: itemParams } = this.translateExpression(item.expression);
                     this.ctx.materializedAggregateAliases = materializedAggregates;
-                    cteSelectParts.push(`${aggSql} AS "${aliasName}"`);
-                    cteParams.push(...aggParams);
-                }
-            }
-            if (cteSelectParts.length > 0) {
-                // Build the CTE FROM clause (same as main query's FROM)
-                // We need to replicate the UNWIND/FROM structure
-                const unwindClausesFinal = this.ctx.unwindClauses;
-                let cteFrom = "";
-                if (unwindClausesFinal && unwindClausesFinal.length > 0) {
-                    const cteParts = [];
-                    for (const unwind of unwindClausesFinal) {
-                        cteParts.push(`json_each(${unwind.jsonExpr}) ${unwind.alias}`);
-                        cteParams.push(...unwind.params);
+                    cteSelectParts.push(`${itemSql} AS "${aliasName}"`);
+                    cteParams.push(...itemParams);
+                    // Non-aggregate items become GROUP BY keys
+                    if (!this.isAggregateExpression(item.expression)) {
+                        // Re-translate for GROUP BY (might need different SQL for grouping)
+                        this.ctx.materializedAggregateAliases = undefined;
+                        const { sql: groupSql, params: groupParams } = this.translateExpression(item.expression);
+                        this.ctx.materializedAggregateAliases = materializedAggregates;
+                        cteGroupByParts.push(groupSql);
+                        // Don't double-add params - they're already in cteParams from SELECT
                     }
-                    cteFrom = cteParts.join(" CROSS JOIN ");
                 }
-                // Build the CTE SQL
-                let cteSql = `WITH __aggregates__ AS (SELECT ${cteSelectParts.join(", ")}`;
-                if (cteFrom) {
-                    cteSql += ` FROM ${cteFrom}`;
+                // Build the CTE with full FROM/JOIN and WHERE from the main query
+                let cteSql = `WITH __with_results__ AS (SELECT ${cteSelectParts.join(", ")}`;
+                // Add FROM clause
+                if (fromParts.length > 0) {
+                    cteSql += ` FROM ${fromParts.join(", ")}`;
+                }
+                // Add JOINs
+                if (joinParts.length > 0) {
+                    cteSql += ` ${joinParts.join(" ")}`;
+                    cteParams.push(...joinParams);
+                }
+                // Add WHERE conditions
+                if (whereParts.length > 0) {
+                    cteSql += ` WHERE ${whereParts.join(" AND ")}`;
+                    cteParams.push(...whereParams);
+                }
+                // Add GROUP BY for non-aggregate items
+                if (cteGroupByParts.length > 0) {
+                    cteSql += ` GROUP BY ${cteGroupByParts.join(", ")}`;
                 }
                 cteSql += `) `;
-                // Prepend CTE to main query
-                sql = cteSql + sql;
-                // Prepend CTE params (only CTE params, exprParams don't use UNWIND params since we use CTE)
-                allParams = [...cteParams];
+                // Now rebuild the main query to SELECT from the CTE
+                // The RETURN expressions need to reference CTE columns instead of table columns
+                const mainSelectParts = [];
+                const mainParams = [];
+                // Store mapping of WITH aliases to CTE column references
+                const cteColumnMap = new Map();
+                for (const item of lastWithClause.items) {
+                    const aliasName = this.getReturnItemName(item);
+                    cteColumnMap.set(aliasName, `__with_results__."${aliasName}"`);
+                }
+                // Rebuild RETURN expressions using CTE column references
+                for (const item of clause.items) {
+                    const alias = this.getReturnItemName(item);
+                    // Translate expression with CTE column mapping
+                    const exprSql = this.translateExpressionWithCTEMapping(item.expression, cteColumnMap, mainParams);
+                    mainSelectParts.push(`${exprSql} AS ${this.quoteAlias(alias)}`);
+                }
+                // Build the main query that selects from the CTE
+                sql = cteSql + `SELECT ${mainSelectParts.join(", ")} FROM __with_results__`;
+                allParams = [...cteParams, ...mainParams];
+            }
+            else {
+                // Original CTE logic for UNWIND-based cases
+                const cteSelectParts = [];
+                const cteParams = [];
+                for (const aliasName of materializedAggregates) {
+                    if (withAliasesFinal && withAliasesFinal.has(aliasName)) {
+                        const originalExpr = withAliasesFinal.get(aliasName);
+                        // Temporarily clear materializedAggregateAliases to get the actual aggregate SQL
+                        this.ctx.materializedAggregateAliases = undefined;
+                        const { sql: aggSql, params: aggParams } = this.translateExpression(originalExpr);
+                        this.ctx.materializedAggregateAliases = materializedAggregates;
+                        cteSelectParts.push(`${aggSql} AS "${aliasName}"`);
+                        cteParams.push(...aggParams);
+                    }
+                }
+                if (cteSelectParts.length > 0) {
+                    // Build the CTE FROM clause (same as main query's FROM)
+                    // We need to replicate the UNWIND/FROM structure
+                    const unwindClausesFinal = this.ctx.unwindClauses;
+                    let cteFrom = "";
+                    if (unwindClausesFinal && unwindClausesFinal.length > 0) {
+                        const cteParts = [];
+                        for (const unwind of unwindClausesFinal) {
+                            cteParts.push(`json_each(${unwind.jsonExpr}) ${unwind.alias}`);
+                            cteParams.push(...unwind.params);
+                        }
+                        cteFrom = cteParts.join(" CROSS JOIN ");
+                    }
+                    // Build the CTE SQL
+                    let cteSql = `WITH __aggregates__ AS (SELECT ${cteSelectParts.join(", ")}`;
+                    if (cteFrom) {
+                        cteSql += ` FROM ${cteFrom}`;
+                    }
+                    cteSql += `) `;
+                    // Prepend CTE to main query
+                    sql = cteSql + sql;
+                    // Prepend CTE params (only CTE params, exprParams don't use UNWIND params since we use CTE)
+                    allParams = [...cteParams];
+                }
             }
             // Clean up context
             this.ctx.materializedAggregateAliases = undefined;
@@ -2892,7 +3055,7 @@ export class Translator {
                 exprSql = translated.sql;
                 params.push(...translated.params);
             }
-            const alias = item.alias || this.getExpressionName(item.expression);
+            const alias = this.getReturnItemName(item);
             selectParts.push(`${exprSql} AS ${this.quoteAlias(alias)}`);
             returnColumns.push(alias);
         }
@@ -4108,6 +4271,98 @@ export class Translator {
         }
         return undefined;
     }
+    /**
+     * Translate an expression, substituting WITH alias references with CTE column references.
+     * This is used when we've materialized WITH results in a CTE and need to build
+     * the RETURN query that references those CTE columns.
+     */
+    translateExpressionWithCTEMapping(expr, cteColumnMap, params) {
+        switch (expr.type) {
+            case "variable": {
+                const varName = expr.variable;
+                // Check if this is a WITH alias that maps to a CTE column
+                if (cteColumnMap.has(varName)) {
+                    return cteColumnMap.get(varName);
+                }
+                // For other variables, translate normally
+                const { sql, params: exprParams } = this.translateExpression(expr);
+                params.push(...exprParams);
+                return sql;
+            }
+            case "function": {
+                const funcName = (expr.functionName || expr.name || "").toLowerCase();
+                const args = expr.args || [];
+                // Handle aggregate functions
+                if (funcName === "collect") {
+                    // collect({...}) becomes json_group_array(json_object(...))
+                    if (args.length === 1 && args[0].type === "object") {
+                        const objExpr = args[0];
+                        const objParts = [];
+                        for (const prop of objExpr.properties || []) {
+                            const key = prop.key;
+                            const valueSql = this.translateExpressionWithCTEMapping(prop.value, cteColumnMap, params);
+                            objParts.push(`?`);
+                            params.push(key);
+                            objParts.push(valueSql);
+                        }
+                        return `json_group_array(json_object(${objParts.join(", ")}))`;
+                    }
+                    // Simple collect
+                    const argSql = this.translateExpressionWithCTEMapping(args[0], cteColumnMap, params);
+                    return `json_group_array(${argSql})`;
+                }
+                // For other functions, translate arguments with CTE mapping
+                const argSqls = args.map(arg => this.translateExpressionWithCTEMapping(arg, cteColumnMap, params));
+                // Map function names to SQL
+                const funcNameUpper = funcName.toUpperCase();
+                if (["COUNT", "SUM", "AVG", "MIN", "MAX"].includes(funcNameUpper)) {
+                    return `${funcNameUpper}(${argSqls.join(", ")})`;
+                }
+                // Fall back to standard translation for other functions
+                const { sql, params: funcParams } = this.translateExpression(expr);
+                params.push(...funcParams);
+                return sql;
+            }
+            case "object": {
+                // json_object('key1', val1, 'key2', val2, ...)
+                const objParts = [];
+                for (const prop of expr.properties || []) {
+                    const key = prop.key;
+                    const valueSql = this.translateExpressionWithCTEMapping(prop.value, cteColumnMap, params);
+                    objParts.push(`?`);
+                    params.push(key);
+                    objParts.push(valueSql);
+                }
+                return `json_object(${objParts.join(", ")})`;
+            }
+            case "literal": {
+                if (expr.value === null)
+                    return "NULL";
+                if (typeof expr.value === "boolean") {
+                    params.push(expr.value ? 1 : 0);
+                    return "?";
+                }
+                if (typeof expr.value === "number" || typeof expr.value === "string") {
+                    params.push(expr.value);
+                    return "?";
+                }
+                const { sql, params: litParams } = this.translateExpression(expr);
+                params.push(...litParams);
+                return sql;
+            }
+            case "binary": {
+                const leftSql = this.translateExpressionWithCTEMapping(expr.left, cteColumnMap, params);
+                const rightSql = this.translateExpressionWithCTEMapping(expr.right, cteColumnMap, params);
+                return `(${leftSql} ${expr.operator} ${rightSql})`;
+            }
+            default: {
+                // Fall back to standard translation
+                const { sql, params: defaultParams } = this.translateExpression(expr);
+                params.push(...defaultParams);
+                return sql;
+            }
+        }
+    }
     translateExpression(expr) {
         const tables = [];
         const params = [];
@@ -4400,12 +4655,16 @@ export class Translator {
                                 // This variable is a WITH alias - translate the underlying expression and access the property
                                 const objectResult = this.translateExpression(originalExpr);
                                 tables.push(...objectResult.tables);
-                                params.push(...objectResult.params);
                                 // Check if this is a temporal property accessor (year, month, day, etc.)
-                                const temporalSql = this.translateTemporalPropertyAccess(objectResult.sql, expr.property);
-                                if (temporalSql) {
-                                    return { sql: temporalSql, tables, params };
+                                const temporalResult = this.translateTemporalPropertyAccess(objectResult.sql, expr.property);
+                                if (temporalResult) {
+                                    // Repeat the params for each occurrence of the base SQL in the temporal accessor
+                                    for (let i = 0; i < temporalResult.paramMultiplier; i++) {
+                                        params.push(...objectResult.params);
+                                    }
+                                    return { sql: temporalResult.sql, tables, params };
                                 }
+                                params.push(...objectResult.params);
                                 // Access property from the result using json_extract
                                 return {
                                     sql: `json_extract(${objectResult.sql}, '$.${expr.property}')`,
@@ -4436,9 +4695,10 @@ export class Translator {
                         // UNWIND variables use the 'value' column from json_each
                         const baseSql = `${unwindClause.alias}.value`;
                         // Check if this is a temporal property accessor
-                        const temporalSql = this.translateTemporalPropertyAccess(baseSql, expr.property);
-                        if (temporalSql) {
-                            return { sql: temporalSql, tables, params };
+                        const temporalResult = this.translateTemporalPropertyAccess(baseSql, expr.property);
+                        if (temporalResult) {
+                            // baseSql is a column reference (no params), so no need to repeat params
+                            return { sql: temporalResult.sql, tables, params };
                         }
                         // Access property from the unwound value using json_extract
                         return {
@@ -4483,6 +4743,30 @@ export class Translator {
                             };
                         }
                         else if (arg.type === "variable") {
+                            // Check if this is an UNWIND variable first
+                            const unwindClausesCount = this.ctx.unwindClauses;
+                            if (unwindClausesCount) {
+                                const unwindClause = unwindClausesCount.find(u => u.variable === arg.variable);
+                                if (unwindClause) {
+                                    // Check if UNWIND was consumed by MIN/MAX subquery
+                                    const consumedUnwinds = this.ctx.consumedUnwindClauses;
+                                    if (consumedUnwinds?.has(unwindClause.alias)) {
+                                        // UNWIND was consumed, use subquery
+                                        const alias = unwindClause.alias;
+                                        return {
+                                            sql: `(SELECT COUNT(${distinctKeyword}${alias}.value) FROM json_each(${unwindClause.jsonExpr}) ${alias})`,
+                                            tables: [],
+                                            params: [...params, ...unwindClause.params],
+                                        };
+                                    }
+                                    tables.push(unwindClause.alias);
+                                    return {
+                                        sql: `COUNT(${distinctKeyword}${unwindClause.alias}.value)`,
+                                        tables,
+                                        params,
+                                    };
+                                }
+                            }
                             const varInfo = this.ctx.variables.get(arg.variable);
                             if (!varInfo) {
                                 throw new Error(`Unknown variable: ${arg.variable}`);
@@ -4579,6 +4863,20 @@ export class Translator {
                         }
                         const distinctKeyword = expr.distinct ? "DISTINCT " : "";
                         if (arg.type === "property") {
+                            // First check if this is an UNWIND variable
+                            const unwindClauses = this.ctx.unwindClauses;
+                            if (unwindClauses) {
+                                const unwindClause = unwindClauses.find(u => u.variable === arg.variable);
+                                if (unwindClause) {
+                                    tables.push(unwindClause.alias);
+                                    // UNWIND variables use the 'value' column from json_each
+                                    return {
+                                        sql: `${expr.functionName}(${distinctKeyword}json_extract(${unwindClause.alias}.value, '$.${arg.property}'))`,
+                                        tables,
+                                        params,
+                                    };
+                                }
+                            }
                             const varInfo = this.ctx.variables.get(arg.variable);
                             if (!varInfo) {
                                 throw new Error(`Unknown variable: ${arg.variable}`);
@@ -4592,10 +4890,10 @@ export class Translator {
                             };
                         }
                         else if (arg.type === "variable") {
-                            // Check if this is an UNWIND variable first
-                            const unwindClauses = this.ctx.unwindClauses;
-                            if (unwindClauses) {
-                                const unwindClause = unwindClauses.find(u => u.variable === arg.variable);
+                            // Check if this is an UNWIND variable first (use different name to avoid shadowing)
+                            const unwindClausesVar = this.ctx.unwindClauses;
+                            if (unwindClausesVar) {
+                                const unwindClause = unwindClausesVar.find((u) => u.variable === arg.variable);
                                 if (unwindClause) {
                                     tables.push(unwindClause.alias);
                                     // For MIN/MAX on UNWIND variables, use type-aware comparison
@@ -4672,7 +4970,17 @@ export class Translator {
                                             };
                                         }
                                     }
-                                    // For other aggregates (SUM, AVG), use standard aggregation
+                                    // For other aggregates (SUM, AVG), check if UNWIND was consumed by subquery aggregate
+                                    const consumedUnwinds = this.ctx.consumedUnwindClauses;
+                                    if (consumedUnwinds?.has(unwindClause.alias)) {
+                                        // UNWIND was consumed by MIN/MAX subquery, use subquery for SUM/AVG too
+                                        const alias = unwindClause.alias;
+                                        return {
+                                            sql: `(SELECT ${expr.functionName}(${distinctKeyword}${alias}.value) FROM json_each(${unwindClause.jsonExpr}) ${alias})`,
+                                            tables: [], // Don't add to outer tables since we use subquery
+                                            params: [...params, ...unwindClause.params],
+                                        };
+                                    }
                                     // Check if this UNWIND variable was wrapped in a WITH subquery
                                     const subqueryColName = unwindClause.subqueryColumnName;
                                     const valueRef = subqueryColName
@@ -4697,8 +5005,8 @@ export class Translator {
                                 params,
                             };
                         }
-                        else if (arg.type === "function" || arg.type === "binary") {
-                            // Handle aggregates on expressions like sum(n.x * n.y) or min(length(p))
+                        else if (arg.type === "function" || arg.type === "binary" || arg.type === "case") {
+                            // Handle aggregates on expressions like sum(n.x * n.y), min(length(p)), or sum(CASE WHEN ... END)
                             const argResult = this.translateFunctionArg(arg);
                             tables.push(...argResult.tables);
                             params.push(...argResult.params);
@@ -4719,6 +5027,69 @@ export class Translator {
                     }
                     throw new Error(`${expr.functionName} requires a property, variable, or expression argument`);
                 }
+                // Standard deviation functions: STDEV (sample), STDEVP (population)
+                // Formula: sqrt((sum(x^2) - sum(x)^2/n) / (n-1)) for sample
+                //          sqrt((sum(x^2) - sum(x)^2/n) / n) for population
+                if (expr.functionName === "STDEV" || expr.functionName === "STDEVP") {
+                    if (expr.args && expr.args.length > 0) {
+                        const arg = expr.args[0];
+                        // Validate that the argument doesn't contain non-deterministic functions
+                        if (this.containsNonDeterministicFunction(arg)) {
+                            throw new Error(`SyntaxError: Can't use non-deterministic (random) functions inside of aggregate functions.`);
+                        }
+                        let valueSql;
+                        if (arg.type === "property") {
+                            const varInfo = this.ctx.variables.get(arg.variable);
+                            if (!varInfo) {
+                                throw new Error(`Unknown variable: ${arg.variable}`);
+                            }
+                            tables.push(varInfo.alias);
+                            valueSql = `json_extract(${varInfo.alias}.properties, '$.${arg.property}')`;
+                        }
+                        else if (arg.type === "variable") {
+                            // Check if this is an UNWIND variable
+                            const unwindClauses = this.ctx.unwindClauses;
+                            if (unwindClauses) {
+                                const unwindClause = unwindClauses.find(u => u.variable === arg.variable);
+                                if (unwindClause) {
+                                    tables.push(unwindClause.alias);
+                                    valueSql = `${unwindClause.alias}.value`;
+                                }
+                                else {
+                                    const varInfo = this.ctx.variables.get(arg.variable);
+                                    if (!varInfo) {
+                                        throw new Error(`Unknown variable: ${arg.variable}`);
+                                    }
+                                    tables.push(varInfo.alias);
+                                    valueSql = `${varInfo.alias}.id`;
+                                }
+                            }
+                            else {
+                                const varInfo = this.ctx.variables.get(arg.variable);
+                                if (!varInfo) {
+                                    throw new Error(`Unknown variable: ${arg.variable}`);
+                                }
+                                tables.push(varInfo.alias);
+                                valueSql = `${varInfo.alias}.id`;
+                            }
+                        }
+                        else {
+                            // Handle expressions
+                            const argResult = this.translateFunctionArg(arg);
+                            tables.push(...argResult.tables);
+                            params.push(...argResult.params);
+                            valueSql = argResult.sql;
+                        }
+                        // Use computational formula for standard deviation
+                        // Sample: sqrt((sum(x^2) - sum(x)^2/n) / (n-1))
+                        // Population: sqrt((sum(x^2) - sum(x)^2/n) / n)
+                        // Note: multiply by 1.0 to force float division in SQLite
+                        const divisor = expr.functionName === "STDEV" ? `(COUNT(${valueSql}) - 1)` : `COUNT(${valueSql})`;
+                        const formula = `CASE WHEN COUNT(${valueSql}) <= 1 THEN 0.0 ELSE sqrt((SUM(${valueSql} * ${valueSql}) - SUM(${valueSql}) * SUM(${valueSql}) * 1.0 / COUNT(${valueSql})) * 1.0 / ${divisor}) END`;
+                        return { sql: formula, tables, params };
+                    }
+                    throw new Error(`${expr.functionName.toLowerCase()} requires an argument`);
+                }
                 // Percentile functions: PERCENTILEDISC, PERCENTILECONT
                 // percentileDisc(value, percentile) - Returns discrete value at percentile position
                 // percentileCont(value, percentile) - Returns interpolated value at percentile position
@@ -4934,13 +5305,20 @@ END FROM (SELECT json_group_array(${valueExpr}) as sv))`,
                             if (unwindClauses) {
                                 const unwindClause = unwindClauses.find(u => u.variable === arg.variable);
                                 if (unwindClause) {
-                                    tables.push(unwindClause.alias);
+                                    // Check if this UNWIND variable was wrapped in a WITH subquery
+                                    const subqueryColName = unwindClause.subqueryColumnName;
+                                    const valueRef = subqueryColName
+                                        ? `__with_subquery__."${subqueryColName}"`
+                                        : `${unwindClause.alias}.value`;
+                                    if (!subqueryColName) {
+                                        tables.push(unwindClause.alias);
+                                    }
                                     // For UNWIND variables, collect the raw values from json_each
                                     if (useDistinct) {
                                         // Filter nulls using CASE WHEN ... IS NOT NULL
                                         params.push(...collectOrderParams);
                                         return {
-                                            sql: `COALESCE(json('[' || GROUP_CONCAT(DISTINCT CASE WHEN ${unwindClause.alias}.value IS NOT NULL THEN json_quote(${unwindClause.alias}.value) END${collectOrderClause}) || ']'), json('[]'))`,
+                                            sql: `COALESCE(json('[' || GROUP_CONCAT(DISTINCT CASE WHEN ${valueRef} IS NOT NULL THEN json_quote(${valueRef}) END${collectOrderClause}) || ']'), json('[]'))`,
                                             tables,
                                             params,
                                         };
@@ -4948,7 +5326,7 @@ END FROM (SELECT json_group_array(${valueExpr}) as sv))`,
                                     // Neo4j's collect() skips NULL values - use GROUP_CONCAT with null filtering
                                     params.push(...collectOrderParams);
                                     return {
-                                        sql: `COALESCE(json('[' || GROUP_CONCAT(CASE WHEN ${unwindClause.alias}.value IS NOT NULL THEN json_quote(${unwindClause.alias}.value) END${collectOrderClause}) || ']'), json('[]'))`,
+                                        sql: `COALESCE(json('[' || GROUP_CONCAT(CASE WHEN ${valueRef} IS NOT NULL THEN json_quote(${valueRef}) END${collectOrderClause}) || ']'), json('[]'))`,
                                         tables,
                                         params,
                                     };
@@ -5346,6 +5724,103 @@ END FROM (SELECT json_group_array(${valueExpr}) as sv))`,
                     }
                     throw new Error("coalesce requires at least one argument");
                 }
+                // EXISTS: check if map property exists
+                // This handles exists(m.prop) in RETURN context where m is a map
+                if (expr.functionName === "EXISTS") {
+                    if (expr.args && expr.args.length > 0) {
+                        const arg = expr.args[0];
+                        if (arg.type === "property") {
+                            const varName = arg.variable;
+                            const propName = arg.property;
+                            // Check if this is a node variable (has node info in variables)
+                            const varInfo = this.ctx.variables.get(varName);
+                            if (varInfo && (varInfo.type === "node" || varInfo.type === "edge")) {
+                                // For nodes/edges, check if property is not null in properties JSON
+                                const result = this.translateExpression(arg);
+                                tables.push(...result.tables);
+                                params.push(...result.params);
+                                return {
+                                    sql: `cypher_to_json_bool(${result.sql} IS NOT NULL)`,
+                                    tables,
+                                    params,
+                                };
+                            }
+                            // For maps (WITH alias or other), check if key exists in JSON object
+                            // json_type returns NULL if key doesn't exist, type name if it does
+                            const argResult = this.translateExpression({ type: "variable", variable: varName });
+                            tables.push(...argResult.tables);
+                            params.push(...argResult.params);
+                            return {
+                                sql: `cypher_to_json_bool(json_type(${argResult.sql}, '$.${propName}') IS NOT NULL)`,
+                                tables,
+                                params,
+                            };
+                        }
+                        // For other expressions passed to exists(), check IS NOT NULL
+                        const argResult = this.translateFunctionArg(arg);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return {
+                            sql: `cypher_to_json_bool(${argResult.sql} IS NOT NULL)`,
+                            tables,
+                            params,
+                        };
+                    }
+                    throw new Error("exists requires an argument");
+                }
+                // ============================================================================
+                // Spatial functions
+                // ============================================================================
+                // POINT: create a point from coordinates
+                // Supports: point({x: 0, y: 0}) for Cartesian
+                // and point({latitude: 48.8, longitude: 2.3}) for geographic
+                if (expr.functionName === "POINT") {
+                    if (expr.args && expr.args.length > 0) {
+                        const arg = expr.args[0];
+                        // The argument should be a map/object literal
+                        if (arg.type === "object") {
+                            // Build the point object from the map properties
+                            const properties = arg.properties || [];
+                            const pointProps = [];
+                            for (const prop of properties) {
+                                const keyName = prop.key;
+                                const valueResult = this.translateExpression(prop.value);
+                                tables.push(...valueResult.tables);
+                                params.push(...valueResult.params);
+                                pointProps.push({ key: keyName, sql: valueResult.sql });
+                            }
+                            // Build a JSON object with the point properties
+                            const jsonPairs = pointProps.map(p => `'${p.key}', ${p.sql}`).join(", ");
+                            return { sql: `json_object(${jsonPairs})`, tables, params };
+                        }
+                        // For non-literal map, pass through as-is (variable or parameter)
+                        const argResult = this.translateFunctionArg(arg);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: argResult.sql, tables, params };
+                    }
+                    throw new Error("point requires a map argument with coordinates");
+                }
+                // DISTANCE: calculate distance between two points
+                // For Cartesian: sqrt((x2-x1)^2 + (y2-y1)^2)
+                // For geographic: haversine formula
+                if (expr.functionName === "DISTANCE") {
+                    if (expr.args && expr.args.length >= 2) {
+                        const p1Result = this.translateFunctionArg(expr.args[0]);
+                        const p2Result = this.translateFunctionArg(expr.args[1]);
+                        tables.push(...p1Result.tables, ...p2Result.tables);
+                        params.push(...p1Result.params, ...p2Result.params);
+                        // Check if it's Cartesian (x,y) or geographic (latitude,longitude)
+                        // For simplicity, use Cartesian distance formula
+                        // Euclidean distance: sqrt((x2-x1)^2 + (y2-y1)^2)
+                        const sql = `(SELECT SQRT(
+              POWER(COALESCE(json_extract(p2, '$.x'), json_extract(p2, '$.longitude')) - COALESCE(json_extract(p1, '$.x'), json_extract(p1, '$.longitude')), 2) +
+              POWER(COALESCE(json_extract(p2, '$.y'), json_extract(p2, '$.latitude')) - COALESCE(json_extract(p1, '$.y'), json_extract(p1, '$.latitude')), 2)
+            ) FROM (SELECT ${p1Result.sql} as p1, ${p2Result.sql} as p2))`;
+                        return { sql, tables, params };
+                    }
+                    throw new Error("distance requires two point arguments");
+                }
                 // ============================================================================
                 // Math functions
                 // ============================================================================
@@ -5359,37 +5834,51 @@ END FROM (SELECT json_group_array(${valueExpr}) as sv))`,
                     }
                     throw new Error("abs requires an argument");
                 }
-                // ROUND: round to nearest integer
+                // ROUND: round to nearest integer using "round half up" (toward positive infinity)
+                // Neo4j: round(-6.5) = -6, round(6.5) = 7
+                // SQLite's ROUND uses "round half away from zero" which gives -7 for -6.5
+                // We implement floor(x + 0.5) to get "round half up" semantics
                 if (expr.functionName === "ROUND") {
                     if (expr.args && expr.args.length > 0) {
                         const argResult = this.translateFunctionArg(expr.args[0]);
                         tables.push(...argResult.tables);
                         params.push(...argResult.params);
-                        return { sql: `ROUND(${argResult.sql})`, tables, params };
+                        // floor(x + 0.5) gives "round half up" semantics
+                        // SQLite CAST truncates toward zero, so we need proper floor for negatives
+                        return {
+                            sql: `(SELECT CASE WHEN v >= 0 OR v = CAST(v AS INTEGER) THEN CAST(v AS INTEGER) ELSE CAST(v AS INTEGER) - 1 END FROM (SELECT (${argResult.sql} + 0.5) AS v))`,
+                            tables,
+                            params
+                        };
                     }
                     throw new Error("round requires an argument");
                 }
-                // FLOOR: round down to integer
+                // FLOOR: round down to integer (towards negative infinity)
                 if (expr.functionName === "FLOOR") {
                     if (expr.args && expr.args.length > 0) {
                         const argResult = this.translateFunctionArg(expr.args[0]);
                         tables.push(...argResult.tables);
                         params.push(...argResult.params);
-                        // SQLite doesn't have FLOOR, use CAST for positive numbers or CASE for proper floor
-                        return { sql: `CAST(${argResult.sql} AS INTEGER)`, tables, params };
+                        // SQLite's CAST truncates towards zero, but floor rounds towards -infinity
+                        // For negative numbers with a fractional part, we need to subtract 1
+                        return {
+                            sql: `(SELECT CASE WHEN v >= 0 OR v = CAST(v AS INTEGER) THEN CAST(v AS INTEGER) ELSE CAST(v AS INTEGER) - 1 END FROM (SELECT ${argResult.sql} AS v))`,
+                            tables,
+                            params
+                        };
                     }
                     throw new Error("floor requires an argument");
                 }
-                // CEIL: round up to integer
+                // CEIL: round up to integer (towards positive infinity)
                 if (expr.functionName === "CEIL") {
                     if (expr.args && expr.args.length > 0) {
                         const argResult = this.translateFunctionArg(expr.args[0]);
                         tables.push(...argResult.tables);
                         params.push(...argResult.params);
-                        // SQLite doesn't have CEIL, simulate with CASE
-                        // Use subquery to evaluate arg once (avoids duplicate parameter binding)
+                        // SQLite's CAST truncates towards zero, which is correct for ceil of negative numbers
+                        // For positive numbers with fractional part, we need to add 1
                         return {
-                            sql: `(SELECT CASE WHEN v = CAST(v AS INTEGER) THEN CAST(v AS INTEGER) ELSE CAST(v AS INTEGER) + 1 END FROM (SELECT ${argResult.sql} AS v))`,
+                            sql: `(SELECT CASE WHEN v <= 0 OR v = CAST(v AS INTEGER) THEN CAST(v AS INTEGER) ELSE CAST(v AS INTEGER) + 1 END FROM (SELECT ${argResult.sql} AS v))`,
                             tables,
                             params
                         };
@@ -5429,92 +5918,230 @@ END FROM (SELECT json_group_array(${valueExpr}) as sv))`,
                         params
                     };
                 }
-                // ============================================================================
-                // List functions
-                // ============================================================================
-                // SIZE: get length of array
-                if (expr.functionName === "SIZE") {
+                // LOG: natural logarithm (Cypher log = SQLite ln)
+                if (expr.functionName === "LOG") {
                     if (expr.args && expr.args.length > 0) {
                         const argResult = this.translateFunctionArg(expr.args[0]);
                         tables.push(...argResult.tables);
                         params.push(...argResult.params);
-                        return { sql: `json_array_length(${argResult.sql})`, tables, params };
+                        return { sql: `ln(${argResult.sql})`, tables, params };
                     }
-                    throw new Error("size requires an argument");
+                    throw new Error("log requires an argument");
                 }
-                // HEAD: get first element of array
-                if (expr.functionName === "HEAD") {
+                // LOG10: base-10 logarithm
+                if (expr.functionName === "LOG10") {
                     if (expr.args && expr.args.length > 0) {
                         const argResult = this.translateFunctionArg(expr.args[0]);
                         tables.push(...argResult.tables);
                         params.push(...argResult.params);
-                        return { sql: `json_extract(${argResult.sql}, '$[0]')`, tables, params };
+                        return { sql: `log10(${argResult.sql})`, tables, params };
                     }
-                    throw new Error("head requires an argument");
+                    throw new Error("log10 requires an argument");
                 }
-                // LAST: get last element of array
-                if (expr.functionName === "LAST") {
+                // EXP: exponential (e^x)
+                if (expr.functionName === "EXP") {
                     if (expr.args && expr.args.length > 0) {
                         const argResult = this.translateFunctionArg(expr.args[0]);
                         tables.push(...argResult.tables);
                         params.push(...argResult.params);
-                        // SQLite: json_extract with [json_array_length - 1] or $[#-1] syntax
-                        return { sql: `json_extract(${argResult.sql}, '$[#-1]')`, tables, params };
+                        return { sql: `exp(${argResult.sql})`, tables, params };
                     }
-                    throw new Error("last requires an argument");
+                    throw new Error("exp requires an argument");
                 }
-                // KEYS: get property keys of a node/map (only returns keys with non-null values)
-                if (expr.functionName === "KEYS") {
+                // Trigonometric functions
+                if (expr.functionName === "SIN") {
                     if (expr.args && expr.args.length > 0) {
-                        const arg = expr.args[0];
-                        // Handle null literal - keys(null) returns null
-                        if (arg.type === "literal" && arg.value === null) {
-                            return { sql: "NULL", tables, params };
-                        }
-                        if (arg.type === "variable") {
-                            // First check if it's a WITH alias
-                            const withAliases = this.ctx.withAliases;
-                            if (withAliases && withAliases.has(arg.variable)) {
-                                const originalExpr = withAliases.get(arg.variable);
-                                // If the WITH alias is null, return null
-                                if (originalExpr.type === "literal" && originalExpr.value === null) {
-                                    return { sql: "NULL", tables, params };
-                                }
-                                // For maps/objects from WITH, translate and get keys
-                                const translated = this.translateExpression(originalExpr);
-                                tables.push(...translated.tables);
-                                params.push(...translated.params);
-                                // Use json_each to get keys from the JSON object
-                                // Note: keys() returns ALL keys including those with null values
-                                return {
-                                    sql: `(SELECT json_group_array(key) FROM json_each(${translated.sql}))`,
-                                    tables,
-                                    params,
-                                };
-                            }
-                            // Check ctx.variables for node/edge variables
-                            const varInfo = this.ctx.variables.get(arg.variable);
-                            if (!varInfo) {
-                                throw new Error(`Unknown variable: ${arg.variable}`);
-                            }
-                            tables.push(varInfo.alias);
-                            // Use json_each to get keys from the node/edge properties
-                            // For nodes/edges, filter out null-valued properties since setting a property to null removes it
-                            return {
-                                sql: `(SELECT json_group_array(key) FROM json_each(${varInfo.alias}.properties) WHERE type != 'null')`,
-                                tables,
-                                params
-                            };
-                        }
-                        // Handle map literals
-                        if (arg.type === "object") {
-                            const translated = this.translateExpression(arg);
-                            tables.push(...translated.tables);
-                            params.push(...translated.params);
-                            // Note: keys() returns ALL keys including those with null values
-                            return {
-                                sql: `(SELECT json_group_array(key) FROM json_each(${translated.sql}))`,
-                                tables,
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `sin(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("sin requires an argument");
+                }
+                if (expr.functionName === "COS") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `cos(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("cos requires an argument");
+                }
+                if (expr.functionName === "TAN") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `tan(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("tan requires an argument");
+                }
+                if (expr.functionName === "ASIN") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `asin(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("asin requires an argument");
+                }
+                if (expr.functionName === "ACOS") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `acos(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("acos requires an argument");
+                }
+                if (expr.functionName === "ATAN") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `atan(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("atan requires an argument");
+                }
+                if (expr.functionName === "ATAN2") {
+                    if (expr.args && expr.args.length >= 2) {
+                        const arg1Result = this.translateFunctionArg(expr.args[0]);
+                        const arg2Result = this.translateFunctionArg(expr.args[1]);
+                        tables.push(...arg1Result.tables, ...arg2Result.tables);
+                        params.push(...arg1Result.params, ...arg2Result.params);
+                        return { sql: `atan2(${arg1Result.sql}, ${arg2Result.sql})`, tables, params };
+                    }
+                    throw new Error("atan2 requires two arguments");
+                }
+                // DEGREES: convert radians to degrees
+                if (expr.functionName === "DEGREES") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `degrees(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("degrees requires an argument");
+                }
+                // RADIANS: convert degrees to radians
+                if (expr.functionName === "RADIANS") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `radians(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("radians requires an argument");
+                }
+                // HAVERSIN: haversine function (1 - cos(x)) / 2
+                if (expr.functionName === "HAVERSIN") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `((1.0 - cos(${argResult.sql})) / 2.0)`, tables, params };
+                    }
+                    throw new Error("haversin requires an argument");
+                }
+                // E: Euler's number constant
+                if (expr.functionName === "E") {
+                    return { sql: `exp(1)`, tables, params };
+                }
+                // PI: mathematical constant pi
+                if (expr.functionName === "PI") {
+                    return { sql: `pi()`, tables, params };
+                }
+                // ============================================================================
+                // List functions
+                // ============================================================================
+                // SIZE: get length of array or string
+                if (expr.functionName === "SIZE") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        // Push params 4 times since the arg is referenced 4 times in the CASE expression
+                        params.push(...argResult.params);
+                        params.push(...argResult.params);
+                        params.push(...argResult.params);
+                        params.push(...argResult.params);
+                        // Handle both strings and arrays: use json_array_length for valid JSON arrays, length() otherwise
+                        return { sql: `CASE WHEN json_valid(${argResult.sql}) AND json_type(${argResult.sql}) = 'array' THEN json_array_length(${argResult.sql}) ELSE length(${argResult.sql}) END`, tables, params };
+                    }
+                    throw new Error("size requires an argument");
+                }
+                // HEAD: get first element of array
+                if (expr.functionName === "HEAD") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `json_extract(${argResult.sql}, '$[0]')`, tables, params };
+                    }
+                    throw new Error("head requires an argument");
+                }
+                // LAST: get last element of array
+                if (expr.functionName === "LAST") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        // SQLite: json_extract with [json_array_length - 1] or $[#-1] syntax
+                        return { sql: `json_extract(${argResult.sql}, '$[#-1]')`, tables, params };
+                    }
+                    throw new Error("last requires an argument");
+                }
+                // KEYS: get property keys of a node/map (only returns keys with non-null values)
+                if (expr.functionName === "KEYS") {
+                    if (expr.args && expr.args.length > 0) {
+                        const arg = expr.args[0];
+                        // Handle null literal - keys(null) returns null
+                        if (arg.type === "literal" && arg.value === null) {
+                            return { sql: "NULL", tables, params };
+                        }
+                        if (arg.type === "variable") {
+                            // First check if it's a WITH alias
+                            const withAliases = this.ctx.withAliases;
+                            if (withAliases && withAliases.has(arg.variable)) {
+                                const originalExpr = withAliases.get(arg.variable);
+                                // If the WITH alias is null, return null
+                                if (originalExpr.type === "literal" && originalExpr.value === null) {
+                                    return { sql: "NULL", tables, params };
+                                }
+                                // For maps/objects from WITH, translate and get keys
+                                const translated = this.translateExpression(originalExpr);
+                                tables.push(...translated.tables);
+                                params.push(...translated.params);
+                                // Use json_each to get keys from the JSON object
+                                // Note: keys() returns ALL keys including those with null values
+                                return {
+                                    sql: `(SELECT json_group_array(key) FROM json_each(${translated.sql}))`,
+                                    tables,
+                                    params,
+                                };
+                            }
+                            // Check ctx.variables for node/edge variables
+                            const varInfo = this.ctx.variables.get(arg.variable);
+                            if (!varInfo) {
+                                throw new Error(`Unknown variable: ${arg.variable}`);
+                            }
+                            tables.push(varInfo.alias);
+                            // Use json_each to get keys from the node/edge properties
+                            // For nodes/edges, filter out null-valued properties since setting a property to null removes it
+                            return {
+                                sql: `(SELECT json_group_array(key) FROM json_each(${varInfo.alias}.properties) WHERE type != 'null')`,
+                                tables,
+                                params
+                            };
+                        }
+                        // Handle map literals
+                        if (arg.type === "object") {
+                            const translated = this.translateExpression(arg);
+                            tables.push(...translated.tables);
+                            params.push(...translated.params);
+                            // Note: keys() returns ALL keys including those with null values
+                            return {
+                                sql: `(SELECT json_group_array(key) FROM json_each(${translated.sql}))`,
+                                tables,
                                 params,
                             };
                         }
@@ -8405,6 +9032,9 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             case "existsPattern": {
                 return this.translateExistsPattern(expr);
             }
+            case "sizePattern": {
+                return this.translateSizePattern(expr);
+            }
             case "listPredicate": {
                 // Wrap list predicate result with cypher_to_json_bool for proper boolean output in RETURN
                 // translateListPredicate returns 0/1 for SQLite WHERE compatibility
@@ -8444,7 +9074,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 // For multiple labels, all must be present (AND)
                 const labelChecks = labelsToCheck.map(l => `EXISTS(SELECT 1 FROM json_each(${varInfo.alias}.label) WHERE value = '${l}')`).join(' AND ');
                 return {
-                    sql: `(${labelChecks})`,
+                    sql: `CASE WHEN ${varInfo.alias}.id IS NULL THEN NULL ELSE cypher_to_json_bool(${labelChecks}) END`,
                     tables,
                     params,
                 };
@@ -8462,6 +9092,39 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     params,
                 };
             }
+            case "mapProjection": {
+                // Map projection: p {.name, .age} or p {.name, key: expr}
+                // This creates a new JSON object with selected properties from the source
+                const sourceResult = this.translateExpression(expr.projectionSource);
+                tables.push(...sourceResult.tables);
+                params.push(...sourceResult.params);
+                const items = expr.projectionItems || [];
+                const jsonParts = [];
+                for (const item of items) {
+                    if (item.type === "property") {
+                        // .property shorthand - extract property from source
+                        const key = item.property;
+                        jsonParts.push(`'${key}', json_extract(${sourceResult.sql}, '$.${key}')`);
+                    }
+                    else if (item.type === "literal") {
+                        // key: value syntax
+                        const key = item.key;
+                        const valueResult = this.translateExpression(item.value);
+                        tables.push(...valueResult.tables);
+                        params.push(...valueResult.params);
+                        jsonParts.push(`'${key}', ${valueResult.sql}`);
+                    }
+                    else if (item.type === "allProperties") {
+                        // .* - project all properties (not yet fully supported, just returns the source)
+                        // TODO: implement proper .* support
+                    }
+                }
+                return {
+                    sql: `json_object(${jsonParts.join(", ")})`,
+                    tables,
+                    params,
+                };
+            }
             case "in": {
                 // value IN list - check if value is in the list
                 const listExpr = expr.list;
@@ -8805,6 +9468,16 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     };
                 }
             }
+            case "regexMatch": {
+                // Regex match operator: left =~ pattern
+                const leftResult = this.translateExpression(expr.left);
+                const patternResult = this.translateExpression(expr.pattern);
+                return {
+                    sql: `cypher_to_json_bool(cypher_regex(${leftResult.sql}, ${patternResult.sql}))`,
+                    tables: [...leftResult.tables, ...patternResult.tables],
+                    params: [...leftResult.params, ...patternResult.params],
+                };
+            }
             default:
                 throw new Error(`Unknown expression type: ${expr.type}`);
         }
@@ -8850,17 +9523,23 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             }
             params.push(...condParams);
             // Translate the result expression
+            // Wrap string literals with json_quote() to preserve them as JSON strings
+            // This ensures 'null' string is returned as '"null"' not null
             const { sql: resultSql, tables: resultTables, params: resultParams } = this.translateExpression(when.result);
             tables.push(...resultTables);
             params.push(...resultParams);
-            sql += ` WHEN ${condSql} THEN ${resultSql}`;
+            const isStringLiteral = when.result.type === "literal" && typeof when.result.value === "string";
+            const wrappedResultSql = isStringLiteral ? `json_quote(${resultSql})` : resultSql;
+            sql += ` WHEN ${condSql} THEN ${wrappedResultSql}`;
         }
         // Add ELSE clause if present
         if (expr.elseExpr) {
             const { sql: elseSql, tables: elseTables, params: elseParams } = this.translateExpression(expr.elseExpr);
             tables.push(...elseTables);
             params.push(...elseParams);
-            sql += ` ELSE ${elseSql}`;
+            const isStringLiteral = expr.elseExpr.type === "literal" && typeof expr.elseExpr.value === "string";
+            const wrappedElseSql = isStringLiteral ? `json_quote(${elseSql})` : elseSql;
+            sql += ` ELSE ${wrappedElseSql}`;
         }
         sql += " END";
         return { sql, tables, params };
@@ -8944,13 +9623,15 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         const rightIsList = this.isListExpression(expr.right);
         const leftIsStringLiteral = expr.left?.type === "literal" && typeof expr.left.value === "string";
         const rightIsStringLiteral = expr.right?.type === "literal" && typeof expr.right.value === "string";
+        // Helper for json_each that preserves boolean types (SQLite converts true/false to 1/0)
+        const jsonEachWithBooleans = (arrayExpr) => `SELECT CASE json_each.type WHEN 'true' THEN json('true') WHEN 'false' THEN json('false') ELSE json_each.value END as value FROM json_each(${arrayExpr})`;
         if (expr.operator === "+" && leftIsList && rightIsList) {
             // Both are lists: list + list concatenation
             // Pattern: (SELECT json_group_array(value) FROM (SELECT value FROM json_each(left) UNION ALL SELECT value FROM json_each(right)))
             const leftArraySql = this.wrapForArray(expr.left, leftResult.sql);
             const rightArraySql = this.wrapForArray(expr.right, rightResult.sql);
             return {
-                sql: `(SELECT json_group_array(value) FROM (SELECT value FROM json_each(${leftArraySql}) UNION ALL SELECT value FROM json_each(${rightArraySql})))`,
+                sql: `(SELECT json_group_array(value) FROM (${jsonEachWithBooleans(leftArraySql)} UNION ALL ${jsonEachWithBooleans(rightArraySql)}))`,
                 tables,
                 params,
             };
@@ -8958,21 +9639,37 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         if (expr.operator === "+" && leftIsList && !rightIsList) {
             // list + scalar: append scalar to list
             // Use json_quote() to properly convert any scalar (including strings) to JSON
+            // In Cypher, list + null returns null (not [list..., null])
             const leftArraySql = this.wrapForArray(expr.left, leftResult.sql);
             const rightScalarSql = rightResult.sql;
+            // Params order: rightScalarSql (IS NULL) -> leftArraySql -> rightScalarSql (json_quote)
             return {
-                sql: `(SELECT json_group_array(value) FROM (SELECT value FROM json_each(${leftArraySql}) UNION ALL SELECT json_quote(${rightScalarSql})))`,
+                sql: `(CASE WHEN ${rightScalarSql} IS NULL THEN NULL ELSE (SELECT json_group_array(value) FROM (${jsonEachWithBooleans(leftArraySql)} UNION ALL SELECT json_quote(${rightScalarSql}))) END)`,
                 tables,
-                params,
+                params: [...rightResult.params, ...leftResult.params, ...rightResult.params],
             };
         }
         // String concatenation: if either side is definitely a string (literal or string concat chain),
         // use || for concatenation instead of + (numeric addition)
+        // Use cypher_to_string to properly format numbers (integers without .0)
+        // Exception: power expressions always return floats, so use CAST to preserve .0
         const leftIsStringConcat = this.isStringConcatenation(expr.left);
         const rightIsStringConcat = this.isStringConcatenation(expr.right);
         if (expr.operator === "+" && !leftIsList && !rightIsList && (leftIsStringConcat || rightIsStringConcat)) {
-            const leftSql = this.wrapForArithmetic(expr.left, leftResult.sql);
-            const rightSql = this.wrapForArithmetic(expr.right, rightResult.sql);
+            // Wrap non-string expressions with cypher_to_string for proper number formatting
+            // But for power expressions, use CAST to preserve the .0 suffix (power always returns float)
+            const leftIsPower = this.isPowerExpression(expr.left);
+            const rightIsPower = this.isPowerExpression(expr.right);
+            const leftSql = leftIsStringLiteral || leftIsStringConcat
+                ? this.wrapForArithmetic(expr.left, leftResult.sql)
+                : leftIsPower
+                    ? `CAST(${this.wrapForArithmetic(expr.left, leftResult.sql)} AS TEXT)`
+                    : `cypher_to_string(${this.wrapForArithmetic(expr.left, leftResult.sql)})`;
+            const rightSql = rightIsStringLiteral || rightIsStringConcat
+                ? this.wrapForArithmetic(expr.right, rightResult.sql)
+                : rightIsPower
+                    ? `CAST(${this.wrapForArithmetic(expr.right, rightResult.sql)} AS TEXT)`
+                    : `cypher_to_string(${this.wrapForArithmetic(expr.right, rightResult.sql)})`;
             return { sql: `(${leftSql} || ${rightSql})`, tables, params };
         }
         // For property + literal list (where left is property and right is known list)
@@ -9000,12 +9697,15 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         if (expr.operator === "+" && !leftIsList && rightIsList) {
             // scalar + list: prepend scalar to list (only for non-property scalars)
             // Use json_quote() to properly convert any scalar (including strings) to JSON
+            // Use jsonEachWithBooleans to preserve boolean types in the list
+            // In Cypher, null + list returns null (not [null, list...])
             const leftScalarSql = leftResult.sql;
             const rightArraySql = this.wrapForArray(expr.right, rightResult.sql);
+            // Params order: leftScalarSql (IS NULL) -> leftScalarSql (json_quote) -> rightArraySql
             return {
-                sql: `(SELECT json_group_array(value) FROM (SELECT json_quote(${leftScalarSql}) as value UNION ALL SELECT value FROM json_each(${rightArraySql})))`,
+                sql: `(CASE WHEN ${leftScalarSql} IS NULL THEN NULL ELSE (SELECT json_group_array(value) FROM (SELECT json_quote(${leftScalarSql}) as value UNION ALL ${jsonEachWithBooleans(rightArraySql)})) END)`,
                 tables,
-                params,
+                params: [...leftResult.params, ...leftResult.params, ...rightResult.params],
             };
         }
         // For property + property, use a WITH subquery to avoid duplicate parameter references
@@ -9065,6 +9765,87 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 params,
             };
         }
+        // Handle modulo operator - SQLite % only works on integers
+        // For float modulo, use (a - trunc(a/b) * b) formula (truncate toward zero, like C/Java/Neo4j)
+        if (expr.operator === "%") {
+            // Recursive helper to check if expression contains float values
+            const containsFloat = (e) => {
+                if (!e)
+                    return false;
+                // Float literal
+                if (e.type === "literal" && typeof e.value === "number") {
+                    const literalKind = e.numberLiteralKind;
+                    return literalKind === "float";
+                }
+                // Binary expression - check both operands recursively
+                if (e.type === "binary" && (e.left || e.right)) {
+                    return containsFloat(e.left) || containsFloat(e.right);
+                }
+                return false;
+            };
+            if (containsFloat(expr.left) || containsFloat(expr.right)) {
+                // Float modulo: a - trunc(a/b) * b
+                // SQLite doesn't have TRUNC, use CAST to INTEGER which truncates toward zero
+                // Note: leftSql is used twice and rightSql is used twice, so duplicate params
+                return {
+                    sql: `(${leftSql} - CAST((${leftSql} * 1.0 / ${rightSql}) AS INTEGER) * ${rightSql})`,
+                    tables,
+                    params: [...leftResult.params, ...leftResult.params, ...rightResult.params, ...rightResult.params],
+                };
+            }
+        }
+        // Handle division with proper integer division semantics
+        // In Cypher, integer / integer = integer (truncated toward zero)
+        // SQLite's -> operator returns TEXT which causes float division
+        // We use CAST to ensure integer division when both operands are integers
+        if (expr.operator === "/") {
+            // Recursive helper to check if expression evaluates to integer
+            const isIntegerExpression = (e) => {
+                if (!e)
+                    return false;
+                // Integer literal - check numberLiteralKind to distinguish 3 from 3.0
+                if (e.type === "literal" && typeof e.value === "number") {
+                    const literalKind = e.numberLiteralKind;
+                    // Only consider it integer if explicitly marked as integer (not float)
+                    return literalKind === "integer";
+                }
+                // Array index with integer array elements
+                if (e.type === "function" && e.functionName === "INDEX" &&
+                    e.args?.[0]?.type === "literal" && Array.isArray(e.args[0].value) &&
+                    e.args[0].value.every(v => typeof v === "number" && Number.isInteger(v))) {
+                    return true;
+                }
+                // Map property access: {a: 1, b: 2}.a - check if the accessed property is an integer
+                if (e.type === "propertyAccess" && e.object?.type === "object" && e.property) {
+                    const mapObj = e.object;
+                    const prop = mapObj.properties?.find(p => p.key === e.property);
+                    if (prop && isIntegerExpression(prop.value)) {
+                        return true;
+                    }
+                }
+                // Binary expression where result is integer (both operands are integers and op preserves integerality)
+                if (e.type === "binary" && e.left && e.right) {
+                    // Include "/" because integer/integer = integer in Cypher
+                    const integerOps = ["+", "-", "*", "%", "/"]; // These preserve integer type
+                    if (integerOps.includes(e.operator) && isIntegerExpression(e.left) && isIntegerExpression(e.right)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+            // Check if both operands could be integers at compile time
+            const leftIsStaticInt = isIntegerExpression(expr.left);
+            const rightIsStaticInt = isIntegerExpression(expr.right);
+            if (leftIsStaticInt && rightIsStaticInt) {
+                // Both operands are integers, use CAST to ensure integer division
+                // CAST(left AS INTEGER) / CAST(right AS INTEGER) ensures SQLite does integer division
+                return {
+                    sql: `(CAST(${leftSql} AS INTEGER) / CAST(${rightSql} AS INTEGER))`,
+                    tables,
+                    params,
+                };
+            }
+        }
         return {
             sql: `(${leftSql} ${expr.operator} ${rightSql})`,
             tables,
@@ -9563,7 +10344,8 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         }
         if (expr.type === "function") {
             // List-returning functions like collect(), range(), etc.
-            const listFunctions = ["COLLECT", "RANGE", "KEYS", "LABELS", "SPLIT", "TAIL", "REVERSE"];
+            // LIST is used by the parser when a list contains complex expressions like objects
+            const listFunctions = ["COLLECT", "RANGE", "KEYS", "LABELS", "SPLIT", "TAIL", "REVERSE", "LIST"];
             return listFunctions.includes(expr.functionName || "");
         }
         if (expr.type === "case") {
@@ -9609,6 +10391,18 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         }
         return false;
     }
+    /**
+     * Check if an expression is a boolean literal (true or false).
+     */
+    isBooleanLiteral(expr) {
+        return expr.type === "literal" && typeof expr.value === "boolean";
+    }
+    /**
+     * Check if an expression is an integer literal.
+     */
+    isIntegerLiteral(expr) {
+        return expr.type === "literal" && typeof expr.value === "number" && Number.isInteger(expr.value);
+    }
     isStringConcatenation(expr) {
         // Check if expression is a string concatenation chain
         // (contains a string literal anywhere in a + chain)
@@ -9626,6 +10420,21 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         }
         return false;
     }
+    /**
+     * Check if an expression is or contains a power operation (^).
+     * In Neo4j, power always returns a float, so when converting to string
+     * we should preserve the .0 suffix for whole numbers.
+     */
+    isPowerExpression(expr) {
+        if (expr.type === "binary" && expr.operator === "^") {
+            return true;
+        }
+        // Check if nested in other binary operations
+        if (expr.type === "binary" && expr.left && expr.right) {
+            return this.isPowerExpression(expr.left) || this.isPowerExpression(expr.right);
+        }
+        return false;
+    }
     /**
      * Check if an expression could produce NaN (IEEE 754 Not a Number).
      * In SQLite, division by zero returns NULL, but Cypher semantics require NaN.
@@ -9890,6 +10699,22 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 };
             }
         }
+        // In Cypher, boolean and integer types are NOT comparable.
+        // `true = 1` should return `false` (not `true`), because they are different types.
+        // Detect when comparing a boolean literal to an integer literal and short-circuit.
+        const leftIsBooleanLiteral = this.isBooleanLiteral(expr.left);
+        const rightIsBooleanLiteral = this.isBooleanLiteral(expr.right);
+        const leftIsIntegerLiteral = this.isIntegerLiteral(expr.left);
+        const rightIsIntegerLiteral = this.isIntegerLiteral(expr.right);
+        if ((leftIsBooleanLiteral && rightIsIntegerLiteral) || (leftIsIntegerLiteral && rightIsBooleanLiteral)) {
+            // Different types: boolean vs integer -> always false for =, always true for <>
+            if (expr.comparisonOperator === "=") {
+                return { sql: `json('false')`, tables, params: [] };
+            }
+            if (expr.comparisonOperator === "<>") {
+                return { sql: `json('true')`, tables, params: [] };
+            }
+        }
         // For equality comparisons, use cypher_bool_eq to handle mixed boolean representations
         // (JSON boolean strings 'true'/'false' vs SQLite integers 1/0)
         if (expr.comparisonOperator === "=") {
@@ -9994,19 +10819,34 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
      * Translates to SQLite using json_each and json_group_array:
      * (SELECT json_group_array(value_or_mapped) FROM json_each(listExpr) WHERE filter)
      */
-    translateListComprehension(expr) {
+    translateListComprehension(expr, outerScopes) {
         const tables = [];
         const params = [];
         const variable = expr.variable;
         const listExpr = expr.listExpr;
         const filterCondition = expr.filterCondition;
         const mapExpr = expr.mapExpr;
-        // Translate the source list expression
-        const listResult = this.translateExpression(listExpr);
+        // Generate a unique table alias for this comprehension to avoid conflicts in nested comprehensions
+        const tableAlias = outerScopes ? `__lc${outerScopes.length}__` : "__lc__";
+        // Build the current scope chain
+        const currentScope = { variable, tableAlias };
+        const allScopes = outerScopes ? [...outerScopes, currentScope] : [currentScope];
+        // Translate the source list expression, potentially referencing outer scope variables
+        let listResult;
+        if (outerScopes && outerScopes.length > 0) {
+            // Use translateListComprehensionExpr to handle references to outer variables
+            const lastOuterScope = outerScopes[outerScopes.length - 1];
+            listResult = this.translateListComprehensionExpr(listExpr, lastOuterScope.variable, lastOuterScope.tableAlias, outerScopes.slice(0, -1));
+            // Wrap in an object to match expected structure
+            listResult = { sql: listResult.sql, tables: [], params: listResult.params };
+        }
+        else {
+            listResult = this.translateExpression(listExpr);
+        }
         tables.push(...listResult.tables);
         // Wrap the source expression for json_each
         let sourceExpr = listResult.sql;
-        if (listExpr.type === "property") {
+        if (listExpr.type === "property" && !outerScopes) {
             // For property access, use json_extract 
             const varInfo = this.ctx.variables.get(listExpr.variable);
             if (varInfo) {
@@ -10014,23 +10854,34 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             }
         }
         // Determine what to select: the mapped expression or just the value
-        let selectExpr = `__lc__.value`;
+        let selectExpr = `${tableAlias}.value`;
         let mapParams = [];
         if (mapExpr) {
-            const mapResult = this.translateListComprehensionExpr(mapExpr, variable, "__lc__");
-            mapParams = mapResult.params;
-            selectExpr = mapResult.sql;
+            // Check if mapExpr is a nested list comprehension
+            if (mapExpr.type === "listComprehension") {
+                // Recursively translate nested list comprehension with current scope
+                const nestedResult = this.translateListComprehension(mapExpr, allScopes);
+                mapParams = nestedResult.params;
+                selectExpr = nestedResult.sql;
+                tables.push(...nestedResult.tables);
+            }
+            else {
+                // Pass outerScopes (without current) so inner can access outer variables
+                const mapResult = this.translateListComprehensionExpr(mapExpr, variable, tableAlias, outerScopes);
+                mapParams = mapResult.params;
+                selectExpr = mapResult.sql;
+            }
         }
         // Build the WHERE clause if filter is present
         let whereClause = "";
         let filterParams = [];
         if (filterCondition) {
-            const filterResult = this.translateListComprehensionCondition(filterCondition, variable, "__lc__");
+            const filterResult = this.translateListComprehensionCondition(filterCondition, variable, tableAlias, outerScopes);
             filterParams = filterResult.params;
             whereClause = ` WHERE ${filterResult.sql}`;
         }
         // Build the final SQL using json_group_array
-        const sql = `(SELECT json_group_array(${selectExpr}) FROM json_each(${sourceExpr}) AS __lc__${whereClause})`;
+        const sql = `(SELECT json_group_array(${selectExpr}) FROM json_each(${sourceExpr}) AS ${tableAlias}${whereClause})`;
         // Params must match SQL order: selectExpr params, then source params, then filter params
         params.push(...mapParams, ...listResult.params, ...filterParams);
         return { sql, tables, params };
@@ -10057,26 +10908,62 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         // Translate the source list expression
         const listResult = this.translateExpression(listExpr);
         tables.push(...listResult.tables);
+        // Check if the list expression is a WITH alias that contains an aggregation
+        // In that case, we need to avoid putting the aggregation inside the recursive CTE
+        // because SQLite doesn't allow aggregate functions in that context.
+        let listExprSql = listResult.sql;
+        let needsAggregateWrapper = false;
+        if (listExpr.type === "variable") {
+            const withAliases = this.ctx.withAliases;
+            if (withAliases && withAliases.has(listExpr.variable)) {
+                const aliasExpr = withAliases.get(listExpr.variable);
+                if (this.isAggregateExpression(aliasExpr)) {
+                    needsAggregateWrapper = true;
+                }
+            }
+        }
         // Build the reduce expression with variable substitutions
         // Replace accumulator with "__red__.acc" and variable with "__red_elem.value"
         const reduceResult = this.translateReduceBodyExpr(reduceExpr, accumulator, variable, "__red__", "__red_elem");
-        // Build recursive CTE:
-        // WITH RECURSIVE __red__(idx, acc) AS (
-        //   SELECT 0, <init>
-        //   UNION ALL
-        //   SELECT idx + 1, <reduceExpr>
-        //   FROM __red__, json_each(<list>) AS __red_elem__
-        //   WHERE __red__.idx = __red_elem__.key
-        // )
-        // SELECT acc FROM __red__ ORDER BY idx DESC LIMIT 1
-        const sql = `(WITH RECURSIVE __red__(idx, acc) AS (
+        let sql;
+        if (needsAggregateWrapper) {
+            // For aggregation-based lists, use a subquery approach that avoids aggregate in recursive CTE
+            // This uses the json_array_reduce helper pattern that iterates without recursion
+            // SQLite's json_each produces key/value pairs we can iterate over
+            // We calculate the reduce using a correlated subquery sum pattern for numeric operations
+            // Check if this is a simple addition pattern: acc + x or x + acc
+            const isSimpleAddition = reduceExpr.type === "binary" && reduceExpr.operator === "+";
+            if (isSimpleAddition) {
+                // For simple addition, use SUM which works with aggregations
+                // reduce(s=0, x IN list | s+x) is equivalent to COALESCE(init + SUM(values), init)
+                sql = `(${initResult.sql} + COALESCE((SELECT SUM(__elem.value) FROM json_each(${listExprSql}) AS __elem), 0))`;
+            }
+            else {
+                // For complex reduce operations, we need to use a window function approach
+                // or materialize the list first. For now, fall back to the standard CTE approach
+                // but wrap the list in a scalar subquery to try to avoid the aggregate issue.
+                // This may still fail for some patterns, but handles many cases.
+                sql = `(WITH RECURSIVE __red__(idx, acc) AS (
       SELECT 0, ${initResult.sql}
       UNION ALL
       SELECT __red__.idx + 1, ${reduceResult.sql}
-      FROM __red__, json_each(${listResult.sql}) AS __red_elem
+      FROM __red__, json_each(${listExprSql}) AS __red_elem
       WHERE __red__.idx = __red_elem.key
     )
     SELECT acc FROM __red__ ORDER BY idx DESC LIMIT 1)`;
+            }
+        }
+        else {
+            // Standard recursive CTE approach for non-aggregate lists
+            sql = `(WITH RECURSIVE __red__(idx, acc) AS (
+      SELECT 0, ${initResult.sql}
+      UNION ALL
+      SELECT __red__.idx + 1, ${reduceResult.sql}
+      FROM __red__, json_each(${listExprSql}) AS __red_elem
+      WHERE __red__.idx = __red_elem.key
+    )
+    SELECT acc FROM __red__ ORDER BY idx DESC LIMIT 1)`;
+        }
         // Params order: init params, then list params (once for each occurrence), then reduce params
         params.push(...initResult.params, ...listResult.params, ...reduceResult.params);
         return { sql, tables, params };
@@ -10483,6 +11370,119 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         tables.push(boundVarInfo.alias);
         return { sql, tables, params };
     }
+    /**
+     * Translate a size() function on a pattern expression.
+     *
+     * Pattern: size((n)-[:R]->())
+     * Returns the count of matching relationships.
+     *
+     * Example: size((p)-[:KNOWS]->()) returns the count of outgoing KNOWS edges for node p
+     */
+    translateSizePattern(expr) {
+        const tables = [];
+        const params = [];
+        const patterns = expr.patterns;
+        // Pattern structure: patterns from parsePatternChain
+        const firstPattern = patterns[0];
+        const isRelPattern = (p) => {
+            return typeof p === "object" && p !== null && "edge" in p;
+        };
+        let startVar;
+        let relPattern;
+        let startNodePattern;
+        let targetNodePattern;
+        if (isRelPattern(firstPattern)) {
+            // First pattern is a RelationshipPattern
+            relPattern = firstPattern;
+            startNodePattern = relPattern.source;
+            targetNodePattern = relPattern.target;
+            startVar = startNodePattern.variable;
+        }
+        else {
+            // First pattern is a NodePattern, look for RelationshipPattern in rest
+            startNodePattern = firstPattern;
+            startVar = startNodePattern.variable;
+            for (let i = 1; i < patterns.length; i++) {
+                if (isRelPattern(patterns[i])) {
+                    relPattern = patterns[i];
+                    targetNodePattern = relPattern.target;
+                    break;
+                }
+            }
+        }
+        if (!startVar) {
+            throw new Error("size() pattern must start with a bound variable");
+        }
+        // Get the bound variable info from outer context
+        const boundVarInfo = this.ctx.variables.get(startVar);
+        if (!boundVarInfo) {
+            throw new Error(`Unknown variable in size() pattern: ${startVar}`);
+        }
+        if (!relPattern) {
+            throw new Error("size() pattern must include a relationship pattern");
+        }
+        // Build the correlated subquery
+        const edgeAlias = `__sz_e_${this.ctx.aliasCounter++}`;
+        const targetAlias = `__sz_t_${this.ctx.aliasCounter++}`;
+        const edge = relPattern.edge;
+        // Build edge type filter
+        const edgeTypes = edge.types || (edge.type ? [edge.type] : []);
+        let edgeTypeFilter = "";
+        const edgeTypeParams = [];
+        if (edgeTypes.length > 0) {
+            const typeConditions = edgeTypes.map((t) => `${edgeAlias}.type = ?`);
+            edgeTypeFilter = ` AND (${typeConditions.join(" OR ")})`;
+            edgeTypeParams.push(...edgeTypes);
+        }
+        // Build direction filter
+        let directionFilter = "";
+        const direction = edge.direction || "right";
+        if (direction === "right") {
+            directionFilter = `${edgeAlias}.source_id = ${boundVarInfo.alias}.id`;
+        }
+        else if (direction === "left") {
+            directionFilter = `${edgeAlias}.target_id = ${boundVarInfo.alias}.id`;
+        }
+        else {
+            // "none" means either direction
+            directionFilter = `(${edgeAlias}.source_id = ${boundVarInfo.alias}.id OR ${edgeAlias}.target_id = ${boundVarInfo.alias}.id)`;
+        }
+        // Build target node filter if labels specified
+        let targetFilter = "";
+        const targetFilterParams = [];
+        if (targetNodePattern && targetNodePattern.label) {
+            const labels = Array.isArray(targetNodePattern.label)
+                ? targetNodePattern.label
+                : [targetNodePattern.label];
+            const labelConditions = labels.map((l) => `EXISTS(SELECT 1 FROM json_each(${targetAlias}.label) WHERE value = ?)`);
+            targetFilter = ` AND ${labelConditions.join(" AND ")}`;
+            targetFilterParams.push(...labels);
+        }
+        // Build the from clause
+        let fromClause = `edges ${edgeAlias}`;
+        if (targetNodePattern && (targetNodePattern.label || targetNodePattern.variable)) {
+            // Need to join with nodes for target filtering
+            let targetJoin;
+            if (direction === "right") {
+                targetJoin = `${edgeAlias}.target_id = ${targetAlias}.id`;
+            }
+            else if (direction === "left") {
+                targetJoin = `${edgeAlias}.source_id = ${targetAlias}.id`;
+            }
+            else {
+                // For undirected, target is the "other" node
+                targetJoin = `(CASE WHEN ${edgeAlias}.source_id = ${boundVarInfo.alias}.id THEN ${edgeAlias}.target_id ELSE ${edgeAlias}.source_id END) = ${targetAlias}.id`;
+            }
+            fromClause = `edges ${edgeAlias} JOIN nodes ${targetAlias} ON ${targetJoin}`;
+        }
+        // Build the COUNT subquery (unlike EXISTS, we want the actual count)
+        const sql = `(SELECT COUNT(*) FROM ${fromClause} WHERE ${directionFilter}${edgeTypeFilter}${targetFilter})`;
+        // Params must be in SQL order: edgeType, then targetFilter
+        params.push(...edgeTypeParams, ...targetFilterParams);
+        // Add outer table reference
+        tables.push(boundVarInfo.alias);
+        return { sql, tables, params };
+    }
     /**
      * Translate an expression within a pattern comprehension.
      */
@@ -10618,6 +11618,11 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 if (expr.value === false) {
                     return { sql: "0", params };
                 }
+                // Handle array literals - need to serialize as JSON for json_each
+                if (Array.isArray(expr.value)) {
+                    params.push(JSON.stringify(expr.value));
+                    return { sql: "?", params };
+                }
                 params.push(expr.value);
                 return { sql: "?", params };
             case "parameter": {
@@ -10630,6 +11635,14 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 }
                 return { sql: "?", params };
             }
+            case "listComprehension": {
+                // Handle nested list comprehensions - pass the current scope chain
+                const allScopes = scopes
+                    ? [...scopes, { variable: compVar, tableAlias }]
+                    : [{ variable: compVar, tableAlias }];
+                const nestedResult = this.translateListComprehension(expr, allScopes);
+                return { sql: nestedResult.sql, params: nestedResult.params };
+            }
             case "function": {
                 // Handle functions like size(x)
                 const funcArgs = [];
@@ -10666,6 +11679,17 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     // SQLite's RANDOM() returns integer, convert to 0-1 range
                     return { sql: `((RANDOM() + 9223372036854775808) / 18446744073709551615.0)`, params };
                 }
+                if (funcName === "TYPE") {
+                    // type() on a relationship in list comprehension context (e.g., [r IN relationships(p) | type(r)])
+                    // The relationship value is a JSON object containing "type" directly
+                    // Validate that the argument is a relationship object with a type field
+                    // If not, trigger an error (TCK requirement: type() on invalid arguments should fail)
+                    const arg = funcArgs[0];
+                    return {
+                        sql: `CASE WHEN json_type(${arg}) = 'object' AND json_extract(${arg}, '$.type') IS NOT NULL THEN json_extract(${arg}, '$.type') ELSE json('type() requires a relationship argument') END`,
+                        params
+                    };
+                }
                 // Fall back to regular translation for unknown functions
                 const result = this.translateExpression(expr);
                 return { sql: result.sql, params: result.params };
@@ -11324,6 +12348,14 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             case "exists": {
                 return this.translateExistsCondition(condition);
             }
+            case "propertyExists": {
+                // exists(n.property) - checks if property is not NULL
+                const expr = this.translateWhereExpression(condition.expression);
+                return {
+                    sql: `${expr.sql} IS NOT NULL`,
+                    params: expr.params,
+                };
+            }
             case "in": {
                 return this.translateInCondition(condition);
             }
@@ -11829,6 +12861,18 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         targetVariable = aliasedExpr.variable;
                     }
                 }
+                // Check if this is a property access on an UNWIND variable
+                const unwindClauses = this.ctx.unwindClauses;
+                if (unwindClauses) {
+                    const unwindClause = unwindClauses.find(u => u.variable === targetVariable);
+                    if (unwindClause) {
+                        // UNWIND variables use the 'value' column from json_each
+                        return {
+                            sql: this.buildDateTimeWithOffsetOrderBy(`json_extract(${unwindClause.alias}.value, '$.${expr.property}')`),
+                            params: [],
+                        };
+                    }
+                }
                 const varInfo = this.ctx.variables.get(targetVariable);
                 if (!varInfo) {
                     throw new Error(`Unknown variable: ${expr.variable}`);
@@ -11939,8 +12983,9 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             }
             case "binary":
             case "unary":
-            case "literal": {
-                // For complex expressions (binary, literal, etc.), translate them
+            case "literal":
+            case "case": {
+                // For complex expressions (binary, literal, case, etc.), translate them
                 // but substitute variables with column aliases when they are RETURN aliases
                 return this.translateOrderByComplexExpression(expr, returnAliases);
             }
@@ -12060,7 +13105,18 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             }
             case "literal": {
                 // Convert booleans to 1/0 for SQLite
-                const value = expr.value === true ? 1 : expr.value === false ? 0 : expr.value;
+                // Arrays and objects need to be JSON serialized
+                let value = expr.value;
+                if (value === true) {
+                    value = 1;
+                }
+                else if (value === false) {
+                    value = 0;
+                }
+                else if (Array.isArray(value) || (value !== null && typeof value === "object")) {
+                    // For arrays/objects in WHERE expressions, use json() to create proper JSON value
+                    return { sql: `json(?)`, params: [JSON.stringify(value)] };
+                }
                 return { sql: "?", params: [value] };
             }
             case "parameter": {
@@ -12168,6 +13224,16 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 const result = this.translateCaseExpression(expr);
                 return { sql: result.sql, params: result.params };
             }
+            case "sizePattern": {
+                // size((n)-[:REL]->()) pattern in WHERE clause
+                const result = this.translateSizePattern(expr);
+                return { sql: result.sql, params: result.params };
+            }
+            case "object": {
+                // Map literal in WHERE clause (e.g., WITH {a: 1} AS x WHERE x IS NOT NULL)
+                const result = this.translateObjectLiteral(expr);
+                return { sql: result.sql, params: result.params };
+            }
             default:
                 throw new Error(`Unknown expression type in WHERE: ${expr.type}`);
         }
@@ -12297,6 +13363,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
      * Check if a property name is a temporal accessor (like year, month, day, etc.)
      * and return the SQL expression to extract it from a temporal value.
      * Returns null if not a temporal accessor.
+     * Also returns a paramMultiplier indicating how many times the baseSql params need to be repeated.
      */
     translateTemporalPropertyAccess(baseSql, propertyName) {
         // If baseSql uses the -> operator, we need to use json_extract to get the actual value
@@ -12403,7 +13470,14 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             "microsecondsOfSecond": `CAST(COALESCE(NULLIF(substr(${valueExpr}, instr(${valueExpr}, '.') + 1, 6), ''), '0') AS INTEGER)`,
             "nanosecondsOfSecond": `CAST(COALESCE(NULLIF(substr(${valueExpr}, instr(${valueExpr}, '.') + 1, 9), ''), '0') AS INTEGER)`,
         };
-        return temporalAccessors[propertyName] ?? durationAccessors[propertyName] ?? null;
+        const sql = temporalAccessors[propertyName] ?? durationAccessors[propertyName] ?? null;
+        if (sql === null) {
+            return null;
+        }
+        // Count how many times the valueExpr appears in the SQL to know how many times to repeat params
+        // We count occurrences of valueExpr in the template result
+        const paramMultiplier = (sql.split(valueExpr).length - 1);
+        return { sql, paramMultiplier };
     }
     isRelationshipPattern(pattern) {
         return "source" in pattern && "edge" in pattern && "target" in pattern;
@@ -12447,7 +13521,9 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
      */
     quoteAlias(alias) {
         // SQLite uses double quotes for identifiers
-        return `"${alias}"`;
+        // Double quotes inside the identifier must be escaped by doubling them
+        const escaped = alias.replace(/"/g, '""');
+        return `"${escaped}"`;
     }
     expressionReferencesGraphVariables(expr, withAliases, visitingAliases = new Set()) {
         for (const varName of this.findVariablesInExpression(expr)) {
@@ -12755,6 +13831,102 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         collectFromExpr(expr);
         return aliases;
     }
+    /**
+     * Collect WITH aggregate aliases that are referenced inside aggregate expressions in RETURN.
+     * This handles "double aggregation" like: WITH ... collect(x) as vals RETURN collect({v: vals}) as all
+     * When an aggregate in RETURN references a WITH aggregate alias, we need to materialize
+     * the WITH aggregates in a CTE first to avoid nested aggregate function errors in SQLite.
+     */
+    collectWithAggregateAliasesFromAggregateExpressions(expr, withAliases) {
+        const aliases = new Set();
+        if (!withAliases)
+            return aliases;
+        // Helper to collect WITH aggregate aliases from an expression
+        const collectAggregateAliases = (e) => {
+            if (e.type === "variable" && e.variable) {
+                const aliasExpr = withAliases.get(e.variable);
+                if (aliasExpr && this.isAggregateExpression(aliasExpr)) {
+                    aliases.add(e.variable);
+                }
+            }
+            // Recursively check sub-expressions
+            if (e.type === "binary") {
+                if (e.left)
+                    collectAggregateAliases(e.left);
+                if (e.right)
+                    collectAggregateAliases(e.right);
+            }
+            if (e.type === "function" && e.args) {
+                for (const arg of e.args) {
+                    collectAggregateAliases(arg);
+                }
+            }
+            if (e.type === "comparison") {
+                if (e.left)
+                    collectAggregateAliases(e.left);
+                if (e.right)
+                    collectAggregateAliases(e.right);
+            }
+            if (e.type === "unary" && e.operand) {
+                collectAggregateAliases(e.operand);
+            }
+            if (e.type === "case") {
+                if (e.expression)
+                    collectAggregateAliases(e.expression);
+                for (const when of e.whens || []) {
+                    if (when.result)
+                        collectAggregateAliases(when.result);
+                }
+                if (e.elseExpr)
+                    collectAggregateAliases(e.elseExpr);
+            }
+            if (e.type === "object" && e.properties) {
+                for (const prop of e.properties) {
+                    if (prop.value)
+                        collectAggregateAliases(prop.value);
+                }
+            }
+            if (e.type === "list" && e.elements) {
+                for (const el of e.elements) {
+                    collectAggregateAliases(el);
+                }
+            }
+        };
+        // Only check inside aggregate expressions - if this expression IS an aggregate,
+        // collect any WITH aggregate aliases it references
+        if (this.isAggregateExpression(expr)) {
+            // For aggregate functions, check their arguments
+            if (expr.type === "function" && expr.args) {
+                for (const arg of expr.args) {
+                    collectAggregateAliases(arg);
+                }
+            }
+        }
+        // Also recursively check for nested aggregates
+        if (expr.type === "binary") {
+            const leftAliases = this.collectWithAggregateAliasesFromAggregateExpressions(expr.left, withAliases);
+            const rightAliases = this.collectWithAggregateAliasesFromAggregateExpressions(expr.right, withAliases);
+            leftAliases.forEach(a => aliases.add(a));
+            rightAliases.forEach(a => aliases.add(a));
+        }
+        if (expr.type === "case") {
+            if (expr.expression) {
+                const exprAliases = this.collectWithAggregateAliasesFromAggregateExpressions(expr.expression, withAliases);
+                exprAliases.forEach(a => aliases.add(a));
+            }
+            for (const when of expr.whens || []) {
+                if (when.result) {
+                    const resultAliases = this.collectWithAggregateAliasesFromAggregateExpressions(when.result, withAliases);
+                    resultAliases.forEach(a => aliases.add(a));
+                }
+            }
+            if (expr.elseExpr) {
+                const elseAliases = this.collectWithAggregateAliasesFromAggregateExpressions(expr.elseExpr, withAliases);
+                elseAliases.forEach(a => aliases.add(a));
+            }
+        }
+        return aliases;
+    }
     /**
      * Check if a WHERE condition references any alias that resolves to an aggregate expression.
      * This is used to determine if the condition should go in HAVING instead of WHERE.
@@ -12864,7 +14036,15 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 }
             }
         }
-        return { json: JSON.stringify(resolved), params };
+        // In Neo4j/Cypher, setting a property to null means the property is not stored.
+        // Filter out properties with null values.
+        const filtered = {};
+        for (const [key, value] of Object.entries(resolved)) {
+            if (value !== null) {
+                filtered[key] = value;
+            }
+        }
+        return { json: JSON.stringify(filtered), params };
     }
     isFunctionPropertyValue(value) {
         return (typeof value === "object" &&
@@ -12927,7 +14107,13 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 case "+": return leftNum + rightNum;
                 case "-": return leftNum - rightNum;
                 case "*": return leftNum * rightNum;
-                case "/": return leftNum / rightNum;
+                case "/": {
+                    // Cypher integer division: if both operands are integers, truncate toward zero
+                    if (Number.isInteger(leftNum) && Number.isInteger(rightNum)) {
+                        return Math.trunc(leftNum / rightNum);
+                    }
+                    return leftNum / rightNum;
+                }
                 case "%": return leftNum % rightNum;
                 case "^": return Math.pow(leftNum, rightNum);
                 default: throw new Error("Unknown operator");
@@ -13155,6 +14341,9 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 throw new Error(`Cannot evaluate expression of type ${expr.type}`);
         }
     }
+    getReturnItemName(item) {
+        return item.alias || item.rawExpression || this.getExpressionName(item.expression);
+    }
     getExpressionName(expr) {
         switch (expr.type) {
             case "variable":
@@ -13163,10 +14352,28 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 return `${expr.variable}.${expr.property}`;
             case "function": {
                 // Build full function call representation: function(args)
-                const funcName = expr.functionName.toLowerCase();
+                const canonicalFunctionName = (name) => {
+                    switch (name.toUpperCase()) {
+                        case "TOUPPER":
+                            return "toUpper";
+                        case "TOLOWER":
+                            return "toLower";
+                        case "TOINTEGER":
+                            return "toInteger";
+                        case "TOFLOAT":
+                            return "toFloat";
+                        case "TOSTRING":
+                            return "toString";
+                        case "TOBOOLEAN":
+                            return "toBoolean";
+                        default:
+                            return name.toLowerCase();
+                    }
+                };
+                const funcName = canonicalFunctionName(expr.functionName);
                 if (expr.args && expr.args.length > 0) {
                     // Special case: INDEX function should be rendered as list[index] notation
-                    if (funcName === "index" && expr.args.length === 2) {
+                    if (funcName.toLowerCase() === "index" && expr.args.length === 2) {
                         const listName = this.getExpressionName(expr.args[0]);
                         const indexName = this.getExpressionName(expr.args[1]);
                         return `${listName}[${indexName}]`;
@@ -13189,7 +14396,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             case "literal": {
                 // For literals, use the string representation of the value
                 if (expr.value === null)
-                    return "NULL";
+                    return "null";
                 if (typeof expr.value === "string")
                     return `'${expr.value}'`;
                 // For arrays/objects, use JSON.stringify to preserve nested structure
@@ -13234,6 +14441,164 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 const operandName = this.getExpressionName(expr.operand);
                 return `${expr.operator} ${operandName}`;
             }
+            case "case": {
+                const parts = ["CASE"];
+                // Simple form: CASE <expr> WHEN <value> THEN <result> ...
+                if (expr.expression) {
+                    parts.push(this.getExpressionName(expr.expression));
+                }
+                const whens = expr.whens ?? [];
+                for (const whenClause of whens) {
+                    parts.push("WHEN");
+                    // If we have a simple-form CASE, the WHEN condition is stored as equality
+                    // against the CASE expression. For naming, reconstruct the original WHEN value.
+                    if (expr.expression &&
+                        whenClause.condition.type === "comparison" &&
+                        whenClause.condition.operator === "=" &&
+                        whenClause.condition.right) {
+                        parts.push(this.getExpressionName(whenClause.condition.right));
+                    }
+                    else {
+                        // Best-effort stringification for searched CASE conditions
+                        const cond = whenClause.condition;
+                        if (cond.type === "comparison" && cond.left && cond.right && cond.operator) {
+                            parts.push(`${this.getExpressionName(cond.left)} ${cond.operator} ${this.getExpressionName(cond.right)}`);
+                        }
+                        else if (cond.type === "and" && cond.conditions) {
+                            parts.push(cond.conditions.map(c => (c.type === "comparison" && c.left && c.right && c.operator)
+                                ? `${this.getExpressionName(c.left)} ${c.operator} ${this.getExpressionName(c.right)}`
+                                : "expr").join(" AND "));
+                        }
+                        else if (cond.type === "or" && cond.conditions) {
+                            parts.push(cond.conditions.map(c => (c.type === "comparison" && c.left && c.right && c.operator)
+                                ? `${this.getExpressionName(c.left)} ${c.operator} ${this.getExpressionName(c.right)}`
+                                : "expr").join(" OR "));
+                        }
+                        else if (cond.type === "not" && cond.condition) {
+                            parts.push(`NOT ${"expr"}`);
+                        }
+                        else if (cond.type === "isNull" && cond.left) {
+                            parts.push(`${this.getExpressionName(cond.left)} IS NULL`);
+                        }
+                        else if (cond.type === "isNotNull" && cond.left) {
+                            parts.push(`${this.getExpressionName(cond.left)} IS NOT NULL`);
+                        }
+                        else {
+                            parts.push("expr");
+                        }
+                    }
+                    parts.push("THEN");
+                    parts.push(this.getExpressionName(whenClause.result));
+                }
+                if (expr.elseExpr) {
+                    parts.push("ELSE");
+                    parts.push(this.getExpressionName(expr.elseExpr));
+                }
+                parts.push("END");
+                return parts.join(" ");
+            }
+            case "listComprehension": {
+                const canonicalFunctionName = (name) => {
+                    switch (name.toUpperCase()) {
+                        case "TOUPPER":
+                            return "toUpper";
+                        case "TOLOWER":
+                            return "toLower";
+                        case "TOINTEGER":
+                            return "toInteger";
+                        case "TOFLOAT":
+                            return "toFloat";
+                        case "TOSTRING":
+                            return "toString";
+                        case "TOBOOLEAN":
+                            return "toBoolean";
+                        default:
+                            return name.toLowerCase();
+                    }
+                };
+                const formatLiteralValue = (value) => {
+                    if (value === null)
+                        return "null";
+                    if (typeof value === "string")
+                        return `'${value}'`;
+                    if (typeof value === "boolean")
+                        return value ? "true" : "false";
+                    if (typeof value === "number")
+                        return String(value);
+                    if (Array.isArray(value)) {
+                        return `[${value.map(formatLiteralValue).join(", ")}]`;
+                    }
+                    if (typeof value === "object" && value !== null) {
+                        return JSON.stringify(value);
+                    }
+                    return String(value);
+                };
+                const formatExpression = (e) => {
+                    switch (e.type) {
+                        case "variable":
+                            return e.variable;
+                        case "property":
+                            return `${e.variable}.${e.property}`;
+                        case "literal":
+                            return formatLiteralValue(e.value);
+                        case "parameter":
+                            return `$${e.name}`;
+                        case "function": {
+                            const name = canonicalFunctionName(e.functionName);
+                            const args = (e.args ?? []).map(formatExpression);
+                            const distinctPrefix = e.distinct ? "DISTINCT " : "";
+                            if (e.star)
+                                return `${name}(*)`;
+                            return `${name}(${distinctPrefix}${args.join(", ")})`;
+                        }
+                        case "binary":
+                            return `${formatExpression(e.left)} ${e.operator} ${formatExpression(e.right)}`;
+                        case "unary":
+                            return `${e.operator} ${formatExpression(e.operand)}`;
+                        case "comparison": {
+                            const leftName = formatExpression(e.left);
+                            const op = e.comparisonOperator;
+                            if (op === "IS NULL" || op === "IS NOT NULL")
+                                return `${leftName} ${op}`;
+                            return `${leftName} ${op} ${formatExpression(e.right)}`;
+                        }
+                        case "in":
+                            return `${formatExpression(e.left)} IN ${formatExpression(e.list)}`;
+                        case "listComprehension":
+                            // Nested comprehension in naming
+                            return this.getExpressionName(e);
+                        default:
+                            return this.getExpressionName(e);
+                    }
+                };
+                const formatCondition = (c) => {
+                    switch (c.type) {
+                        case "comparison":
+                            if (c.left && c.right && c.operator) {
+                                return `${formatExpression(c.left)} ${c.operator} ${formatExpression(c.right)}`;
+                            }
+                            return "expr";
+                        case "and":
+                            return (c.conditions ?? []).map(formatCondition).join(" AND ");
+                        case "or":
+                            return (c.conditions ?? []).map(formatCondition).join(" OR ");
+                        case "not":
+                            return c.condition ? `NOT ${formatCondition(c.condition)}` : "expr";
+                        case "isNull":
+                            return c.left ? `${formatExpression(c.left)} IS NULL` : "expr";
+                        case "isNotNull":
+                            return c.left ? `${formatExpression(c.left)} IS NOT NULL` : "expr";
+                        case "in":
+                            return c.left && c.list ? `${formatExpression(c.left)} IN ${formatExpression(c.list)}` : "expr";
+                        default:
+                            return "expr";
+                    }
+                };
+                const listExprName = formatExpression(expr.listExpr);
+                const wherePart = expr.filterCondition ? ` WHERE ${formatCondition(expr.filterCondition)}` : "";
+                const mapPart = expr.mapExpr ? ` | ${formatExpression(expr.mapExpr)}` : "";
+                return `[${expr.variable} IN ${listExprName}${wherePart}${mapPart}]`;
+            }
             default:
                 return "expr";
         }
@@ -13250,7 +14615,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 continue;
             }
             // Get the column name (alias if provided, otherwise derived from expression)
-            const columnName = item.alias || this.getExpressionName(item.expression);
+            const columnName = this.getReturnItemName(item);
             if (seenNames.has(columnName)) {
                 throw new Error(`SyntaxError: ColumnNameConflict - Multiple result columns with the same name '${columnName}'`);
             }
@@ -13278,7 +14643,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         const returnedExpressions = [];
         for (const item of clause.items) {
             // Get the column name
-            const columnName = item.alias || this.getExpressionName(item.expression);
+            const columnName = this.getReturnItemName(item);
             availableColumns.add(columnName);
             returnedExpressions.push(item.expression);
             // If the expression is a whole variable (not a property), it's available for property access
@@ -13322,7 +14687,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         const availableColumns = new Set();
         const returnedExpressions = [];
         for (const item of clause.items) {
-            const columnName = item.alias || this.getExpressionName(item.expression);
+            const columnName = this.getReturnItemName(item);
             availableColumns.add(columnName);
             returnedExpressions.push(item.expression);
         }