Function debug_multi_hop_pattern

graphlite/tests/pattern_tests.rs:730–803

()

#[test]
fn debug_multi_hop_pattern() {
    let fixture = TestFixture::with_fraud_data().expect("Failed to create test fixture");

    log::debug!("=== Test 1: Basic multi-hop pattern ===");
    let query1 = "MATCH (a1:Account)-[:Transaction]->(m:Merchant)<-[:Transaction]-(a2:Account) RETURN count(*) as shared_merchants";

    let result1 = fixture.query(query1);
    match &result1 {
        Ok(r) => log::debug!("✅ Basic works: {} rows", r.rows.len()),
        Err(e) => log::debug!("❌ Basic failed: {:?}", e),
    }

    // Test 1.5: Simple two-hop without WHERE to see if a2 is bound at all
    log::debug!("=== Test 1.5: Two-hop without WHERE ===");
    let query1_5 = "MATCH (a1:Account)-[:Transaction]->(m:Merchant)<-[:Transaction]-(a2:Account) RETURN a1, a2, a1.account_number, a2.account_number LIMIT 3";

    let result1_5 = fixture.query(query1_5);
    match &result1_5 {
        Ok(r) => {
            log::debug!("✅ Two-hop without WHERE works: {} rows", r.rows.len());
            if let Some(first_row) = r.rows.first() {
                log::debug!(
                    "  Available variables: {:?}",
                    first_row.values.keys().collect::<Vec<_>>()
                );
                // Print first few actual values to debug
                for (key, value) in first_row.values.iter().take(4) {
                    log::debug!("    {} = {:?}", key, value);
                }
            }
        }
        Err(e) => log::debug!("❌ Two-hop without WHERE failed: {:?}", e),
    }

    log::debug!("=== Test 2: With != operator ===");
    let query2 = "MATCH (a1:Account)-[:Transaction]->(m:Merchant)<-[:Transaction]-(a2:Account) WHERE a1 != a2 RETURN count(*) as shared_merchants";

    let result2 = fixture.query(query2);
    match &result2 {
        Ok(r) => log::debug!("✅ != works: {} rows", r.rows.len()),
        Err(e) => log::debug!("❌ != failed: {:?}", e),
    }

    log::debug!("=== Test 3: With <> operator ===");
    let query3 = "MATCH (a1:Account)-[:Transaction]->(m:Merchant)<-[:Transaction]-(a2:Account) WHERE a1 <> a2 RETURN count(*) as shared_merchants";

    let result3 = fixture.query(query3);
    match &result3 {
        Ok(r) => log::debug!("✅ <> works: {} rows", r.rows.len()),
        Err(e) => log::debug!("❌ <> failed: {:?}", e),
    }

    // Test 4: Debug the physical plan generation
    log::debug!("=== Test 4: Debug physical plan ===");
    log::debug!("Let me check if I can trace the physical plan generation...");

    // For now, let's test if a simpler variable pattern works
    let simple_query = "MATCH (a:Account) RETURN a.account_number LIMIT 1";