{"id":13415064,"url":"https://github.com/koculu/ZoneTree","last_synced_at":"2025-03-14T22:32:43.382Z","repository":{"id":43232407,"uuid":"511139581","full_name":"koculu/ZoneTree","owner":"koculu","description":"ZoneTree is a persistent, high-performance, transactional, and ACID-compliant ordered key-value database for .NET. It operates seamlessly both in-memory and on local/cloud storage, making it an ideal choice for a wide range of applications requiring efficient data management.","archived":false,"fork":false,"pushed_at":"2024-10-16T04:52:11.000Z","size":1457,"stargazers_count":349,"open_issues_count":0,"forks_count":32,"subscribers_count":7,"default_branch":"main","last_synced_at":"2024-10-17T18:23:10.197Z","etag":null,"topics":["atomicity","binary-tree","cloud-disk","concurrency-control","concurrent","consistency","database","durability","isolation","iterator","key-value-database","key-value-store","library","linux","lsm-tree","microservices","multi-threaded","persistence","recoverable","transactional"],"latest_commit_sha":null,"homepage":"https://tenray.io/","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/koculu.png","metadata":{"funding":{"github":"koculu","patreon":null,"open_collective":null,"ko_fi":null,"tidelift":null,"community_bridge":null,"liberapay":null,"issuehunt":null,"otechie":null,"lfx_crowdfunding":null,"custom":null},"files":{"readme":"README.md","changelog":null,"contributing":".github/CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":".github/CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-07-06T13:02:20.000Z","updated_at":"2024-10-16T08:55:16.000Z","dependencies_parsed_at":"2023-12-12T20:41:56.735Z","dependency_job_id":"589a9a00-a315-493f-9ca1-6d43d6551197","html_url":"https://github.com/koculu/ZoneTree","commit_stats":null,"previous_names":[],"tags_count":79,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/koculu%2FZoneTree","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/koculu%2FZoneTree/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/koculu%2FZoneTree/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/koculu%2FZoneTree/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/koculu","download_url":"https://codeload.github.com/koculu/ZoneTree/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":243658057,"owners_count":20326459,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["atomicity","binary-tree","cloud-disk","concurrency-control","concurrent","consistency","database","durability","isolation","iterator","key-value-database","key-value-store","library","linux","lsm-tree","microservices","multi-threaded","persistence","recoverable","transactional"],"created_at":"2024-07-30T21:00:42.573Z","updated_at":"2025-03-14T22:32:43.368Z","avatar_url":"https://github.com/koculu.png","language":"C#","readme":"![ZoneTree Logo](https://raw.githubusercontent.com/koculu/ZoneTree/main/src/ZoneTree/docs/ZoneTree/images/logo2.png)\n\n# ZoneTree\n\nZoneTree is a **persistent**, **high-performance**, **transactional**, and **ACID-compliant** [ordered key-value database](https://en.wikipedia.org/wiki/Ordered_Key-Value_Store) for .NET. It operates seamlessly both **in-memory** and on **local/cloud storage**, making it an ideal choice for a wide range of applications requiring efficient data management.\n\n![License](https://img.shields.io/badge/license-MIT-blue.svg)\n[![Downloads](https://img.shields.io/nuget/dt/ZoneTree)](https://www.nuget.org/packages/ZoneTree/)\n![Platform](https://img.shields.io/badge/platform-.NET-blue.svg)\n![Build](https://img.shields.io/badge/build-passing-brightgreen.svg)\n[![Join Discord](https://dcbadge.vercel.app/api/server/d9aDtzVNNv?logoColor=f1c400\u0026theme=discord\u0026style=flat)](https://discord.gg/d9aDtzVNNv)\n\n## Table of Contents\n\n- [Why Choose ZoneTree?](#why-choose-zonetree)\n- [Performance](#performance)\n  - [Benchmark Results](#benchmark-results)\n  - [Write-Ahead Log (WAL) Modes](#write-ahead-log-wal-modes)\n  - [Benchmark Environment](#benchmark-environment)\n- [Getting Started](#getting-started)\n  - [Basic Usage](#basic-usage)\n  - [Creating a Database](#creating-a-database)\n- [Maintaining the LSM Tree](#maintaining-the-lsm-tree)\n- [Handling Deletions](#handling-deletions)\n  - [Using an Integer Deletion Flag](#using-an-integer-deletion-flag)\n  - [Using a Custom Struct for Deletion](#using-a-custom-struct-for-deletion)\n- [Data Iteration](#data-iteration)\n  - [Forward and Backward Iteration](#forward-and-backward-iteration)\n  - [Seekable Iterator](#seekable-iterator)\n- [Transaction Support](#transaction-support)\n  - [Fluent Transactions](#fluent-transactions)\n  - [Classical Transactions](#classical-transactions)\n  - [Exceptionless Transactions](#exceptionless-transactions)\n- [Feature Highlights](#feature-highlights)\n- [ZoneTree.FullTextSearch](#zonetreefulltextsearch)\n- [Documentation](#documentation)\n- [Contributing](#contributing)\n- [License](#license)\n\n---\n\n## Why Choose ZoneTree?\n\n1. **Pure C# Implementation**: ZoneTree is developed entirely in C#, ensuring seamless integration and deployment within .NET ecosystems without external dependencies.\n\n2. **Exceptional Performance**: Demonstrates performance several times faster than Facebook's RocksDB and hundreds of times faster than SQLite. Optimized for both speed and efficiency.\n\n3. **Data Durability and Crash Resilience**: Provides optional durability features that protect data against crashes and power outages, ensuring data integrity under all circumstances.\n\n4. **Transactional and ACID-Compliant**: Supports both transactional and non-transactional access with full ACID guarantees, offering flexibility for various application requirements.\n\n5. **Embeddable Database Engine**: Easily embed ZoneTree into applications, eliminating the overhead of maintaining or shipping separate database products.\n\n6. **Scalability**: Capable of handling small to massive datasets, allowing the creation of both scalable and non-scalable databases tailored to specific needs.\n\n---\n\n## Performance\n\nZoneTree sets new standards in database performance, showcasing remarkable speeds in data insertion, loading, and iteration operations.\n\n### Benchmark Results\n\n- **100 Million integer key-value pairs** inserted in **20 seconds** using **WAL mode = NONE**.\n- **Loading** database with 100 million integer key-value pairs takes **812 milliseconds**.\n- **Iterating** over 100 million key-value pairs completes in **24 seconds**.\n\n**Detailed Benchmark for Various Modes:**\n\n| Insert Benchmarks                         | 1M            | 2M       | 3M       | 10M      |\n| ----------------------------------------- | ------------- | -------- | -------- | -------- |\n| **int-int ZoneTree async-compressed WAL** | 267 ms        | 464 ms   | 716 ms   | 2693 ms  |\n| **int-int ZoneTree sync-compressed WAL**  | 834 ms        | 1617 ms  | 2546 ms  | 8642 ms  |\n| **int-int ZoneTree sync WAL**             | 2742 ms       | 5533 ms  | 8242 ms  | 27497 ms |\n|                                           |               |          |          |          |\n| **str-str ZoneTree async-compressed WAL** | 892 ms        | 1833 ms  | 2711 ms  | 9443 ms  |\n| **str-str ZoneTree sync-compressed WAL**  | 1752 ms       | 3397 ms  | 5070 ms  | 19153 ms |\n| **str-str ZoneTree sync WAL**             | 3488 ms       | 7002 ms  | 10483 ms | 38727 ms |\n|                                           |               |          |          |          |\n| **int-int RocksDb sync-compressed WAL**   | 8059 ms       | 16188 ms | 23599 ms | 61947 ms |\n| **str-str RocksDb sync-compressed WAL**   | 8215 ms       | 16146 ms | 23760 ms | 72491 ms |\n\n**[Full Benchmark Results](https://raw.githubusercontent.com/koculu/ZoneTree/main/src/Playground/BenchmarkForAllModes.txt)**\n\n**Benchmark Configuration:**\n\n```csharp\nDiskCompressionBlockSize = 10 * 1024 * 1024; // 10 MB\nWALCompressionBlockSize = 32 * 1024 * 8;     // 256 KB\nDiskSegmentMode = DiskSegmentMode.SingleDiskSegment;\nMutableSegmentMaxItemCount = 1_000_000;\nThresholdForMergeOperationStart = 2_000_000;\n```\n\n**Additional Notes:**\n\n- ZoneTree has been tested successfully with up to **1 billion records** on standard desktop computers, demonstrating stability and efficiency even with very large datasets.\n\n### Write-Ahead Log (WAL) Modes\n\nZoneTree offers **four WAL modes** to provide flexibility between performance and durability:\n\n1. **Sync Mode**:\n\n   - **Durability**: Maximum.\n   - **Performance**: Slower write speed.\n   - **Use Case**: Ensures data is not lost in case of crashes or power cuts.\n\n2. **Sync-Compressed Mode**:\n\n   - **Durability**: High, but slightly less than sync mode.\n   - **Performance**: Faster write speed due to compression.\n   - **Use Case**: Balances durability and performance; periodic jobs can persist decompressed tail records for added safety.\n\n3. **Async-Compressed Mode**:\n\n   - **Durability**: Moderate.\n   - **Performance**: Very fast write speed; logs are written in a separate thread.\n   - **Use Case**: Suitable where immediate durability is less critical but performance is paramount.\n\n4. **None Mode**:\n   - **Durability**: No immediate durability; relies on manual or automatic disk saves.\n   - **Performance**: Maximum possible.\n   - **Use Case**: Ideal for scenarios where performance is critical and data can be reconstructed or is not mission-critical.\n\n### Benchmark Environment\n\n```\nBenchmarkDotNet=v0.13.1, OS=Windows 10.0.22000\nProcessor: Intel Core i7-6850K CPU @ 3.60GHz (Skylake), 12 logical cores, 6 physical cores\nMemory: 64 GB DDR4\nStorage: Samsung SSD 850 EVO 1TB\nConfiguration: 1M mutable segment size, 2M readonly segments merge-threshold\n```\n\n---\n\n## Getting Started\n\nZoneTree is designed for ease of use, allowing developers to integrate and utilize its capabilities with minimal setup.\n\n### Basic Usage\n\n```csharp\nusing Tenray.ZoneTree;\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, string\u003e()\n    .OpenOrCreate();\n\nzoneTree.Upsert(39, \"Hello ZoneTree\");\n```\n\n### Creating a Database\n\n```csharp\nusing Tenray.ZoneTree;\nusing Tenray.ZoneTree.Comparers;\nusing Tenray.ZoneTree.Serializers;\n\nvar dataPath = \"data/mydatabase\";\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, string\u003e()\n    .SetComparer(new Int32ComparerAscending())\n    .SetDataDirectory(dataPath)\n    .SetKeySerializer(new Int32Serializer())\n    .SetValueSerializer(new Utf8StringSerializer())\n    .OpenOrCreate();\n\n// Atomic (thread-safe) operation on single mutable-segment.\nzoneTree.Upsert(39, \"Hello ZoneTree!\");\n\n// Atomic operation across all segments.\nzoneTree.TryAtomicAddOrUpdate(39, \"a\", (ref string x) =\u003e\n{\n    x += \"b\";\n    return true;\n}, out var opIndex);\n```\n\n---\n\n## Maintaining the LSM Tree\n\nLarge-scale LSM Trees require periodic maintenance to ensure optimal performance and resource utilization. ZoneTree provides the `IZoneTreeMaintenance` interface to facilitate comprehensive maintenance tasks.\n\n**Example Usage:**\n\n```csharp\nusing Tenray.ZoneTree;\nusing Tenray.ZoneTree.Maintenance;\n\nvar dataPath = \"data/mydatabase\";\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, string\u003e()\n    .SetComparer(new Int32ComparerAscending())\n    .SetDataDirectory(dataPath)\n    .SetKeySerializer(new Int32Serializer())\n    .SetValueSerializer(new Utf8StringSerializer())\n    .OpenOrCreate();\n\nusing var maintainer = zoneTree.CreateMaintainer();\nmaintainer.EnableJobForCleaningInactiveCaches = true;\n\n// Perform read/write operations.\nzoneTree.Upsert(39, \"Hello ZoneTree!\");\n\n// Wait for background maintenance tasks to complete.\nmaintainer.WaitForBackgroundThreads();\n```\n\n**Note:** For smaller datasets, maintenance tasks may not be necessary. The default maintainer allows developers to focus on core business logic without delving into LSM tree intricacies.\n\n---\n\n## Handling Deletions\n\nIn **Log-Structured Merge (LSM) trees**, deletions are managed by upserting a key/value pair with a **deletion marker**. Actual data removal occurs during the **compaction** stage.\n\nBy default, ZoneTree assumes that **default values** indicate deletion. This behavior can be customized by defining specific deletion flags or disabling deletions entirely using the `DisableDeletion` method.\n\n### Using an Integer Deletion Flag\n\nIn this example, `-1` is used as the deletion marker for integer values:\n\n```csharp\nusing Tenray.ZoneTree;\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, int\u003e()\n    .SetIsDeletedDelegate((in int key, in int value) =\u003e value == -1)\n    .SetMarkValueDeletedDelegate((ref int value) =\u003e value = -1)\n    .OpenOrCreate();\n\n// Deleting a key by setting its value to -1\nzoneTree.Upsert(42, -1);\n```\n\n### Using a Custom Struct for Deletion\n\nFor more control, define a custom structure to represent values and their deletion status:\n\n```csharp\nusing System.Runtime.InteropServices;\nusing Tenray.ZoneTree;\n\n[StructLayout(LayoutKind.Sequential)]\nstruct MyDeletableValueType\n{\n    public int Number;\n    public bool IsDeleted;\n}\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, MyDeletableValueType\u003e()\n    .SetIsDeletedDelegate((in int key, in MyDeletableValueType value) =\u003e value.IsDeleted)\n    .SetMarkValueDeletedDelegate((ref MyDeletableValueType value) =\u003e value.IsDeleted = true)\n    .OpenOrCreate();\n\n// Deleting a key by setting the IsDeleted flag\nzoneTree.Upsert(42, new MyDeletableValueType { Number = 0, IsDeleted = true });\n```\n\n---\n\n## Data Iteration\n\nZoneTree provides efficient mechanisms to iterate over data both **forward** and **backward**, with equal performance in both directions. Iterators also support **seek** operations for quick access to specific keys.\n\n### Forward and Backward Iteration\n\n```csharp\nusing Tenray.ZoneTree;\nusing Tenray.ZoneTree.Collections;\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, int\u003e()\n    .OpenOrCreate();\n\n// Forward iteration\nusing var iterator = zoneTree.CreateIterator();\nwhile (iterator.Next())\n{\n    var key = iterator.CurrentKey;\n    var value = iterator.CurrentValue;\n    // Process key and value\n}\n\n// Backward iteration\nusing var reverseIterator = zoneTree.CreateReverseIterator();\nwhile (reverseIterator.Next())\n{\n    var key = reverseIterator.CurrentKey;\n    var value = reverseIterator.CurrentValue;\n    // Process key and value\n}\n```\n\n### Seekable Iterator\n\nThe `ZoneTreeIterator` supports the `Seek()` method to jump to any record with **O(log(n))** complexity, useful for prefix searches and range queries.\n\n```csharp\nusing Tenray.ZoneTree;\nusing Tenray.ZoneTree.Collections;\n\nusing var zoneTree = new ZoneTreeFactory\u003cstring, int\u003e()\n    .OpenOrCreate();\n\nusing var iterator = zoneTree.CreateIterator();\n\n// Jump to the first record starting with \"SomePrefix\"\nif (iterator.Seek(\"SomePrefix\"))\n{\n    do\n    {\n        var key = iterator.CurrentKey;\n        var value = iterator.CurrentValue;\n        // Process key and value\n    }\n    while (iterator.Next());\n}\n```\n\n---\n\n## Transaction Support\n\nZoneTree supports **Optimistic Transactions**, ensuring **ACID compliance** while offering flexibility through various transaction models:\n\n1. **Fluent Transactions**: Provides an intuitive, chainable API with built-in retry capabilities.\n2. **Classical Transactions**: Traditional approach with explicit control over transaction lifecycle.\n3. **Exceptionless Transactions**: Allows transaction management without relying on exceptions for control flow.\n\n### Fluent Transactions\n\n```csharp\nusing System.Threading.Tasks;\nusing Tenray.ZoneTree;\nusing Tenray.ZoneTree.Transaction;\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, int\u003e()\n    .OpenOrCreateTransactional();\n\nusing var transaction = zoneTree\n    .BeginFluentTransaction()\n    .Do(tx =\u003e zoneTree.UpsertNoThrow(tx, 3, 9))\n    .Do(tx =\u003e\n    {\n        if (zoneTree.TryGetNoThrow(tx, 3, out var value).IsAborted)\n            return TransactionResult.Aborted();\n\n        if (zoneTree.UpsertNoThrow(tx, 3, 21).IsAborted)\n            return TransactionResult.Aborted();\n\n        return TransactionResult.Success();\n    })\n    .SetRetryCountForPendingTransactions(100)\n    .SetRetryCountForAbortedTransactions(10);\n\nawait transaction.CommitAsync();\n```\n\n### Classical Transactions\n\n```csharp\nusing System;\nusing System.Threading;\nusing Tenray.ZoneTree;\nusing Tenray.ZoneTree.Transaction;\n\nusing var zoneTree = new ZoneTreeFactory\u003cint, int\u003e()\n    .OpenOrCreateTransactional();\n\ntry\n{\n    var txId = zoneTree.BeginTransaction();\n\n    zoneTree.TryGet(txId, 3, out var value);\n    zoneTree.Upsert(txId, 3, 9);\n\n    var result = zoneTree.Prepare(txId);\n    while (result.IsPendingTransactions)\n    {\n        Thread.Sleep(100);\n        result = zoneTree.Prepare(txId);\n    }\n\n    zoneTree.Commit(txId);\n}\ncatch (TransactionAbortedException)\n{\n    // Handle aborted transaction (retry or cancel)\n}\n```\n\n### Exceptionless Transactions\n\n```csharp\nusing System;\nusing System.Threading.Tasks;\nusing Tenray.ZoneTree.Transactional;\n\npublic async Task\u003cbool\u003e ExecuteTransactionWithRetryAsync(ZoneTreeFactory\u003cint, int\u003e zoneTreeFactory, int maxRetries = 3)\n{\n    using var zoneTree = zoneTreeFactory.OpenOrCreateTransactional();\n    var transactionId = zoneTree.BeginTransaction();\n\n    // Execute the operations within the transaction\n    var result = zoneTree.UpsertNoThrow(transactionId, 1, 100);\n    if (result.IsAborted)\n        return false; // Abort the transaction and return false on failure.\n\n    result = zoneTree.UpsertNoThrow(transactionId, 2, 200);\n    if (result.IsAborted)\n        return false; // Abort the transaction and return false on failure.\n\n    // Retry only the prepare step\n    int retryCount = 0;\n    while (retryCount \u003c= maxRetries)\n    {\n        var prepareResult = zoneTree.PrepareNoThrow(transactionId);\n        if (prepareResult.IsAborted)\n            return false; // Abort the transaction and return false on failure.\n\n        if (prepareResult.IsPendingTransactions)\n        {\n            await Task.Delay(100); // Simple delay before retrying\n            retryCount++;\n            continue; // Retry the prepare step\n        }\n\n        if (prepareResult.IsReadyToCommit)\n            break; // Exit loop if ready to commit\n    }\n\n    // After successfully preparing, commit the transaction\n    var commitResult = zoneTree.CommitNoThrow(transactionId);\n    if (commitResult.IsAborted)\n        return false; // Abort the transaction and return false on failure.\n\n    // Transaction committed successfully\n    return true;\n}\n```\n\n---\n\n## Feature Highlights\n\n| Feature                                         | Description                                                                          |\n| ----------------------------------------------- | ------------------------------------------------------------------------------------ |\n| **.NET Compatibility**                          | Works seamlessly with .NET primitives, structs, and classes.                         |\n| **High Performance and Low Memory Consumption** | Optimized algorithms ensure fast operations with minimal resource usage.             |\n| **Crash Resilience**                            | Robust mechanisms protect data integrity against unexpected failures.                |\n| **Efficient Disk Space Utilization**            | Optimized storage strategies minimize disk space requirements.                       |\n| **Data Compression**                            | Supports WAL and DiskSegment data compression for efficient storage.                 |\n| **Fast Load/Unload**                            | Quickly load and unload large datasets as needed.                                    |\n| **Standard CRUD Operations**                    | Provides intuitive and straightforward Create, Read, Update, Delete functionalities. |\n| **Optimistic Transactions**                     | Supports concurrent operations with minimal locking overhead.                        |\n| **Atomic Read-Modify-Update**                   | Ensures data consistency during complex update operations.                           |\n| **In-Memory and Disk Storage**                  | Flexibly operate entirely in memory or persist data to various storage backends.     |\n| **Cloud Storage Support**                       | Compatible with cloud-based storage solutions for scalable deployments.              |\n| **ACID Compliance**                             | Guarantees Atomicity, Consistency, Isolation, and Durability across transactions.    |\n| **Multiple WAL Modes**                          | Choose from four different WAL modes to balance performance and durability.          |\n| **Configurable Memory Usage**                   | Adjust the amount of data retained in memory based on application needs.             |\n| **Partial and Complete Data Loading**           | Load data partially (with sparse arrays) or completely to and from disk.             |\n| **Bidirectional Iteration**                     | Efficiently iterate over data both forward and backward.                             |\n| **Optional Dirty Reads**                        | Allow for faster reads when strict consistency is not required.                      |\n| **Embeddable Design**                           | Integrate ZoneTree directly into applications without external dependencies.         |\n| **SSD Optimization**                            | Tailored for optimal performance on solid-state drives.                              |\n| **Exceptionless Transaction API**               | Manage transactions smoothly without relying on exceptions for control flow.         |\n| **Fluent Transaction API**                      | Utilize an intuitive, chainable transaction interface with retry capabilities.       |\n| **Easy Maintenance**                            | Simplified maintenance processes ensure consistent performance.                      |\n| **Configurable LSM Merger**                     | Customize merge operations to suit specific workload patterns.                       |\n| **Transparent Implementation**                  | Clear and straightforward codebase reveals internal workings for easy understanding. |\n| **Open-Source with MIT License**                | Freely use, modify, and distribute under a permissive license.                       |\n| **Transaction Log Compaction**                  | Efficiently manage and reduce the size of transaction logs.                          |\n| **Transaction Analysis and Control**            | Analyze and manage transactions for improved performance and reliability.            |\n| **Efficient Concurrency Control**               | Minimal overhead through innovative separation of concurrency stamps and data.       |\n| **Time-To-Live (TTL) Support**                  | Automatically expire data after a specified duration.                                |\n| **Custom Serializer and Comparer Support**      | Implement custom logic for data serialization and comparison.                        |\n| **Multiple Disk Segments Mode**                 | Divide data files into configurable chunks for better manageability and performance. |\n| **Snapshot Iterators**                          | Create consistent snapshots for data analysis and backup purposes.                   |\n\n---\n\n## ZoneTree.FullTextSearch\n\n[ZoneTree.FullTextSearch](https://www.nuget.org/packages/ZoneTree.FullTextSearch/) is an extension library built upon ZoneTree, providing a **high-performance** and **flexible full-text search engine** for .NET applications.\n\n**Key Features Include:**\n\n- **Fast and Efficient Indexing**: Handles large volumes of text data with impressive speed.\n- **Advanced Query Support**: Enables complex search queries with support for Boolean operators and faceted search.\n- **Customizable Components**: Allows integration of custom tokenizers, stemmers, and normalizers to suit specific application needs.\n- **Scalable Architecture**: Designed to scale seamlessly with growing data and usage demands.\n\nFor more information and detailed documentation, visit the [ZoneTree.FullTextSearch GitHub Repository](https://github.com/koculu/ZoneTree.FullTextSearch).\n\n---\n\n## Documentation\n\nExplore comprehensive guides and API references to get the most out of ZoneTree:\n\n- **[Introduction](https://tenray.io/docs/ZoneTree/guide/introduction.html)**\n- **[Quick Start Guide](https://tenray.io/docs/ZoneTree/guide/quick-start.html)**\n- **[API Documentation](https://tenray.io/docs/ZoneTree/api/Tenray.ZoneTree.html)**\n- **[Tuning ZoneTree](https://tenray.io/docs/ZoneTree/guide/tuning-disk-segment.html)**\n- **[Features Overview](https://tenray.io/docs/ZoneTree/guide/features.html)**\n- **[Terminology](https://tenray.io/docs/ZoneTree/guide/terminology.html)**\n- **[Performance Details](https://tenray.io/docs/ZoneTree/guide/performance.html)**\n\n---\n\n## Contributing\n\nContributions are highly appreciated and welcomed! Here’s how you can help:\n\n1. **Write Tests and Benchmarks**: Improve code reliability and performance analysis.\n2. **Enhance Documentation**: Help others understand and utilize ZoneTree effectively.\n3. **Submit Feature Requests and Bug Reports**: Share ideas and report issues to refine ZoneTree further.\n4. **Optimize Performance**: Contribute optimizations and improvements to existing functionalities.\n\nPlease follow the guidelines outlined in **[CONTRIBUTING.md](https://github.com/koculu/ZoneTree/blob/main/.github/CONTRIBUTING.md)** to get started.\n\n---\n\n## License\n\nZoneTree is licensed under the **[MIT License](https://github.com/koculu/ZoneTree?tab=MIT-1-ov-file#readme)**, allowing for flexible use and distribution.\n","funding_links":["https://github.com/sponsors/koculu"],"categories":["Database","DataBase"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkoculu%2FZoneTree","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fkoculu%2FZoneTree","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkoculu%2FZoneTree/lists"}