Added default comparer options for optimized usage

Author: CoreyKaylor

src/LightningDB.Tests/ComparerTests.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances using lexicographic byte comparison (memcmp-style).
+/// </summary>
+public sealed class BitwiseComparer : IComparer<MDBValue>
+{
+    public static readonly BitwiseComparer Instance = new();
+
+    private BitwiseComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+        => x.AsSpan().SequenceCompareTo(y.AsSpan());
+}

src/LightningDB/Comparers/BitwiseComparer.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+#if !NET6_0_OR_GREATER
+using System.Runtime.InteropServices;
+#endif
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances by hash code for faster comparison of large values.
+/// Falls back to byte comparison when hashes collide.
+/// Sort order is deterministic within a process but may vary across restarts.
+/// </summary>
+public sealed class HashCodeComparer : IComparer<MDBValue>
+{
+    public static readonly HashCodeComparer Instance = new();
+
+    private HashCodeComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+    {
+        var left = x.AsSpan();
+        var right = y.AsSpan();
+
+        var leftHash = ComputeHash(left);
+        var rightHash = ComputeHash(right);
+
+        var hashCmp = leftHash.CompareTo(rightHash);
+        return hashCmp != 0 ? hashCmp : left.SequenceCompareTo(right);
+    }
+
+#if NET6_0_OR_GREATER
+    private static int ComputeHash(ReadOnlySpan<byte> data)
+    {
+        var hc = new HashCode();
+        hc.AddBytes(data);
+        return hc.ToHashCode();
+    }
+#else
+    private static ulong ComputeHash(ReadOnlySpan<byte> data)
+    {
+        const ulong prime = 0x9E3779B97F4A7C15UL;
+        var hash = (ulong)data.Length;
+
+        while (data.Length >= 8)
+        {
+            hash ^= MemoryMarshal.Read<ulong>(data);
+            hash *= prime;
+            hash ^= hash >> 32;
+            data = data.Slice(8);
+        }
+
+        if (data.Length >= 4)
+        {
+            hash ^= MemoryMarshal.Read<uint>(data);
+            hash *= prime;
+            data = data.Slice(4);
+        }
+
+        foreach (var b in data)
+        {
+            hash ^= b;
+            hash *= prime;
+        }
+
+        return hash;
+    }
+#endif
+}

src/LightningDB/Comparers/HashCodeComparer.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances by length first, then by content.
+/// Shorter values sort before longer values.
+/// </summary>
+public sealed class LengthComparer : IComparer<MDBValue>
+{
+    public static readonly LengthComparer Instance = new();
+
+    private LengthComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+    {
+        var left = x.AsSpan();
+        var right = y.AsSpan();
+        var lengthCmp = left.Length.CompareTo(right.Length);
+        return lengthCmp != 0 ? lengthCmp : left.SequenceCompareTo(right);
+    }
+}

src/LightningDB/Comparers/LengthComparer.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances by length only, ignoring content.
+/// Values of equal length are considered equal regardless of content.
+/// </summary>
+public sealed class LengthOnlyComparer : IComparer<MDBValue>
+{
+    public static readonly LengthOnlyComparer Instance = new();
+
+    private LengthOnlyComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+        => x.AsSpan().Length.CompareTo(y.AsSpan().Length);
+}

src/LightningDB/Comparers/LengthOnlyComparer.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances using lexicographic byte comparison in descending order.
+/// </summary>
+public sealed class ReverseBitwiseComparer : IComparer<MDBValue>
+{
+    public static readonly ReverseBitwiseComparer Instance = new();
+
+    private ReverseBitwiseComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+        => y.AsSpan().SequenceCompareTo(x.AsSpan());
+}

src/LightningDB/Comparers/ReverseBitwiseComparer.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances by length first (descending), then by content (descending).
+/// Longer values sort before shorter values.
+/// </summary>
+public sealed class ReverseLengthComparer : IComparer<MDBValue>
+{
+    public static readonly ReverseLengthComparer Instance = new();
+
+    private ReverseLengthComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+    {
+        var left = x.AsSpan();
+        var right = y.AsSpan();
+        var lengthCmp = right.Length.CompareTo(left.Length);
+        return lengthCmp != 0 ? lengthCmp : right.SequenceCompareTo(left);
+    }
+}

src/LightningDB/Comparers/ReverseLengthComparer.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances as signed integers (int or long) in descending order.
+/// Supports 4-byte and 8-byte values. Falls back to reverse bitwise comparison for other sizes.
+/// </summary>
+public sealed class ReverseSignedIntegerComparer : IComparer<MDBValue>
+{
+    public static readonly ReverseSignedIntegerComparer Instance = new();
+
+    private ReverseSignedIntegerComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+    {
+        var left = x.AsSpan();
+        var right = y.AsSpan();
+
+        if (left.Length == 4 && right.Length == 4)
+            return MemoryMarshal.Read<int>(right).CompareTo(MemoryMarshal.Read<int>(left));
+
+        if (left.Length == 8 && right.Length == 8)
+            return MemoryMarshal.Read<long>(right).CompareTo(MemoryMarshal.Read<long>(left));
+
+        return right.SequenceCompareTo(left);
+    }
+}

src/LightningDB/Comparers/ReverseSignedIntegerComparer.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances as unsigned integers (uint or ulong) in descending order.
+/// Supports 4-byte and 8-byte values. Falls back to reverse bitwise comparison for other sizes.
+/// </summary>
+public sealed class ReverseUnsignedIntegerComparer : IComparer<MDBValue>
+{
+    public static readonly ReverseUnsignedIntegerComparer Instance = new();
+
+    private ReverseUnsignedIntegerComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+    {
+        var left = x.AsSpan();
+        var right = y.AsSpan();
+
+        if (left.Length == 4 && right.Length == 4)
+            return MemoryMarshal.Read<uint>(right).CompareTo(MemoryMarshal.Read<uint>(left));
+
+        if (left.Length == 8 && right.Length == 8)
+            return MemoryMarshal.Read<ulong>(right).CompareTo(MemoryMarshal.Read<ulong>(left));
+
+        return right.SequenceCompareTo(left);
+    }
+}

src/LightningDB/Comparers/ReverseUnsignedIntegerComparer.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightningDB.Comparers;
+
+/// <summary>
+/// Compares MDBValue instances as UTF-8 encoded strings in descending order.
+/// </summary>
+public sealed class ReverseUtf8StringComparer : IComparer<MDBValue>
+{
+    public static readonly ReverseUtf8StringComparer Instance = new();
+
+    private ReverseUtf8StringComparer() { }
+
+    public int Compare(MDBValue x, MDBValue y)
+        => y.AsSpan().SequenceCompareTo(x.AsSpan());
+}