FeOxDB
Ultra-fast embedded key-value database with sub-microsecond latency
FeOxDB Overview
FeOxDB is a high-performance embedded key-value store designed for applications requiring sub-microsecond latency. Built in Rust, it offers ultra-low latency operations, lock-free concurrent access, and flexible storage options (memory-only or persistent). FeOxDB is ideal for systems where performance is critical, such as real-time analytics, high-frequency trading, and caching layers. It provides ACI (Atomicity, Consistency, Isolation) properties with relaxed durability, trading full durability for extreme performance. With features like JSON Patch support, atomic operations, and efficient cache eviction, FeOxDB is a powerful solution for developers needing fast, reliable data storage.
FeOxDB Screenshot
FeOxDB Official screenshot of the tool interface
FeOxDB Core Features
Ultra-Low Latency
FeOxDB delivers sub-microsecond latency with GET operations under 200ns and INSERT operations under 700ns. This performance is achieved through lock-free data structures and optimized memory access patterns.
Lock-Free Operations
Utilizes SCC HashMap and SkipList for concurrent access, enabling high-throughput operations without the overhead of traditional locking mechanisms.
io_uring Support (Linux)
Leverages kernel-bypass I/O for maximum throughput with minimal syscalls, significantly reducing I/O latency and increasing performance on Linux systems.
Flexible Storage
Supports both memory-only and persistent modes with async I/O, allowing developers to choose the best balance between performance and durability for their use case.
JSON Patch Support
RFC 6902 compliant partial updates for JSON values, enabling efficient modifications to JSON documents without full rewrites.
Atomic Operations
Includes compare-and-swap (CAS) and atomic counters, providing safe concurrent updates and optimistic concurrency control.
CLOCK Cache
Implements an efficient cache eviction algorithm to keep frequently accessed data in memory, optimizing performance for read-heavy workloads.
Write Buffering
Uses batched writes with sharded buffers to reduce contention and improve throughput, especially in high-concurrency scenarios.
Statistics
Provides real-time performance metrics and monitoring, giving developers insights into database performance and behavior.
ACID Properties with Relaxed Durability
Offers Atomicity, Consistency, and Isolation with relaxed durability, allowing for extreme performance while still maintaining critical data integrity properties.
FeOxDB Use Cases
High-Frequency Trading Systems
FeOxDB's sub-microsecond latency makes it ideal for storing and accessing market data in real-time trading systems where every nanosecond counts.
Real-Time Analytics
The database's high throughput and low latency enable real-time processing and analysis of streaming data for immediate insights.
Caching Layer
With its ultra-fast access times and efficient cache eviction algorithm, FeOxDB serves as an excellent caching layer for web applications and APIs.
Session Storage
Built-in TTL support makes FeOxDB perfect for managing user sessions with automatic expiration of stale entries.
Configuration Management
Atomic operations and compare-and-swap functionality provide safe, concurrent updates to system configurations without locking.
How to Use FeOxDB
Create a store instance: Choose between memory-only or persistent mode. For memory-only (fastest performance), use `FeOxStore::new(None)`. For persistent storage, provide a path to your data file.
Perform basic operations: Use `insert()`, `get()`, and `delete()` methods for basic key-value operations. All operations are thread-safe and can be called concurrently.
Utilize advanced features: Take advantage of range queries, JSON Patch operations, atomic counters, and compare-and-swap operations for more complex use cases.
Manage durability: In persistent mode, writes are automatically buffered. Call `store.flush()` to synchronously write all buffered data when durability is required.
Monitor performance: Access real-time metrics through the statistics interface to monitor store performance and behavior.
Optimize configuration: Use the builder pattern to fine-tune parameters like file size, memory limits, hash buckets, and TTL support for your specific workload.