google/leveldb
Leveldb
LevelDB is an embedded database library and persistent storage engine that provides a sorted key-value store. It uses a log-structured merge-tree architecture to map byte arrays to values, running directly within a process to provide storage without the need for a separate server process.
The system is distinguished by its use of custom comparison functions to define key ordering, enabling efficient range scans and sequenced lookups. It ensures data reliability through atomic batch execution, consistent snapshot generation, and log-based recovery after failures.
The engine covers broad capability areas including data management, storage maintenance, and performance optimization. It implements write-ahead logging and multi-level compaction to manage disk space, while utilizing block-based caching and data compression to optimize read and write throughput.
Low-level integration is handled through an abstract file system interface that decouples the storage engine from the operating system.
Features
- Embedded Databases - Provides a high-performance storage engine that runs within the application process without a separate server.
- Log-Structured Merge-Trees - Employs a log-structured merge-tree architecture to optimize write throughput and read performance.
- Database Atomic Batches - Group multiple mutations into a single batch to ensure they are applied as one indivisible unit in the project.
- Custom Key Ordering - Specify a custom comparison function to determine how keys are sorted and stored in the project.
- Storage Compaction Utilities - Performs background multi-level compaction to merge sorted files and reclaim disk space.
- Data Iterators - Provides sequential iterators for traversing stored entries in forward or backward order.
- Database Key Scanning - Implements key range scanning to iterate over dataset entries between two boundaries.
- Sorted String Tables - Stores data in sorted immutable tables (SSTables) to enable efficient binary search lookups.
- Key-Value Store Iterators - Traverse the project dataset in forward and backward directions to process keys and values in sequence.
- Sorted - Maintains entries in a specific sequence using custom comparison functions for efficient range scans.
- Persistent Storage Engines - Provides a low-level system for managing disk data with atomic batches, snapshots, and background compaction.
- Key-Value - Provides a persistent, embedded key-value store mapping byte arrays to values.
- Log-Structured Merge-Trees - Utilizes a log-structured merge-tree architecture to provide fast, ordered mapping of keys to values.
- Write-Ahead Logging - Implements write-ahead logging to record every mutation for durability and crash recovery.
- Sorted Data Management - Maintains keys in a sorted sequence using comparison functions for efficient range scans.
- Sorted Memory Buffers - Buffers recent writes in a sorted MemTable before flushing them to immutable disk tables.
- Batch Data Operations - Provides batch write operations to improve throughput and maintain atomic consistency.
- Write Throughput Optimizations - Uses atomic batches and asynchronous writes to handle large volumes of data updates efficiently.
- Point-In-Time Snapshots - Generates consistent point-in-time snapshots to allow reads without interference from concurrent updates.
- Data Compression - Compresses and decompresses data to balance processing performance with disk space reduction.
- Data Compression Algorithms - Reduces the disk space footprint by automatically compressing stored data.
- Caching and Performance - Accelerates data retrieval using block-based caching and filtered lookup policies to reduce disk reads.
- Write Persistence Guarantees - Allows choosing between asynchronous writes for performance and synchronous writes to ensure data durability.
- Atomic Transaction Execution - Supports grouping multiple mutations into a single atomic batch to ensure data consistency.
- Data Recovery - Reconstructs state after failures by processing manifest files and log chunks.
- File Storage Management - Identifies and deletes stale log and table files that are no longer referenced by the current state.
- In-Memory Caches - Implements block-based caching to reduce disk read operations and accelerate data retrieval.
- Persistent Application State - Saves application state to disk with support for snapshots and crash recovery.
- Data Integrity - Uses cyclic redundancy checks to validate data blocks and detect corruption during disk I/O.
- File System Abstractions - Decouples the storage engine from the operating system using an abstract file system interface.
- Database Systems - Fast key-value storage library for ordered string mappings.
- 数据库 - Fast key-value storage library.
- Databases and Data - Fast key-value storage library.
- Storage Systems - Fast key-value storage library for embedded use.
