Name: ZoneTree
Author: Ahmed Yasin Koculu

ZoneTree v1.8.3 — nugetz

Insert Benchmarks	1M	2M	3M	10M
int-int ZoneTree async-compressed WAL	267 ms	464 ms	716 ms	2693 ms
int-int ZoneTree sync-compressed WAL	834 ms	1617 ms	2546 ms	8642 ms
int-int ZoneTree sync WAL	2742 ms	5533 ms	8242 ms	27497 ms

str-str ZoneTree async-compressed WAL	892 ms	1833 ms	2711 ms	9443 ms
str-str ZoneTree sync-compressed WAL	1752 ms	3397 ms	5070 ms	19153 ms
str-str ZoneTree sync WAL	3488 ms	7002 ms	10483 ms	38727 ms

RocksDb sync WAL (10K => 11 sec)	~1,100,000 ms	N/A	N/A	N/A
int-int RocksDb sync-compressed WAL	8059 ms	16188 ms	23599 ms	61947 ms
str-str RocksDb sync-compressed WAL	8215 ms	16146 ms	23760 ms	72491 ms

DiskCompressionBlockSize = 10 * 1024 * 1024; // 10 MB
WALCompressionBlockSize = 32 * 1024 * 8;     // 256 KB
DiskSegmentMode = DiskSegmentMode.SingleDiskSegment;
MutableSegmentMaxItemCount = 1_000_000;
ThresholdForMergeOperationStart = 2_000_000;

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.22000
Processor: Intel Core i7-6850K CPU @ 3.60GHz (Skylake), 12 logical cores, 6 physical cores
Memory: 64 GB DDR4
Storage: Samsung SSD 850 EVO 1TB
Configuration: 1M mutable segment size, 2M readonly segments merge-threshold

using Tenray.ZoneTree;

using var zoneTree = new ZoneTreeFactory<int, string>()
    .OpenOrCreate();

zoneTree.Upsert(39, "Hello ZoneTree");

using Tenray.ZoneTree;
using Tenray.ZoneTree.Comparers;
using Tenray.ZoneTree.Serializers;

var dataPath = "data/mydatabase";

using var zoneTree = new ZoneTreeFactory<int, string>()
    .SetComparer(new Int32ComparerAscending())
    .SetDataDirectory(dataPath)
    .SetKeySerializer(new Int32Serializer())
    .SetValueSerializer(new Utf8StringSerializer())
    .OpenOrCreate();

// Atomic (thread-safe) operation on single mutable-segment.
zoneTree.Upsert(39, "Hello ZoneTree!");

// Atomic operation across all segments.
zoneTree.TryAtomicAddOrUpdate(39, "a", (ref string x) =>
{
    x += "b";
    return true;
}, out var opIndex);

using Tenray.ZoneTree;
using Tenray.ZoneTree.Maintenance;

var dataPath = "data/mydatabase";

using var zoneTree = new ZoneTreeFactory<int, string>()
    .SetComparer(new Int32ComparerAscending())
    .SetDataDirectory(dataPath)
    .SetKeySerializer(new Int32Serializer())
    .SetValueSerializer(new Utf8StringSerializer())
    .OpenOrCreate();

using var maintainer = zoneTree.CreateMaintainer();
maintainer.EnableJobForCleaningInactiveCaches = true;

// Perform read/write operations.
zoneTree.Upsert(39, "Hello ZoneTree!");

// Wait for background maintenance tasks to complete.
maintainer.WaitForBackgroundThreads();

using Tenray.ZoneTree;

using var zoneTree = new ZoneTreeFactory<int, int>()
    .SetIsDeletedDelegate((in int key, in int value) => value == -1)
    .SetMarkValueDeletedDelegate((ref int x) => x = -1)
    .OpenOrCreate();

// Deleting a key by setting its value to -1
zoneTree.Upsert(42, -1);

using System.Runtime.InteropServices;
using Tenray.ZoneTree;

[StructLayout(LayoutKind.Sequential)]
struct MyDeletableValueType
{
    public int Number;
    public bool IsDeleted;
}

using var zoneTree = new ZoneTreeFactory<int, MyDeletableValueType>()
    .SetIsDeletedDelegate((in int key, in MyDeletableValueType value) => value.IsDeleted)
    .SetMarkValueDeletedDelegate((ref MyDeletableValueType value) => value.IsDeleted = true)
    .OpenOrCreate();

// Deleting a key by setting the IsDeleted flag
zoneTree.Upsert(42, new MyDeletableValueType { Number = 0, IsDeleted = true });

using Tenray.ZoneTree;
using Tenray.ZoneTree.Collections;

using var zoneTree = new ZoneTreeFactory<int, int>()
    .OpenOrCreate();

// Forward iteration
using var iterator = zoneTree.CreateIterator();
while (iterator.Next())
{
    var key = iterator.CurrentKey;
    var value = iterator.CurrentValue;
    // Process key and value
}

// Backward iteration
using var reverseIterator = zoneTree.CreateReverseIterator();
while (reverseIterator.Next())
{
    var key = reverseIterator.CurrentKey;
    var value = reverseIterator.CurrentValue;
    // Process key and value
}

using Tenray.ZoneTree;
using Tenray.ZoneTree.Collections;

using var zoneTree = new ZoneTreeFactory<string, int>()
    .OpenOrCreate();

using var iterator = zoneTree.CreateIterator();

// Jump to the first record starting with "SomePrefix"
if (iterator.Seek("SomePrefix"))
{
    do
    {
        var key = iterator.CurrentKey;
        var value = iterator.CurrentValue;
        // Process key and value
    }
    while (iterator.Next());
}

using System.Threading.Tasks;
using Tenray.ZoneTree;
using Tenray.ZoneTree.Transaction;

using var zoneTree = new ZoneTreeFactory<int, int>()
    .OpenOrCreateTransactional();

using var transaction = zoneTree
    .BeginFluentTransaction()
    .Do(tx => zoneTree.UpsertNoThrow(tx, 3, 9))
    .Do(tx =>
    {
        if (zoneTree.TryGetNoThrow(tx, 3, out var value).IsAborted)
            return TransactionResult.Aborted();

        if (zoneTree.UpsertNoThrow(tx, 3, 21).IsAborted)
            return TransactionResult.Aborted();

        return TransactionResult.Success();
    })
    .SetRetryCountForPendingTransactions(100)
    .SetRetryCountForAbortedTransactions(10);

await transaction.CommitAsync();

using System;
using System.Threading;
using Tenray.ZoneTree;
using Tenray.ZoneTree.Transaction;

using var zoneTree = new ZoneTreeFactory<int, int>()
    .OpenOrCreateTransactional();

try
{
    var txId = zoneTree.BeginTransaction();

    zoneTree.TryGet(txId, 3, out var value);
    zoneTree.Upsert(txId, 3, 9);

    var result = zoneTree.Prepare(txId);
    while (result.IsPendingTransactions)
    {
        Thread.Sleep(100);
        result = zoneTree.Prepare(txId);
    }

    zoneTree.Commit(txId);
}
catch (TransactionAbortedException)
{
    // Handle aborted transaction (retry or cancel)
}

using System;
using System.Threading.Tasks;
using Tenray.ZoneTree.Transactional;

public async Task<bool> ExecuteTransactionWithRetryAsync(ZoneTreeFactory<int, int> zoneTreeFactory, int maxRetries = 3)
{
    using var zoneTree = zoneTreeFactory.OpenOrCreateTransactional();
    var transactionId = zoneTree.BeginTransaction();

    // Execute the operations within the transaction
    var result = zoneTree.UpsertNoThrow(transactionId, 1, 100);
    if (result.IsAborted)
        return false; // Abort the transaction and return false on failure.

    result = zoneTree.UpsertNoThrow(transactionId, 2, 200);
    if (result.IsAborted)
        return false; // Abort the transaction and return false on failure.

    // Retry only the prepare step
    int retryCount = 0;
    while (retryCount <= maxRetries)
    {
        var prepareResult = zoneTree.PrepareNoThrow(transactionId);
        if (prepareResult.IsAborted)
            return false; // Abort the transaction and return false on failure.

        if (prepareResult.IsPendingTransactions)
        {
            await Task.Delay(100); // Simple delay before retrying
            retryCount++;
            continue; // Retry the prepare step
        }

        if (prepareResult.IsReadyToCommit)
            break; // Exit loop if ready to commit
    }

    // After successfully preparing, commit the transaction
    var commitResult = zoneTree.CommitNoThrow(transactionId);
    if (commitResult.IsAborted)
        return false; // Abort the transaction and return false on failure.

    // Transaction committed successfully
    return true;
}

Feature	Description
.NET Compatibility	Works seamlessly with .NET primitives, structs, and classes.
High Performance and Low Memory Consumption	Optimized algorithms ensure fast operations with minimal resource usage.
Crash Resilience	Robust mechanisms protect data integrity against unexpected failures.
Efficient Disk Space Utilization	Optimized storage strategies minimize disk space requirements.
Data Compression	Supports WAL and DiskSegment data compression for efficient storage.
Fast Load/Unload	Quickly load and unload large datasets as needed.
Standard CRUD Operations	Provides intuitive and straightforward Create, Read, Update, Delete functionalities.
Optimistic Transactions	Supports concurrent operations with minimal locking overhead.
Atomic Read-Modify-Update	Ensures data consistency during complex update operations.
In-Memory and Disk Storage	Flexibly operate entirely in memory or persist data to various storage backends.
Cloud Storage Support	Compatible with cloud-based storage solutions for scalable deployments.
ACID Compliance	Guarantees Atomicity, Consistency, Isolation, and Durability across transactions.
Multiple WAL Modes	Choose from four different WAL modes to balance performance and durability.
Configurable Memory Usage	Adjust the amount of data retained in memory based on application needs.
Partial and Complete Data Loading	Load data partially (with sparse arrays) or completely to and from disk.
Bidirectional Iteration	Efficiently iterate over data both forward and backward.
Optional Dirty Reads	Allow for faster reads when strict consistency is not required.
Embeddable Design	Integrate ZoneTree directly into applications without external dependencies.
SSD Optimization	Tailored for optimal performance on solid-state drives.
Exceptionless Transaction API	Manage transactions smoothly without relying on exceptions for control flow.
Fluent Transaction API	Utilize an intuitive, chainable transaction interface with retry capabilities.
Easy Maintenance	Simplified maintenance processes ensure consistent performance.
Configurable LSM Merger	Customize merge operations to suit specific workload patterns.
Transparent Implementation	Clear and straightforward codebase reveals internal workings for easy understanding.
Open-Source with MIT License	Freely use, modify, and distribute under a permissive license.
Transaction Log Compaction	Efficiently manage and reduce the size of transaction logs.
Transaction Analysis and Control	Analyze and manage transactions for improved performance and reliability.
Efficient Concurrency Control	Minimal overhead through innovative separation of concurrency stamps and data.
Time-To-Live (TTL) Support	Automatically expire data after a specified duration.
Custom Serializer and Comparer Support	Implement custom logic for data serialization and comparison.
Multiple Disk Segments Mode	Divide data files into configurable chunks for better manageability and performance.
Snapshot Iterators	Create consistent snapshots for data analysis and backup purposes.

koculu/ZoneTreev1.8.3

Get Started

Readme

ZoneTree

Table of Contents

Why Choose ZoneTree?

Performance

Benchmark Results

Write-Ahead Log (WAL) Modes

Benchmark Environment

Getting Started

Basic Usage

Creating a Database

Maintaining the LSM Tree

Handling Deletions

Using an Integer Deletion Flag

Using a Custom Struct for Deletion

Data Iteration

Forward and Backward Iteration

Seekable Iterator

Transaction Support

Fluent Transactions

Classical Transactions

Exceptionless Transactions

Feature Highlights

ZoneTree.FullTextSearch

Documentation

Contributing

License