RocksDB через P/Invoke в PowerShell

RocksDB — это высокопроизводительная встраиваемая key-value база данных от Facebook:

• Основана на LevelDB от Google
• Оптимизирована для быстрых SSD
• LSM-дерево (Log-Structured Merge Tree)
• Поддержка многопоточности
• Используется в MySQL (MyRocks), MongoDB, Cassandra

Архитектура RocksDB

graph TB
    A[PowerShell App] --> B[P/Invoke Marshal]
    B --> C[rocksdb.dll - C API]
    C --> D[RocksDB Engine]

    subgraph "LSM Tree Structure"
        D --> E[MemTable
In-Memory Buffer]
        E --> F[WAL
Write-Ahead Log]
        E --> G[Level 0 SST Files]
        G --> H[Level 1 SST Files]
        H --> I[Level N SST Files
Compressed]
    end

    subgraph "Compaction Process"
        J[Background
Compaction Threads] --> K[Merge SST Files]
        K --> L[Delete Tombstones]
    end

    D --> J

    style A fill:#e1f5fe
    style E fill:#f3e5f5
    style G fill:#fff3e0

Полная реализация P/Invoke обёртки для PowerShell

1. Подготовка среды

# Скачиваем собранную RocksDB для Windows (x64)
$rocksdbUrl = "https://github.com/facebook/rocksdb/releases/download/v8.3.2/rocksdb-8.3.2-win64.zip"
$tempDir = Join-Path $env:TEMP "rocksdb_setup"
New-Item -ItemType Directory -Path $tempDir -Force

# Скачиваем и распаковываем
Invoke-WebRequest -Uri $rocksdbUrl -OutFile "$tempDir\rocksdb.zip"
Expand-Archive -Path "$tempDir\rocksdb.zip" -DestinationPath $tempDir -Force

# Копируем библиотеки
$libPath = "C:\Windows\System32\rocksdb.dll"
Copy-Item "$tempDir\rocksdb.dll" $libPath -Force

# Проверяем наличие
if (Test-Path $libPath) {
    Write-Host "RocksDB установлена: $libPath" -ForegroundColor Green
} else {
    Write-Error "Не удалось установить RocksDB"
}

2. Полная P/Invoke обёртка

using namespace System.Runtime.InteropServices

# Определяем все структуры и функции RocksDB C API
$rocksdbCode = @"
using System;
using System.Runtime.InteropServices;
using System.Text;

public unsafe class RocksDbNative : IDisposable {
    // Основные дескрипторы
    public struct rocksdb_t { public IntPtr ptr; }
    public struct rocksdb_options_t { public IntPtr ptr; }
    public struct rocksdb_writeoptions_t { public IntPtr ptr; }
    public struct rocksdb_readoptions_t { public IntPtr ptr; }
    public struct rocksdb_iterator_t { public IntPtr ptr; }
    public struct rocksdb_writebatch_t { public IntPtr ptr; }

    // Константы
    public const int ROCKSDB_NO_BACKGROUND_THREADS = 1 << 0;
    public const int ROCKSDB_DISABLE_WAL = 1 << 1;

    // ========== ОПЦИИ БАЗЫ ДАННЫХ ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_options_t* rocksdb_options_create();

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_destroy(rocksdb_options_t* options);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_create_if_missing(
        rocksdb_options_t* options, byte create_if_missing);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_increase_parallelism(
        rocksdb_options_t* options, int total_threads);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_optimize_level_style_compaction(
        rocksdb_options_t* options, ulong memtable_memory_budget);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_max_open_files(
        rocksdb_options_t* options, int max_open_files);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_use_direct_reads(
        rocksdb_options_t* options, byte value);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_use_direct_io_for_flush_and_compaction(
        rocksdb_options_t* options, byte value);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_target_file_size_base(
        rocksdb_options_t* options, ulong size);

    // ========== ОТКРЫТИЕ/ЗАКРЫТИЕ БД ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_t* rocksdb_open(
        rocksdb_options_t* options, 
        [MarshalAs(UnmanagedType.LPStr)] string name, 
        out IntPtr errptr);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_close(rocksdb_t* db);

    // ========== WRITE OPTIONS ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_writeoptions_t* rocksdb_writeoptions_create();

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* writeOptions);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_writeoptions_disable_WAL(
        rocksdb_writeoptions_t* writeOptions, int disable);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_writeoptions_set_sync(
        rocksdb_writeoptions_t* writeOptions, byte sync);

    // ========== READ OPTIONS ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_readoptions_t* rocksdb_readoptions_create();

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_readoptions_destroy(rocksdb_readoptions_t* readOptions);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_readoptions_set_verify_checksums(
        rocksdb_readoptions_t* readOptions, byte verify);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_readoptions_set_fill_cache(
        rocksdb_readoptions_t* readOptions, byte fill_cache);

    // ========== ОСНОВНЫЕ ОПЕРАЦИИ ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_put(
        rocksdb_t* db,
        rocksdb_writeoptions_t* writeOptions,
        byte[] key, long keylen,
        byte[] val, long vallen,
        out IntPtr errptr);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_delete(
        rocksdb_t* db,
        rocksdb_writeoptions_t* writeOptions,
        byte[] key, long keylen,
        out IntPtr errptr);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr rocksdb_get(
        rocksdb_t* db,
        rocksdb_readoptions_t* readOptions,
        byte[] key, long keylen,
        out long vallen,
        out IntPtr errptr);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_free(IntPtr ptr);

    // ========== ПАКЕТНЫЕ ОПЕРАЦИИ ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_writebatch_t* rocksdb_writebatch_create();

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_writebatch_destroy(rocksdb_writebatch_t* batch);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_writebatch_put(
        rocksdb_writebatch_t* batch,
        byte[] key, long klen,
        byte[] val, long vlen);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_writebatch_delete(
        rocksdb_writebatch_t* batch,
        byte[] key, long klen);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_write(
        rocksdb_t* db,
        rocksdb_writeoptions_t* writeOptions,
        rocksdb_writebatch_t* batch,
        out IntPtr errptr);

    // ========== ИТЕРАТОРЫ ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_iterator_t* rocksdb_create_iterator(
        rocksdb_t* db,
        rocksdb_readoptions_t* readOptions);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_iter_destroy(rocksdb_iterator_t* iter);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_iter_seek_to_first(rocksdb_iterator_t* iter);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_iter_seek_to_last(rocksdb_iterator_t* iter);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_iter_seek(rocksdb_iterator_t* iter, byte[] key, long klen);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_iter_next(rocksdb_iterator_t* iter);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_iter_prev(rocksdb_iterator_t* iter);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern byte rocksdb_iter_valid(rocksdb_iterator_t* iter);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr rocksdb_iter_key(rocksdb_iterator_t* iter, out long klen);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr rocksdb_iter_value(rocksdb_iterator_t* iter, out long vlen);

    // ========== СЛУЖЕБНЫЕ ФУНКЦИИ ==========
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_compact_range(
        rocksdb_t* db, 
        byte[] start_key, long start_key_len,
        byte[] end_key, long end_key_len);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_destroy_db(
        rocksdb_options_t* options,
        [MarshalAs(UnmanagedType.LPStr)] string name,
        out IntPtr errptr);

    // Утилиты для работы со строками
    public static string PtrToStringUtf8(IntPtr ptr, long length) {
        if (ptr == IntPtr.Zero) return null;
        byte[] buffer = new byte[length];
        Marshal.Copy(ptr, buffer, 0, (int)length);
        return Encoding.UTF8.GetString(buffer);
    }

    public static IntPtr StringToHGlobalUtf8(string str) {
        if (str == null) return IntPtr.Zero;
        byte[] bytes = Encoding.UTF8.GetBytes(str);
        IntPtr ptr = Marshal.AllocHGlobal(bytes.Length + 1);
        Marshal.Copy(bytes, 0, ptr, bytes.Length);
        Marshal.WriteByte(ptr + bytes.Length, 0);
        return ptr;
    }
}
"@

Add-Type -TypeDefinition $rocksdbCode -Language CSharp

3. Управляемая обёртка для удобной работы

class RocksDb : IDisposable {
    # Указатели на нативные объекты
    hidden [IntPtr]$DbPtr
    hidden [IntPtr]$OptionsPtr
    hidden [IntPtr]$WriteOptionsPtr
    hidden [IntPtr]$ReadOptionsPtr
    hidden [string]$DbPath

    # Статус
    hidden [bool]$IsDisposed = $false
    hidden [bool]$IsOpen = $false

    # Конструктор
    RocksDb([string]$path) {
        $this.DbPath = $path
        $this.InitializeOptions()
    }

    # Инициализация опций
    hidden [void]InitializeOptions() {
        # Создаём опции
        $this.OptionsPtr = [RocksDbNative]::rocksdb_options_create()

        # Оптимизация для SSD
        [RocksDbNative]::rocksdb_options_set_create_if_missing($this.OptionsPtr, 1)
        [RocksDbNative]::rocksdb_options_increase_parallelism($this.OptionsPtr, [Environment]::ProcessorCount)
        [RocksDbNative]::rocksdb_options_optimize_level_style_compaction($this.OptionsPtr, 64 * 1024 * 1024) # 64MB
        [RocksDbNative]::rocksdb_options_set_max_open_files($this.OptionsPtr, -1) # Неограниченно
        [RocksDbNative]::rocksdb_options_set_use_direct_reads($this.OptionsPtr, 1)
        [RocksDbNative]::rocksdb_options_set_use_direct_io_for_flush_and_compaction($this.OptionsPtr, 1)
        [RocksDbNative]::rocksdb_options_set_target_file_size_base($this.OptionsPtr, 64 * 1024 * 1024) # 64MB

        # Опции записи
        $this.WriteOptionsPtr = [RocksDbNative]::rocksdb_writeoptions_create()
        [RocksDbNative]::rocksdb_writeoptions_set_sync($this.WriteOptionsPtr, 0) # Асинхронная запись

        # Опции чтения
        $this.ReadOptionsPtr = [RocksDbNative]::rocksdb_readoptions_create()
        [RocksDbNative]::rocksdb_readoptions_set_verify_checksums($this.ReadOptionsPtr, 0) # Для скорости
        [RocksDbNative]::rocksdb_readoptions_set_fill_cache($this.ReadOptionsPtr, 1)
    }

    # Открытие базы данных
    [void]Open() {
        if ($this.IsOpen) { return }

        $errptr = [IntPtr]::Zero
        $this.DbPtr = [RocksDbNative]::rocksdb_open($this.OptionsPtr, $this.DbPath, [ref]$errptr)

        if ($errptr -ne [IntPtr]::Zero) {
            $errorMsg = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($errptr)
            [RocksDbNative]::rocksdb_free($errptr)
            throw "Ошибка открытия RocksDB: $errorMsg"
        }

        $this.IsOpen = $true
        Write-Host "RocksDB открыта: $($this.DbPath)" -ForegroundColor Green
    }

    # Запись ключ-значение
    [void]Put([string]$key, [string]$value) {
        $this.EnsureOpen()

        $keyBytes = [System.Text.Encoding]::UTF8.GetBytes($key)
        $valueBytes = [System.Text.Encoding]::UTF8.GetBytes($value)

        $errptr = [IntPtr]::Zero
        [RocksDbNative]::rocksdb_put(
            $this.DbPtr,
            $this.WriteOptionsPtr,
            $keyBytes, $keyBytes.Length,
            $valueBytes, $valueBytes.Length,
            [ref]$errptr
        )

        $this.CheckError($errptr, "Put")
    }

    # Чтение по ключу
    [string]Get([string]$key) {
        $this.EnsureOpen()

        $keyBytes = [System.Text.Encoding]::UTF8.GetBytes($key)
        $vallen = 0L
        $errptr = [IntPtr]::Zero

        $valuePtr = [RocksDbNative]::rocksdb_get(
            $this.DbPtr,
            $this.ReadOptionsPtr,
            $keyBytes, $keyBytes.Length,
            [ref]$vallen,
            [ref]$errptr
        )

        if ($errptr -ne [IntPtr]::Zero) {
            $errorMsg = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($errptr)
            [RocksDbNative]::rocksdb_free($errptr)
            throw "Ошибка Get: $errorMsg"
        }

        if ($valuePtr -eq [IntPtr]::Zero) {
            return $null
        }

        $value = [System.Runtime.InteropServices.Marshal]::PtrToStringUTF8($valuePtr, $vallen)
        [RocksDbNative]::rocksdb_free($valuePtr)

        return $value
    }

    # Удаление ключа
    [void]Delete([string]$key) {
        $this.EnsureOpen()

        $keyBytes = [System.Text.Encoding]::UTF8.GetBytes($key)
        $errptr = [IntPtr]::Zero

        [RocksDbNative]::rocksdb_delete(
            $this.DbPtr,
            $this.WriteOptionsPtr,
            $keyBytes, $keyBytes.Length,
            [ref]$errptr
        )

        $this.CheckError($errptr, "Delete")
    }

    # Пакетная запись
    [void]BatchWrite([hashtable]$keyValues) {
        $this.EnsureOpen()

        $batch = [RocksDbNative]::rocksdb_writebatch_create()

        try {
            foreach ($kv in $keyValues.GetEnumerator()) {
                $keyBytes = [System.Text.Encoding]::UTF8.GetBytes($kv.Key)
                $valueBytes = [System.Text.Encoding]::UTF8.GetBytes($kv.Value)

                [RocksDbNative]::rocksdb_writebatch_put(
                    $batch,
                    $keyBytes, $keyBytes.Length,
                    $valueBytes, $valueBytes.Length
                )
            }

            $errptr = [IntPtr]::Zero
            [RocksDbNative]::rocksdb_write(
                $this.DbPtr,
                $this.WriteOptionsPtr,
                $batch,
                [ref]$errptr
            )

            $this.CheckError($errptr, "BatchWrite")
        }
        finally {
            [RocksDbNative]::rocksdb_writebatch_destroy($batch)
        }
    }

    # Итерация по всем ключам
    [System.Collections.Generic.List[hashtable]]GetAll() {
        $this.EnsureOpen()

        $results = [System.Collections.Generic.List[hashtable]]::new()
        $iter = [RocksDbNative]::rocksdb_create_iterator($this.DbPtr, $this.ReadOptionsPtr)

        try {
            [RocksDbNative]::rocksdb_iter_seek_to_first($iter)

            while ([RocksDbNative]::rocksdb_iter_valid($iter) -ne 0) {
                $keyLen = 0L
                $valueLen = 0L

                $keyPtr = [RocksDbNative]::rocksdb_iter_key($iter, [ref]$keyLen)
                $valuePtr = [RocksDbNative]::rocksdb_iter_value($iter, [ref]$valueLen)

                $key = [System.Runtime.InteropServices.Marshal]::PtrToStringUTF8($keyPtr, $keyLen)
                $value = [System.Runtime.InteropServices.Marshal]::PtrToStringUTF8($valuePtr, $valueLen)

                $results.Add(@{ Key = $key; Value = $value })
                [RocksDbNative]::rocksdb_iter_next($iter)
            }
        }
        finally {
            [RocksDbNative]::rocksdb_iter_destroy($iter)
        }

        return $results
    }

    # Поиск по префиксу
    [System.Collections.Generic.List[hashtable]]GetByPrefix([string]$prefix) {
        $this.EnsureOpen()

        $results = [System.Collections.Generic.List[hashtable]]::new()
        $iter = [RocksDbNative]::rocksdb_create_iterator($this.DbPtr, $this.ReadOptionsPtr)
        $prefixBytes = [System.Text.Encoding]::UTF8.GetBytes($prefix)

        try {
            [RocksDbNative]::rocksdb_iter_seek($iter, $prefixBytes, $prefixBytes.Length)

            while ([RocksDbNative]::rocksdb_iter_valid($iter) -ne 0) {
                $keyLen = 0L
                $keyPtr = [RocksDbNative]::rocksdb_iter_key($iter, [ref]$keyLen)
                $key = [System.Runtime.InteropServices.Marshal]::PtrToStringUTF8($keyPtr, $keyLen)

                # Проверяем префикс
                if (-not $key.StartsWith($prefix)) {
                    break
                }

                $valueLen = 0L
                $valuePtr = [RocksDbNative]::rocksdb_iter_value($iter, [ref]$valueLen)
                $value = [System.Runtime.InteropServices.Marshal]::PtrToStringUTF8($valuePtr, $valueLen)

                $results.Add(@{ Key = $key; Value = $value })
                [RocksDbNative]::rocksdb_iter_next($iter)
            }
        }
        finally {
            [RocksDbNative]::rocksdb_iter_destroy($iter)
        }

        return $results
    }

    # Компактизация (оптимизация производительности)
    [void]Compact() {
        $this.EnsureOpen()

        [RocksDbNative]::rocksdb_compact_range(
            $this.DbPtr,
            $null, 0,
            $null, 0
        )

        Write-Host "Компактизация завершена" -ForegroundColor Yellow
    }

    # Получение статистики
    [hashtable]GetStats() {
        $this.EnsureOpen()

        # В реальности нужно вызывать rocksdb_property_value для получения статистики
        $dbPath = $this.DbPath
        $files = Get-ChildItem -Path "$dbPath\*" -File -ErrorAction SilentlyContinue

        return @{
            Path = $dbPath
            FileCount = $files.Count
            TotalSize = ($files | Measure-Object Length -Sum).Sum
            IsOpen = $this.IsOpen
        }
    }

    # Закрытие базы
    [void]Close() {
        if (-not $this.IsOpen) { return }

        [RocksDbNative]::rocksdb_close($this.DbPtr)
        $this.DbPtr = [IntPtr]::Zero
        $this.IsOpen = $false

        Write-Host "RocksDB закрыта" -ForegroundColor Yellow
    }

    # Уничтожение базы данных
    static [void]Destroy([string]$path) {
        $options = [RocksDbNative]::rocksdb_options_create()
        $errptr = [IntPtr]::Zero

        [RocksDbNative]::rocksdb_destroy_db($options, $path, [ref]$errptr)
        [RocksDbNative]::rocksdb_options_destroy($options)

        if ($errptr -ne [IntPtr]::Zero) {
            $errorMsg = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($errptr)
            [RocksDbNative]::rocksdb_free($errptr)
            throw "Ошибка удаления базы: $errorMsg"
        }
    }

    # Проверка ошибок
    hidden [void]CheckError([IntPtr]$errptr, [string]$operation) {
        if ($errptr -ne [IntPtr]::Zero) {
            $errorMsg = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($errptr)
            [RocksDbNative]::rocksdb_free($errptr)
            throw "Ошибка $operation : $errorMsg"
        }
    }

    hidden [void]EnsureOpen() {
        if (-not $this.IsOpen) {
            throw "База данных не открыта. Вызовите Open() перед операциями."
        }
    }

    # Dispose паттерн
    [void]Dispose() {
        if ($this.IsDisposed) { return }

        try {
            $this.Close()

            if ($this.WriteOptionsPtr -ne [IntPtr]::Zero) {
                [RocksDbNative]::rocksdb_writeoptions_destroy($this.WriteOptionsPtr)
            }

            if ($this.ReadOptionsPtr -ne [IntPtr]::Zero) {
                [RocksDbNative]::rocksdb_readoptions_destroy($this.ReadOptionsPtr)
            }

            if ($this.OptionsPtr -ne [IntPtr]::Zero) {
                [RocksDbNative]::rocksdb_options_destroy($this.OptionsPtr)
            }
        }
        finally {
            $this.IsDisposed = $true
            [GC]::SuppressFinalize($this)
        }
    }

    # Деструктор
    RocksDb() {
        $this.Dispose()
    }
}

4. Пример использования с PowerShell

# Использование RocksDB
try {
    $dbPath = "C:\Data\RocksDBTest"

    # Создаём и открываем базу
    $db = [RocksDb]::new($dbPath)
    $db.Open()

    # Бенчмарк: запись 100k ключей
    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()

    1..100000 | ForEach-Object {
        $key = "user:$_"
        $value = @{
            Name = "User $_"
            Email = "user$_@example.com"
            Created = [DateTime]::Now.ToString("o")
        } | ConvertTo-Json -Compress

        $db.Put($key, $value)

        if ($_ % 10000 -eq 0) {
            Write-Progress -Activity "Запись данных" -Status "$_ / 100000" -PercentComplete ($_ / 1000)
        }
    }

    $stopwatch.Stop()
    Write-Host "Запись 100k записей заняла: $($stopwatch.Elapsed.TotalSeconds) сек" -ForegroundColor Cyan

    # Чтение
    $value = $db.Get("user:50000")
    Write-Host "Значение user:50000 = $value" -ForegroundColor Green

    # Поиск по префиксу
    $users = $db.GetByPrefix("user:")
    Write-Host "Найдено пользователей: $($users.Count)" -ForegroundColor Yellow

    # Пакетное обновление
    $batchData = @{
        "config:site_name" = "MySite"
        "config:version" = "1.0.0"
        "config:debug" = "false"
    }
    $db.BatchWrite($batchData)

    # Компактизация для оптимизации
    $db.Compact()

    # Статистика
    $stats = $db.GetStats()
    $stats | Format-List

    # Пример с итератором
    $allData = $db.GetAll()
    Write-Host "Всего записей: $($allData.Count)"

    # Пример сложного ключа с префиксом
    $db.Put("log:2024:01:15:error", "Ошибка соединения")
    $db.Put("log:2024:01:15:info", "Сервис запущен")
    $db.Put("log:2024:01:16:warning", "Высокая загрузка")

    $logs = $db.GetByPrefix("log:2024:01:15")
    Write-Host "Логов за 15.01.2024: $($logs.Count)"

}
finally {
    if ($db -ne $null) {
        $db.Dispose()
    }
}

# Уничтожение базы (полное удаление)
# [RocksDb]::Destroy("C:\Data\RocksDBTest")

5. Продвинутые функции: колонки, сжатие, транзакции

# Расширенная версия с Column Families
$advancedRocksDbCode = @"
using System;
using System.Runtime.InteropServices;

public unsafe class RocksDbAdvanced {
    // Column Families
    public struct rocksdb_column_family_handle_t { public IntPtr ptr; }

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_column_family_handle_t** rocksdb_list_column_families(
        rocksdb_options_t* options,
        [MarshalAs(UnmanagedType.LPStr)] string name,
        out int num_column_families,
        out IntPtr errptr);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_list_column_families_destroy(
        byte** list,
        int num_column_families);

    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern rocksdb_t* rocksdb_open_column_families(
        rocksdb_options_t* options,
        [MarshalAs(UnmanagedType.LPStr)] string name,
        int num_column_families,
        [MarshalAs(UnmanagedType.LPArray)] byte** column_family_names,
        rocksdb_options_t** column_family_options,
        rocksdb_column_family_handle_t*** column_family_handles,
        out IntPtr errptr);

    // Сжатие
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_compression(
        rocksdb_options_t* options,
        int compression_type);  // rocksdb_no_compression = 0, rocksdb_snappy_compression = 1

    // Bloom Filter
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rocksdb_options_set_bloom_locality(int bloom_locality);

    // Статистика
    [DllImport("rocksdb", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr rocksdb_property_value(
        rocksdb_t* db,
        [MarshalAs(UnmanagedType.LPStr)] string propname);
}
"@

Add-Type -TypeDefinition $advancedRocksDbCode -Language CSharp

6. Бенчмарк сравнения

function Measure-RocksDbPerformance {
    param(
        [int]$TotalRecords = 100000,
        [int]$BatchSize = 1000
    )

    $dbPath = "C:\Data\RocksDBBenchmark"

    # Очистка
    if (Test-Path $dbPath) {
        Remove-Item -Path $dbPath -Recurse -Force
    }

    $db = [RocksDb]::new($dbPath)
    $db.Open()

    # Тест 1: Последовательная запись
    $sw = [System.Diagnostics.Stopwatch]::StartNew()

    for ($i = 1; $i -le $TotalRecords; $i++) {
        $db.Put("key_$i", "value_" * 100)  # 700 байт значения
    }

    $sw.Stop()
    $sequentialWrite = $sw.Elapsed.TotalSeconds
    Write-Host "Последовательная запись: $TotalRecords записей за ${sequentialWrite}с ($($TotalRecords/$sequentialWrite) зап/с)" -ForegroundColor Green

    # Тест 2: Случайное чтение
    $sw.Restart()
    $rnd = [Random]::new()

    for ($i = 1; $i -le 10000; $i++) {
        $randomKey = "key_" + $rnd.Next(1, $TotalRecords)
        $null = $db.Get($randomKey)
    }

    $sw.Stop()
    $randomRead = $sw.Elapsed.TotalSeconds
    Write-Host "Случайное чтение: 10000 операций за ${randomRead}с ($(10000/$randomRead) опер/с)" -ForegroundColor Green

    # Тест 3: Пакетная запись
    $sw.Restart()

    $batchCount = [Math]::Ceiling($TotalRecords / $BatchSize)
    for ($batch = 0; $batch -lt $batchCount; $batch++) {
        $batchData = @{}
        $start = $batch * $BatchSize + 1
        $end = [Math]::Min(($batch + 1) * $BatchSize, $TotalRecords)

        for ($i = $start; $i -le $end; $i++) {
            $batchData["batch_key_$i"] = "batch_value_$i"
        }

        $db.BatchWrite($batchData)
    }

    $sw.Stop()
    $batchWrite = $sw.Elapsed.TotalSeconds
    Write-Host "Пакетная запись ($BatchSize/пакет): $TotalRecords записей за ${batchWrite}с ($($TotalRecords/$batchWrite) зап/с)" -ForegroundColor Green

    $db.Dispose()

    return @{
        SequentialWrite = [Math]::Round($TotalRecords / $sequentialWrite, 0)
        RandomRead = [Math]::Round(10000 / $randomRead, 0)
        BatchWrite = [Math]::Round($TotalRecords / $batchWrite, 0)
    }
}

# Запуск бенчмарка
$results = Measure-RocksDbPerformance -TotalRecords 50000
$results | Format-Table

Процесс работы RocksDB

sequenceDiagram
    participant P as PowerShell
    participant M as P/Invoke Marshal
    participant R as rocksdb.dll
    participant L as LSM Tree
    participant D as Disk

    P->>M: rocksdb_put(key, value)
    M->>R: Вызов нативной функции
    R->>L: Добавить в MemTable
    L->>D: Асинхронная запись в WAL
    L->>L: Проверить размер MemTable

    alt MemTable > threshold
        L->>D: Записать SST файл (Level 0)
        L->>L: Очистить MemTable
    end

    loop Background Compaction
        L->>L: Найти переполненный уровень
        L->>D: Прочитать несколько SST файлов
        L->>L: Объединить и отсортировать
        L->>D: Записать новые SST файлы
        L->>D: Удалить старые файлы
    end

    P->>M: rocksdb_get(key)
    M->>R: Вызов нативной функции
    R->>L: Поиск в MemTable
    alt Найдено в MemTable
        L-->>R: Возврат значения
    else Не найдено
        R->>D: Поиск по уровням SST
        D-->>R: Возврат значения
    end
    R-->>M: Результат
    M-->>P: Значение

Плюсы RocksDB через P/Invoke

Преимущества:

1. Экстремальная производительность:

• 1,000,000+ операций в секунду
• Оптимизация под SSD
• Минимальные задержки

1. Эффективное использование ресурсов:

• Асинхронная запись
• Автоматическая компактизация
• Поддержка сжатия (Snappy, Zlib, ZSTD)

1. Продвинутые функции:

• Column Families (подобно таблицам)
• Bloom Filters для быстрого поиска
• Поддержка транзакций
• Point-in-time snapshot

1. Надёжность:

• Write-Ahead Logging
• Контрольные суммы CRC32
• Восстановление после сбоев

1. Гибкость:

• Настраиваемые параметры компрессии
• Контроль размера уровней
• Кастомные компараторы

Минусы и ограничения

Недостатки:

1. Сложность P/Invoke:

• Ручное управление памятью
• Ошибки могут привести к утечкам
• Сложная отладка

1. Отсутствие типизации:

• Все данные как byte[]
• Ручная сериализация JSON/Protobuf
• Нет встроенной поддержки типов

1. Только key-value:

• Нет SQL запросов
• Нет JOIN операций
• Ограниченные возможности индексации

1. Требует компиляции:

• Нужна собранная rocksdb.dll
• Зависит от MSVC runtime
• Проблемы с версионностью

1. Потребление памяти:

• MemTable может занимать много RAM
• Block cache требует настройки
• Фоновые потоки компрессии

Сравнение производительности (100k операций)

Оптимальные настройки для PowerShell

class OptimizedRocksDb : RocksDb {
    OptimizedRocksDb([string]$path) : base($path) {
        # Оптимизация для сценариев PowerShell
        $this.SetPowerShellOptimizations()
    }

    hidden [void]SetPowerShellOptimizations() {
        # Уменьшаем использование памяти для скриптов
        [RocksDbNative]::rocksdb_options_set_write_buffer_size($this.OptionsPtr, 64 * 1024 * 1024) # 64MB вместо 256MB

        # Увеличиваем частоту компактизации
        [RocksDbNative]::rocksdb_options_set_level0_file_num_compaction_trigger($this.OptionsPtr, 4)

        # Оптимизация для частых мелких записов
        [RocksDbNative]::rocksdb_options_set_min_write_buffer_number_to_merge($this.OptionsPtr, 2)

        # Отключаем ведение статистики для экономии CPU
        [RocksDbNative]::rocksdb_options_set_stats_dump_period_sec($this.OptionsPtr, 0)

        # Используем более быстрый компаратор
        [RocksDbNative]::rocksdb_options_set_comparator($this.OptionsPtr, 1) # Bytewise comparator
    }

    # Оптимизированный Put для небольших значений
    [void]PutFast([string]$key, [string]$value) {
        $keyBytes = [System.Text.Encoding]::UTF8.GetBytes($key)
        $valueBytes = [System.Text.Encoding]::UTF8.GetBytes($value)

        # Используем фиксированные буферы для избежания аллокаций
        $bufferSize = $keyBytes.Length + $valueBytes.Length + 16

        # Fast path для маленьких записей
        if ($bufferSize -lt 1024) {
            $errptr = [IntPtr]::Zero
            [RocksDbNative]::rocksdb_put(
                $this.DbPtr,
                $this.WriteOptionsPtr,
                $keyBytes, $keyBytes.Length,
                $valueBytes, $valueBytes.Length,
                [ref]$errptr
            )
            $this.CheckError($errptr, "PutFast")
        } else {
            # Стандартный путь для больших данных
            $this.Put($key, $value)
        }
    }
}

Распространённые ошибки и решения

# Обработка ошибок RocksDB
try {
    $db = [RocksDb]::new("C:\Data\TestDB")
    $db.Open()

    # Типичные ошибки
    # 1. Нехватка места на диске
    # 2. Повреждение файлов БД
    # 3. Достигнут лимит дескрипторов файлов
    # 4. Конфликты версий rocksdb.dll

}
catch [System.DllNotFoundException] {
    Write-Error "RocksDB DLL не найдена. Установите rocksdb.dll в System32"
}
catch [System.AccessViolationException] {
    Write-Error "Нарушение доступа к памяти. Проверьте совместимость версий DLL"
}
catch {
    if ($_.Exception.Message -like "*No such file or directory*") {
        Write-Error "Путь к базе данных не найден"
    }
    elseif ($_.Exception.Message -like "*Corruption*") {
        Write-Warning "Обнаружено повреждение базы данных. Попробуйте восстановить из бэкапа"
        # Восстановление
        [RocksDb]::Destroy("C:\Data\TestDB")
    }
    else {
        Write-Error "Ошибка RocksDB: $($_.Exception.Message)"
    }
}
finally {
    if ($db -ne $null) {
        $db.Dispose()
    }
}

Рекомендации по использованию

Когда использовать RocksDB:

✅ Используйте RocksDB если:

• Нужна максимальная производительность вставки/чтения
• Работаете с временными рядами или логами
• Требуется горизонтальное масштабирование
• Храните данные в key-value формате
• Используете SSD накопители

❌ Не используйте RocksDB если:

• Нужны сложные SQL запросы
• Требуется простота использования
• Маленький проект с небольшим объемом данных
• Не готовы к ручному управлению памятью

Лучшие практики:

1. Используйте пакетные операции при массовой вставке
2. Настройте размер MemTable под ваш объем RAM
3. Включите сжатие для экономии места
4. Регулярно делайте компактизацию для производительности
5. Используйте префиксы ключей для организации данных

Альтернативные .NET обёртки:

# Вместо P/Invoke можно использовать готовые библиотеки:
# 1. RocksDbSharp (https://github.com/warrenfalk/rocksdb-sharp)
# 2. LevelDB.NET (аналогичный API)
# 3. LiteDB (managed альтернатива)

# Пример с RocksDbSharp:
Install-Package RocksDbSharp
$db = [RocksDbSharp.RocksDb]::Open($options, "path/to/db")

Заключение

RocksDB через P/Invoke предоставляет максимальную производительность для key-value операций в PowerShell, но требует глубокого понимания:

1. Управление неуправляемой памятью
2. Настройки LSM-дерева
3. Паттерны доступа к данным

Для большинства задач PowerShell достаточно SQLite, но если вам нужны:

• Более 100,000 операций в секунду
• Многопоточный доступ
• Эффективное сжатие данных
• Промышленная надежность

Тогда RocksDB через P/Invoke — отличный выбор, хотя и требует больше усилий для настройки и сопровождения.