Memgraph 2.4.1搭配neo4j-go-driver执行无RETURN路径Cypher时阻塞

问题场景 #

在Windows 11的WSL2环境运行Memgraph 2.4.1，使用neo4j-go-driver（v5版本）执行包含路径匹配但不带RETURN子句的Cypher语句时，程序会卡在sess.Close(ctx)或res.Consume(ctx)方法上。例如执行MATCH ()-[r]->() SET r.test = 123这类语句时触发阻塞，而带RETURN的语句则能正常运行。

复现代码：

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
)

const url = "bolt://localhost:7687"

func query(driver neo4j.DriverWithContext, cypher string) error {
    ctx := context.Background()
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    sess := driver.NewSession(ctx, neo4j.SessionConfig{})
    defer sess.Close(ctx) // 无RETURN时会卡在这里

    res, err := sess.Run(ctx, cypher, nil)
    if err != nil {
        return err
    }

    for res.Next(ctx) {
        fmt.Println(res.Record().Values...)
    }

    err = res.Err()
    if err != nil {
        return err
    }

    if res.IsOpen() {
        fmt.Println("trying to consume")
        _, err := res.Consume(ctx) // 无RETURN时也会卡在这里
        if err != nil {
            return err
        }
        fmt.Println("ok")
    }

    return nil
}

func example() error {
    driver, err := neo4j.NewDriverWithContext(url, neo4j.BasicAuth("", "", ""))
    if err != nil {
        return err
    }

    if err := query(driver, "RETURN 1+1"); err != nil {
        return err
    }
    if err := query(driver, "MATCH ()-[r]->() SET r.test = 123 RETURN DISTINCT 1"); err != nil {
        fmt.Println(err)
    }
    if err := query(driver, "MATCH ()-[r]->() SET r.test = 123"); err != nil {
        fmt.Println(err)
    }
    if err := query(driver, "MATCH (r)-[]->() SET r.test = 123"); err != nil {
        fmt.Println(err)
    }

    return nil
}

func main() {
    if err := example(); err != nil {
        panic(err)
    }
}

原因分析 #

Memgraph与Neo4j的Bolt协议实现存在细微差异：当执行无返回结果的写操作（尤其是包含路径匹配的语句）时，neo4j-go-driver会等待服务器返回结果集结束的信号，但Memgraph在这类场景下的信号发送逻辑与驱动预期不一致，导致驱动一直处于等待状态，最终阻塞。

解决方案 #

方案1：强制消耗结果集 #

去掉res.IsOpen()的判断，无论语句是否有RETURN子句，都主动调用res.Consume(ctx)，确保驱动正确处理服务器的响应，避免阻塞。

修改后的query函数：

func query(driver neo4j.DriverWithContext, cypher string) error {
    ctx := context.Background()
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    sess := driver.NewSession(ctx, neo4j.SessionConfig{})
    defer sess.Close(ctx)

    res, err := sess.Run(ctx, cypher, nil)
    if err != nil {
        return err
    }

    // 遍历所有返回记录（即使没有）
    for res.Next(ctx) {
        fmt.Println(res.Record().Values...)
    }

    if err := res.Err(); err != nil {
        return err
    }

    // 强制消耗结果集，确保驱动接收完整响应
    _, err = res.Consume(ctx)
    if err != nil {
        return err
    }

    return nil
}

方案2：使用显式事务执行写操作 #

对于无返回的写操作，改用事务的Run和Commit方法，驱动会更明确地处理事务结束信号，避免等待结果集的问题。

示例实现：

func queryWithTx(driver neo4j.DriverWithContext, cypher string) error {
    ctx := context.Background()
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    sess := driver.NewSession(ctx, neo4j.SessionConfig{})
    defer sess.Close(ctx)

    tx, err := sess.BeginTransaction(ctx)
    if err != nil {
        return err
    }
    defer tx.Rollback(ctx) // 确保未提交时回滚事务

    res, err := tx.Run(ctx, cypher, nil)
    if err != nil {
        return err
    }

    // 消耗结果集
    _, err = res.Consume(ctx)
    if err != nil {
        return err
    }

    return tx.Commit(ctx)
}

验证效果 #

修改后执行无RETURN的Cypher语句，程序不会再卡在sess.Close或res.Consume方法上，所有语句均可正常执行完成。

内容的提问来源于stack exchange，提问作者ZoomZoom