Rust图数据库插件库kuzu的使用，kuzu提供高效图数据存储与查询功能

Kuzu是一个嵌入式图数据库，专为查询速度和可扩展性而构建。Kuzu优化了处理超大型数据库上的复杂分析工作负载，并提供了一系列检索功能，如全文搜索和向量索引。核心功能包括：

• 灵活的属性图数据模型和Cypher查询语言
• 可嵌入的、无服务器的应用程序集成
• 原生全文搜索和向量索引
• 基于列的磁盘存储
• 基于列的稀疏行(CSR)邻接列表/连接索引
• 向量化和因子化查询处理器
• 新颖且非常快速的连接算法
• 多核查询并行性
• 可序列化的ACID事务
• Wasm(WebAssembly)绑定，用于在浏览器中快速安全地执行

安装

对于Rust项目，可以使用以下命令安装kuzu：

cargo add kuzu

或者在你的Cargo.toml文件中添加：

kuzu = "0.11.1"

示例代码

以下是一个完整的使用kuzu的Rust示例：

use kuzu::{Database, Connection};

fn main() {
    // 创建或打开数据库
    let db = Database::new("test_db").unwrap();
    
    // 创建连接
    let mut conn = Connection::new(&db).unwrap();
    
    // 创建节点表
    conn.query("CREATE NODE TABLE Person(name STRING, age INT64, PRIMARY KEY(name))").unwrap();
    
    // 创建关系表
    conn.query("CREATE REL TABLE Knows(FROM Person TO Person, since INT64)").unwrap();
    
    // 插入数据
    conn.query("CREATE (p:Person {name: 'Alice', age: 35})").unwrap();
    conn.query("CREATE (p:Person {name: 'Bob', age: 30})").unwrap();
    conn.query("MATCH (a:Person), (b:Person) WHERE a.name = 'Alice' AND b.name = 'Bob' CREATE (a)-[:Knows {since: 2020}]->(b)").unwrap();
    
    // 查询数据
    let result = conn.query(
        "MATCH (a:Person)-[k:Knows]->(b:Person) RETURN a.name, b.name, k.since"
    ).unwrap();
    
    // 打印结果
    while let Some(row) = result.next().unwrap() {
        let alice_name: String = row.get(0).unwrap();
        let bob_name: String = row.get(1).unwrap();
        let since: i64 = row.get(2).unwrap();
        
        println!("{} 认识 {} 从 {} 年开始", alice_name, bob_name, since);
    }
}

这个示例展示了如何：

1. 创建或打开一个kuzu数据库
2. 创建节点表和关系表
3. 插入节点和关系数据
4. 执行查询并处理结果

高级特性

kuzu还支持许多高级特性，如：

// 批量插入数据
conn.query("COPY Person FROM \"data/persons.csv\" (HEADER=true)").unwrap();

// 使用参数化查询
let mut stmt = conn.prepare("MATCH (p:Person) WHERE p.age > $age RETURN p.name").unwrap();
stmt.bind("age", 30).unwrap();
let result = stmt.execute().unwrap();

// 事务处理
{
    let tx = conn.begin_transaction().unwrap();
    tx.query("CREATE (p:Person {name: 'Charlie', age: 25})").unwrap();
    tx.commit().unwrap();
}

Kuzu由Kùzu Inc.开发，采用MIT许可协议。欢迎尝试并提供反馈和功能请求。

完整示例demo

下面是一个更完整的kuzu使用示例，展示了更多功能：

use kuzu::{Database, Connection, Error};
use std::path::Path;

fn main() -> Result<(), Error> {
    // 1. 初始化数据库
    let db_path = Path::new("example_db");
    let db = Database::new(db_path)?;
    
    // 2. 创建连接
    let mut conn = Connection::new(&db)?;
    
    // 3. 创建schema
    // 创建节点表：用户
    conn.query("CREATE NODE TABLE User(id INT64, name STRING, PRIMARY KEY(id))")?;
    // 创建节点表：商品
    conn.query("CREATE NODE TABLE Product(id INT64, name STRING, price FLOAT, PRIMARY KEY(id))")?;
    // 创建关系表：购买
    conn.query("CREATE REL TABLE Purchased(FROM User TO Product, date STRING, quantity INT64)")?;
    
    // 4. 插入数据
    // 插入用户数据
    conn.query("CREATE (u:User {id: 1, name: 'Alice'})")?;
    conn.query("CREATE (u:User {id: 2, name: 'Bob'})")?;
    // 插入商品数据
    conn.query("CREATE (p:Product {id: 101, name: 'Laptop', price: 999.99})")?;
    conn.query("CREATE (p:Product {id: 102, name: 'Phone', price: 699.99})")?;
    // 插入购买关系
    conn.query("MATCH (u:User), (p:Product) WHERE u.id = 1 AND p.id = 101 CREATE (u)-[:Purchased {date: '2023-01-15', quantity: 1}]->(p)")?;
    conn.query("MATCH (u:User), (p:Product) WHERE u.id = 2 AND p.id = 102 CREATE (u)-[:Purchased {date: '2023-01-20', quantity: 2}]->(p)")?;
    
    // 5. 查询示例
    // 简单查询
    println!("--- 所有用户 ---");
    let users = conn.query("MATCH (u:User) RETURN u.id, u.name")?;
    while let Some(row) = users.next()? {
        let id: i64 = row.get(0)?;
        let name: String = row.get(1)?;
        println!("用户ID: {}, 姓名: {}", id, name);
    }
    
    // 复杂查询：查找购买了特定商品的用户
    println!("\n--- 购买了Laptop的用户 ---");
    let laptop_buyers = conn.query(
        "MATCH (u:User)-[p:Purchased]->(prod:Product) 
         WHERE prod.name = 'Laptop' 
         RETURN u.name, p.date, p.quantity"
    )?;
    while let Some(row) = laptop_buyers.next()? {
        let name: String = row.get(0)?;
        let date: String = row.get(1)?;
        let qty: i64 = row.get(2)?;
        println!("用户 {} 于 {} 购买了 {} 台", name, date, qty);
    }
    
    // 6. 使用事务
    println!("\n--- 事务示例 ---");
    {
        let tx = conn.begin_transaction()?;
        tx.query("CREATE (p:Product {id: 103, name: 'Tablet', price: 299.99})")?;
        tx.query("MATCH (u:User), (p:Product) WHERE u.id = 1 AND p.id = 103 CREATE (u)-[:Purchased {date: '2023-02-01', quantity: 1}]->(p)")?;
        tx.commit()?;
    }
    
    // 7. 参数化查询
    println!("\n--- 参数化查询 ---");
    let mut stmt = conn.prepare("MATCH (u:User)-[p:Purchased]->(prod:Product) WHERE p.quantity > $min_qty RETURN u.name, prod.name, p.quantity")?;
    stmt.bind("min_qty", 1)?;
    let high_qty_purchases = stmt.execute()?;
    while let Some(row) = high_qty_purchases.next()? {
        let user: String = row.get(0)?;
        let product: String = row.get(1)?;
        let qty: i64 = row.get(2)?;
        println!("用户 {} 购买了 {} (数量: {})", user, product, qty);
    }
    
    Ok(())
}

这个完整示例展示了：

1. 数据库初始化和连接创建
2. 创建节点表和关系表
3. 插入节点和关系数据
4. 简单查询和复杂查询
5. 事务处理
6. 参数化查询

所有操作都包含错误处理，使用了Rust的Result类型。