GRAPH_MVCC

Rust implementation of Multiversion Concurrency Control for graph databases.

What is Graph MVCC • Features • How To Use • Documentation • License

🛎 Important Notices

• This is version 0.2.0 and is still in active development
• The current version is not recommended for production use (Work in Progress)

📌 Table of Contents

Table of Contents

1. What is Graph MVCC
2. Features
• Core Features
• Technical Features
3. How to Use
4. Work in Progress
5. Documentation
6. Author
7. Support
8. Contributing
9. License

🤔 What is Graph MVCC

graph_mvcc is a Rust crate implementing a Multiversion Concurrency Control (MVCC) graph database. This crate provides a transactional graph data structure with support for nodes, edges, and snapshot isolation. It ensures atomic operations, consistent views of the graph state, and conflict detection for concurrent transactions.

Use Cases

• Transactional Graph Operations: Build graph databases with ACID guarantees
• Concurrent Access: Handle multiple simultaneous transactions safely
• Graph Analytics: Implement complex graph algorithms with consistent data views
• Research & Development: Experiment with MVCC concepts in graph structures
• Educational Tools: Learn about transaction isolation and concurrency control

📷 Features

Core Features

• Transactional Operations: Supports atomic transactions with commit and rollback capabilities
• Snapshot Isolation: Ensures each transaction sees a consistent view of the graph at the time it starts
• Node and Edge Management: Allows creation and manipulation of nodes and edges with type-based collision detection
• MVCC: Implements multiversion concurrency control to manage concurrent transactions without conflicts

Technical Features

• Deterministic Design: Single-threaded deterministic implementation
• UUID-based Identifiers: Proper Node/Edge Management with unique identifiers for all nodes and edges
• Graph Traversal: Support for path-based graph traversal using edge types
• Temporary Transactions: Automatic transaction creation for null transaction operations
• State Management: Proper tracking of active transactions and rollback actions
• Collision Detection: Type-based edge collision detection following MVCC principles

🚙 How to Use

Installation

Install with cargo.

cargo add graph_mvcc

Example

use graph_mvcc::Graph;

fn main() {
    let mut graph = Graph::new();
    let mut tx = graph.start_transaction();

    // Add nodes
    let node1 = graph.add_node(&mut tx);
    let node2 = graph.add_node(&mut tx);

    // Add an edge between nodes
    graph.add_edge(&mut tx, &node1, &node2, "CONNECTS".to_string()).unwrap();

    // Commit the transaction
    graph.commit_transaction(&tx).unwrap();
    
    println!("Successfully created graph with 2 nodes and 1 edge");
}

Work in Progress

I've bumped the version to 0.2.0, but there's still a lot of work to do. This project can be used to experiment with MVCC on a graph data structure, but please shelve any ideas of using the current version (0.2.0) in production. My main goal now is to try and offload all node- and edge-handling, to the excellent graph crate.

📚 Documentation

Comprehensive documentation is available at docs.rs/graph_mvcc, including:

• API reference for all public types and functions
• Examples of transaction management
• Performance considerations and best practices
• Implementation details of MVCC for graphs

🖊 Author

CryptoPatrick

Keybase Verification:
https://keybase.io/cryptopatrick/sigs/8epNh5h2FtIX1UNNmf8YQ-k33M8J-Md4LnAN

🐣 Support

Leave a ⭐ if you think this project is cool.

🤝 Contributing

Found a bug? Missing a specific feature? Contributions are welcome! Please see our contributing guidelines for details on:

• Code style and testing requirements
• Submitting bug reports and feature requests
• Development setup and workflow

🗄 License

This project is licensed under MIT. See LICENSE for details.