Features

Cypher, the language your team already reads

A large part of openCypher and the Neo4j dialect, parsed and planned by GraphBuff itself. What is not supported yet returns an Unsupported error rather than a wrong answer.

PROFILE MATCH (p:Person)-[:ACTED_IN]->(m:Movie {title: 'The Matrix'}) RETURN p.name ORDER BY p.name

Select [3 rows, 0.000 ms]
  Sort p.name [3 rows, 0.008 ms]
    Project p.name [3 rows, 0.002 ms]
      Expand(All) (m)<-[:ACTED_IN]-(p:Person) (~0.5 rows) [3 rows, 0.002 ms]
        NodeByLabelScan (m:Movie {…}) (~3.0 rows) [1 row, 0.007 ms]
          Start [1 row, 0.001 ms]

Three storage engines, chosen per database

Open a database in memory, make it durable with a write-ahead log, or page it from disk when it no longer fits in RAM. The Database API and every query stay the same.

let db = Database::open(StorageMode::InMemory)?;

let db = Database::open(StorageMode::hybrid("data/movies"))?;

let db = Database::open(StorageMode::Persistent(
    PersistentOptions::new("data/web")
        .cache_bytes(1 << 30),
))?;

Nodes with more than 50 relationships become dense: their relationships are grouped by type, so a typed expansion only walks the matching group.

Graph algorithms as procedures

Call them from Cypher and keep working with the results in the same query. Each takes an optional map with relationshipTypes and orientation.

CALL algo.pageRank({relationshipTypes: 'FOLLOWS'}) YIELD node, score
RETURN node.name, score ORDER BY score DESC LIMIT 10

Snapshot reads, serialised writes

Queries that write run one at a time. Read queries never wait for them: each reads a snapshot of the last commit, so it sees all or nothing of every write. All three storage engines take snapshots.

let mut tx = db.begin()?;
tx.execute("MATCH (a:Account {id: 1}) SET a.balance = a.balance - 10")?;
tx.execute("MATCH (a:Account {id: 2}) SET a.balance = a.balance + 10")?;
tx.commit()?; // or tx.rollback(); dropping an open transaction rolls it back

• Per-query time limits and cancellation from another thread
• A cap on transaction size instead of an unbounded page cache
• Explicit transactions over HTTP and Bolt, rolled back after an idle timeout

HTTP/JSON and Bolt from one server

graphbuff-server serves many named databases. HTTP is one JSON request per query, from any language. With --bolt it also speaks Bolt 4.4 and 5.0 to 5.4, so the official Neo4j drivers connect unchanged, including neo4j:// routing URIs.

• Neo4j drivers
• Python 5.28, 6.4
• Java 5.28, 6.0

Users, roles and TLS

Users log in with HTTP Basic or Bolt basic. Passwords are stored as PBKDF2-HMAC-SHA-256 with 600,000 rounds. Roles apply to open connections the moment they are granted or revoked.

graphbuff-server --tls-cert cert.pem --tls-key key.pem --bolt 0.0.0.0:7687 --users users.txt
# drivers connect with bolt+s://, browsers and curl with https://

Bulk import, backup and checks

graphbuff import reads CSV in the neo4j-admin database import format and writes store records directly, without Cypher or a redo log.

graphbuff backup  --data data --database social --to backups/social-monday
graphbuff restore --from backups/social-monday --data data --database social --overwrite
graphbuff check   --data data --database social   # exit code 1 if inconsistent