Saltearse al contenido

Embebido (Rust)

Dependencias

Depende de los crates de almacenamiento y consultas en un tag exacto:

[dependencies]
namidb-storage = { git = "https://github.com/namidb/namidb", tag = "v3.3.0" }
namidb-query = { git = "https://github.com/namidb/namidb", tag = "v3.3.0" }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
anyhow = "1"

Se requiere Rust 1.85 o superior. El crate fachada namidb actualmente solo reexporta los tipos de datos puros de namidb-core (esquema, ids); todavía no es una API de motor embebido.

Features de Cargo opcionales, desactivadas por defecto:

Feature (en namidb-query y en namidb-storage)Habilita
vector-indexConstruir y usar índices vectoriales persistentes
text-indexConstruir y usar índices full-text persistentes

Un programa completo

Este programa abre un namespace, escribe y lee con Cypher, y hace flush. Se compiló y ejecutó contra v3.2.1 tal como se muestra; v3.3.0 solo agrega elementos a la API de estos crates:

use namidb_query::{execute, execute_write, parse, plan, Params, RuntimeValue, StatsCatalog};
use namidb_storage::{parse_uri, WriterSession};
/// Parse, plan and run one Cypher statement. Writes are committed
/// (WAL append + manifest CAS) before `execute_write` returns.
async fn cypher(writer: &mut WriterSession, src: &str, params: &Params) -> anyhow::Result<()> {
let query = parse(src).map_err(|e| anyhow::anyhow!("{e:?}"))?;
let catalog = StatsCatalog::from_manifest(&writer.snapshot().manifest().manifest);
let plan = plan(&query, &catalog)?;
if plan.contains_write() {
let outcome = execute_write(&plan, writer, params).await?;
println!("nodes created: {}", outcome.nodes_created);
} else {
let snapshot = writer.snapshot();
for row in execute(&plan, &snapshot, params).await? {
println!("{:?}", row.bindings);
}
}
Ok(())
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
// Or file:///var/lib/namidb?ns=prod, s3://bucket?ns=prod, gs://…, az://…
let (store, paths) = parse_uri("memory://demo")?;
let mut writer = WriterSession::open(store, paths).await?;
let none = Params::new();
cypher(&mut writer, "CREATE (:Person {name: 'Alice', age: 30})", &none).await?;
cypher(&mut writer, "CREATE (:Person {name: 'Bob', age: 25})", &none).await?;
let mut params = Params::new();
params.insert("min".into(), RuntimeValue::Integer(18));
cypher(
&mut writer,
"MATCH (p:Person) WHERE p.age >= $min RETURN p.name AS name ORDER BY name",
&params,
)
.await?;
// Push the memtable into L0 SSTs (the server does this on a timer).
let schema = writer.schema().clone();
writer.flush(schema).await?;
Ok(())
}

Salida:

nodes created: 1
nodes created: 1
{"name": String("Alice")}
{"name": String("Bob")}

De qué te haces cargo

Embeber los crates te da el motor sin las comodidades que agregan el servidor y el cliente de Python:

  • Mantenimiento. Nada hace flush, compacta ni hace sweep por sí solo. Llama a WriterSession::flush con regularidad y ejecuta la compactación (WriterSession::compact_l0) después de las cargas.
  • DDL de esquema. CREATE CONSTRAINT, CREATE INDEX, CREATE VECTOR INDEX y similares no se traducen a planes de consulta; el servidor y la CLI los interceptan. En Rust llama a los métodos de esquema de WriterSession (create_unique_constraint_named, create_property_index_named, create_composite_index_named, register_vector_index, register_text_index, drop_vector_index, drop_text_index).
  • Límites. No hay timeout de consulta, límite de filas ni gobernador de memoria salvo que los agregues (execute_write_with_deadline acepta un deadline).
  • Un writer por namespace. WriterSession::open reclama el namespace y bloquea (fencing) a cualquier otro writer, exactamente igual que los demás puntos de entrada.

La referencia de la API está en la página de la librería de Rust.