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-index | Construir y usar índices vectoriales persistentes |
text-index | Construir 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", ¶ms, ) .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: 1nodes 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::flushcon regularidad y ejecuta la compactación (WriterSession::compact_l0) después de las cargas. - DDL de esquema.
CREATE CONSTRAINT,CREATE INDEX,CREATE VECTOR INDEXy similares no se traducen a planes de consulta; el servidor y la CLI los interceptan. En Rust llama a los métodos de esquema deWriterSession(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_deadlineacepta un deadline). - Un writer por namespace.
WriterSession::openreclama 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.