The Agnesoft Graph Database (aka agdb) is persistent memory mapped graph database using object 'no-text' queries. It can be used as a main persistent storage, data analytics platform as well as fast in-memory cache. Its typed schema-less data store allows for flexible and seamless data updates with no downtime or costly migrations. All queries are constructed via a builder pattern (or directly as objects) with no special language or text parsing.
cargo add agdb
Basic usage demonstrating creating a database, inserting graph elements with data and querying them back with select and search. The function using this code must handle agdb::DbError and agdb::QueryError error types for operator ? to work:
```Rust use agdb::{Db, DbId, QueryBuilder, UserValue, DbUserValue, Comparison::Equal};
let mut db = Db::new("db_file.agdb")?;
db.exec_mut(&QueryBuilder::insert().nodes().aliases("users").query())?;
struct User { dbid: Option
let usersids = db.execmut(&QueryBuilder::insert().nodes().values(&users).query())?;
db.execmut( &QueryBuilder::insert() .edges() .from("users") .to(&usersids) .query(), )?; ```
This code creates a database called user_db.agdb with a simple graph of 4 nodes. The first node is aliased users and 3 user nodes for Alice, Bob and John are then connected with edges to the users node. The arbitrary name property is attached to the user nodes. Rather than inserting values directly with keys (which is also possible) we use our own type and derive from agdb::UserValue to allow it to be used with the database.
You can select the graph elements (both nodes & edges) with their ids to get them back with their associated data (key-value properties). Lets select our users and convert the result into the list (notice we select only values relevant to our User type with passing User::db_keys()):
```Rust
let users: Vec
println!("{:?}", users); // [User { dbid: Some(DbId(2)), username: "Alice" }, // User { dbid: Some(DbId(3)), username: "Bob" }, // User { db_id: Some(DbId(4)), username: "John" }] ```
You can also search through the graph to get back only certain elements based on conditions. For example:
```Rust let user: User = db .exec( &QueryBuilder::select() .values(User::dbkeys()) .ids( QueryBuilder::search() .from("users") .where() .key("name") .value(Equal("Bob".into())) .query(), ) .query(), )? .try_into()?;
println!("{:?}", user); // User { db_id: Some(DbId(3)), username: "Bob" } ```
For database concepts and primitive data types see concepts. For comprehensive overview of all queries see the queries reference or continue with more in-depth efficient agdb.
The following are planned features in priority order:
| Feature | Description | | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Ability to disable memory mapping | Memory mapping aids with read performance but for databases larger than few GBs it is not very practical. To allow larger databases disable memory mapping and do reads from the database file directly. | | Object query (de)serialization | To facilitate use of the database from other languages or process the query objects and results must allow (de)serialization. | | Server mode | Executable version of the database to be accessed via network (REST & websocket). | | Data replication & RAFT protocol | Allow replication by connecting several database nodes together with a RAFT protocol. | | Data sharding | Allow sharding single database data set across multiple nodes to allow super large databases. |