Fix(hql): Correct IS_IN validation and runtime handling for internal node IDs

[ishaksebsib]

Description

Problem

• Analyzer Issue: The type validator incorrectly grouped IS_IN with other boolean operations, expecting scalar arguments instead of arrays. This caused compilation errors for queries like nodes::WHERE(_::{id}::IS_IN(node_ids)) when node_ids is [ID].
• Runtime Panic: after parsing, queries using IS_IN to filter by internal node IDs caused a panic: "Value is not an id" at value.rs:1591. This happened
  because check_property("id") returned Value::String (stringified UUID), but IS_IN's is_in method requires Value::Id for ID operations (via IntoPrimitive<ID>).
• Root Cause: Type mismatch in both analysis (expecting scalars for arrays) and runtime (wrong Value variant for IDs).
• Impact: IS_IN with arrays failed at compile-time or runtime, preventing valid queries from working.

What We Solved

• Analyzer Fix: Separated IS_IN validation in traversal_validation.rs to expect Type::Array(Box<Type::Scalar(ft))) for arguments, ensuring array element compatibility.
• Runtime Fix: Updated check_property("id") in filterable.rs to return Value::Id(ID::from(self.id)) instead of Value::String(...), aligning with IntoPrimitive<ID> expectations.
• Result: IS_IN now correctly validates and executes with arrays, resolving panics while preserving ID string serialization in responses.

The fixes ensure type safety for array operations and proper handling of reserved properties.

Related Issues

None

Checklist when merging to main

• No compiler warnings (if applicable)
• Code is formatted with rustfmt
• No useless or dead code (if applicable)
• Code is easy to understand
• Doc comments are used for all functions, enums, structs, and fields (where appropriate)
• All tests pass
• Performance has not regressed (assuming change was not to fix a bug)
• Version number has been updated in helix-cli/Cargo.toml and helixdb/Cargo.toml

Additional Notes

None

Greptile Overview

Updated On: 2025-10-21 12:34:05 UTC

Summary

This PR fixes IS_IN operator to work correctly with array arguments by addressing type validation at compile-time and value handling at runtime.

Changes:

• Analyzer (traversal_validation.rs): Separated IS_IN from scalar boolean operations, now correctly expects Type::Array(Box<Type::Scalar(ft))) and validates array element types match the field type
• Runtime (filterable.rs, vector.rs): Changed check_property("id") for Node, Edge, and HVector to return Value::Id(ID::from(self.id)) instead of Value::String, ensuring compatibility with IntoPrimitive<ID> trait used by Value::is_in() method

Impact:
Enables queries like nodes::WHERE(_::{id}::IS_IN(node_ids)) to compile and execute without panics, resolving both the analyzer's incorrect type expectations and the runtime's value variant mismatch.

Important Files Changed

File Analysis

Filename	Score	Overview
helix-db/src/utils/filterable.rs	5/5	Changed check_property("id") to return Value::Id(ID::from(self.id)) for both Node and Edge, fixing runtime panics in IS_IN operations
helix-db/src/helix_engine/vector_core/vector.rs	5/5	Updated HVector's check_property("id") to return Value::Id(ID::from(self.id)), ensuring consistency with Node and Edge implementations
helix-db/src/helixc/analyzer/methods/traversal_validation.rs	5/5	Separated IS_IN validation from scalar boolean operations to correctly expect Type::Array arguments with scalar elements, fixing compile-time type checking

Sequence Diagram

sequenceDiagram
    participant Query as HQL Query
    participant Analyzer as traversal_validation
    participant Runtime as check_property
    participant IsIn as Value is_in
    participant IntoPrim as IntoPrimitive

    Query->>Analyzer: nodes WHERE id IS_IN node_ids
    
    alt Before Analyzer Fix
        Note over Analyzer: IS_IN grouped with scalar ops
        Analyzer->>Analyzer: Expect Type Scalar
        Analyzer-->>Query: Error Expected scalar got array
    end
    
    alt After Analyzer Fix
        Note over Analyzer: IS_IN separated from scalar ops
        Analyzer->>Analyzer: Check IS_IN arg type
        Analyzer->>Analyzer: Expect Type Array of Scalar
        Analyzer->>Analyzer: Validate array element type
        Analyzer-->>Query: Compilation succeeds
    end
    
    Query->>Runtime: Execute filter by ID
    Runtime->>Runtime: check_property id
    
    alt Before Runtime Fix
        Runtime-->>IsIn: Value String uuid_string
        IsIn->>IntoPrim: into_primitive ID
        IntoPrim-->>IsIn: panic Value is not an id
    end
    
    alt After Runtime Fix
        Runtime-->>IsIn: Value Id ID from self id
        IsIn->>IntoPrim: into_primitive ID
        IntoPrim-->>IsIn: Returns ID reference
        IsIn-->>Query: Returns filter result
    end

Loading

[greptile-apps]

Additional Comments (1)

1. helix-db/src/utils/filterable.rs, line 230 (link)

   logic: Edge's id property returns Value::String (via Value::from(self.uuid())), while Node now returns Value::Id. This inconsistency will cause the same panic if IS_IN is used on edge IDs.

_{2 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[ishaksebsib]

@greptile

[greptile-apps]

_{2 files reviewed, no comments}

_{Edit Code Review Agent Settings | Greptile}