c4lliope

Pointers shared across function bounds in Rustler?

Hello! I think the Rust [sparrowdb] crate is a superb choice for modern graph dbs; I’m hoping to package this up in an elixir pkg.

[sparrowdb]: crates.io: Rust Package Registry

Here’s the sample code from their README:

    let db = GraphDb::open(std::path::Path::new("social.db"))?;

    db.execute("CREATE (alice:Person {name: 'Alice', age: 30})")?;
    db.execute("CREATE (bob:Person   {name: 'Bob',   age: 25})")?;
    db.execute("MATCH (a:Person {name:'Alice'}), (b:Person {name:'Bob'}) CREATE (a)-[:KNOWS]->(b)")?;

    // Who does Alice know? Who do *they* know?
    let fof = db.execute("MATCH (a:Person {name:'Alice'})-[:KNOWS*1..2]->(f) RETURN DISTINCT f.name")?;
    // -> [["Bob"], ["Carol"]]  (Carol is a friend-of-friend)
    let _ = fof;
    Ok(())

I can think of some simple changes to make this more approachable as an elixir module. Primarily, loading the db variable should be done in one function call, and each call to execute should be another function call.

I’ve come across this in another rust db package; how does one keep a reference to a rust object, such as db, loaded from a rustler function call? How do future rustler-bound functions refer to the same rust object (db) without leaking or cleaning up the memory address?

I’m new to Rust so I probably need to learn some lifetime attribute concepts. If there are common themes from other rustler packages that I can learn from, I’d be thrilled to find something that I can repurpose across the language boundary.

4 comments

#rustler

0 307 4

2026-06-12 23:58:54 UTC

Marked As Solved

kevinschweikert

The rustler API seems to have changed a bit. Functions now get auto registered when defining the #[rustler::nif] macro.

You can only define traits for structs when you either define the trait or define the struct. But here the trait is defined by rustler and the struct defined by sparrowdb. So we have to wrap it in our own type.

rustler also converts a Result type automatically to a tagged tuple in Elixir. Either {:ok, _} or {:error, _}.

use rustler::{Resource, ResourceArc};
use sparrowdb::GraphDb;

rustler::init!("Elixir.Spare.Native");

struct GraphDbResource(GraphDb);

#[rustler::resource_impl]
impl Resource for GraphDbResource {}

#[rustler::nif]
fn open(base: &str) -> Result<ResourceArc<GraphDbResource>, String> {
    match GraphDb::open(std::path::Path::new(base)) {
        Ok(graph) => Ok(ResourceArc::new(GraphDbResource(graph))),
        Err(e) => Err(e.to_string()),
    }
}

#[rustler::nif]
fn execute(graph_resource: ResourceArc<GraphDbResource>, cypher: &str) -> Result<String, String> {
    let db = &graph_resource.0;
    match db.execute(cypher) {
        Ok(result) => Ok(format!("{:?}", result)),
        Err(e) => Err(e.to_string()),
    }
}

With the example from the sparrowdb README:

iex(1)> {:ok, db} = Spare.Native.open("social.db")
{:ok, #Reference<0.3497539546.3541958666.218184>}
iex(2)> Spare.Native.execute(db, "CREATE (alice:Person {name: 'Alice', age: 30})")
{:ok, "QueryResult { columns: [], rows: [] }"}
iex(3)> Spare.Native.execute(db, "CREATE (bob:Person   {name: 'Bob',   age: 25})")
{:ok, "QueryResult { columns: [], rows: [] }"}
iex(4)> Spare.Native.execute(db, "MATCH (a:Person {name:'Alice'}), (b:Person {name:'Bob'}) CREATE (a)-[:KNOWS]->(b)")
{:ok, "QueryResult { columns: [], rows: [] }"}
iex(5)> Spare.Native.execute(db, "MATCH (a:Person {name:'Alice'})-[:KNOWS*1..2]->(f) RETURN DISTINCT f.name")
{:ok,
 "QueryResult { columns: [\"f.name\"], rows: [[String(\"Bob\")]] }"}

Happy hacking!

Post #4

Also Liked

kevinschweikert

That’s a resource in rustler. Have a look at this thread: Rustler return and pass reference from Rust to Elixir and back to Rust

Post #2

Last Post!

c4lliope

Amazing! I copied your code and was able to spin it up on a greyhound bus. I found a helpful example also in ryugraph_ex, and I’m bringing in pieces that seem useful. sparrow seems to miss some of the cypher spec, so I could perhaps make a benchmark using the opencypher cucumber specs. I’d like to also produce a Neo4j-compatible harness, to make use of their explorer and visualization ecology.

For people going through the same burrow, my first rabbit hole with rust embedded databases was fjall crates.io: Rust Package Registry - I assume this approach will be useful there also.

Post #5