Merge pull request #266 from alfeg/develop

Allocation free GuidConverter for NET

Author: Giorgi

DuckDB.NET.Data/Extensions/GuidConverter.cs

@@ -1,10 +1,13 @@
 using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
 using DuckDB.NET.Native;
 
 namespace DuckDB.NET.Data.Extensions;
 
 internal static class GuidConverter
 {
+#if !NET6_0_OR_GREATER
     private const string GuidFormat = "D";
     private static readonly char[] HexDigits = "0123456789abcdef".ToCharArray();
 
@@ -45,52 +48,112 @@ public static Guid ConvertToGuid(this DuckDBHugeInt input)
         ByteToHex(buffer, ref position, (input.Lower >> 8) & 0xFF);
         ByteToHex(buffer, ref position, input.Lower & 0xFF);
 
-#if NET6_0_OR_GREATER
-        return Guid.ParseExact(buffer, GuidFormat);
-#else
         return Guid.ParseExact(new string(buffer.ToArray()), GuidFormat);
-#endif
-
+        
         static void ByteToHex(Span<char> buffer, ref int position, ulong value)
         {
             buffer[position++] = HexDigits[(value >> 4) & 0xF];
             buffer[position++] = HexDigits[value & 0xF];
         }
     }
+#else
+    public static Guid ConvertToGuid(this DuckDBHugeInt input)
+    {
+        var bytes = ArrayPool<byte>.Shared.Rent(32);
+        try
+        {
+            // Reverse the bit flip on the upper 64 bits
+            long upper = input.Upper ^ ((long)1 << 63);
+
+            // Write upper 64 bits (bytes 0-7)
+            BitConverter.TryWriteBytes(bytes.AsSpan(16), upper);
+
+            // Write lower 64 bits (bytes 8-15)
+            BitConverter.TryWriteBytes(bytes.AsSpan(16 + 8), input.Lower);
+
+            // Reconstruct the Guid bytes (reverse the original byte reordering)
+            ReorderBytesForGuid();
+
+            // Create Guid from the first 16 bytes
+            return new Guid(bytes.AsSpan(0, 16));
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(bytes);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void ReorderBytesForGuid()
+        {
+            // First 4 bytes (little-endian)
+            bytes[6] = bytes[16 + 0];
+            bytes[7] = bytes[16 + 1];
+            bytes[4] = bytes[16 + 2];
+            bytes[5] = bytes[16 + 3];
+
+            // Next 4 bytes (little-endian)
+            bytes[0] = bytes[16 + 4];
+            bytes[1] = bytes[16 + 5];
+            bytes[2] = bytes[16 + 6];
+            bytes[3] = bytes[16 + 7];
+
+            // Last 8 bytes (big-endian)
+            bytes[15] = bytes[16 + 8];
+            bytes[14] = bytes[16 + 9];
+            bytes[13] = bytes[16 + 10];
+            bytes[12] = bytes[16 + 11];
+            bytes[11] = bytes[16 + 12];
+            bytes[10] = bytes[16 + 13];
+            bytes[9] = bytes[16 + 14];
+            bytes[8] = bytes[16 + 15];
+        }
+    }
+#endif
 
     //https://github.com/duckdb/duckdb/blob/9c91b3a329073ea1767b0aaff94b51da98dd03e2/src/common/types/uuid.cpp#L6
     public static DuckDBHugeInt ToHugeInt(this Guid guid)
     {
-        char HexToChar(char ch)
+        var bytes = ArrayPool<byte>.Shared.Rent(32);
+
+        try
         {
-            return ch switch
-            {
-                >= '0' and <= '9' => (char)(ch - '0'),
-                >= 'a' and <= 'f' => (char)(10 + ch - 'a'),
-                >= 'A' and <= 'F' => (char)(10 + ch - 'A'),
-                _ => (char)0
-            };
-        }
+#if NET6_0_OR_GREATER
+            guid.TryWriteBytes(bytes);
+#else
+            Buffer.BlockCopy(guid.ToByteArray(), 0, bytes, 0, 16);
+#endif
+            bytes[16 + 0] = bytes[6]; // First 4 bytes (little-endian)
+            bytes[16 + 1] = bytes[7];
+            bytes[16 + 2] = bytes[4];
+            bytes[16 + 3] = bytes[5];
+            bytes[16 + 4] = bytes[0]; // Next 4 bytes (little-endian)
+            bytes[16 + 5] = bytes[1];
+            bytes[16 + 6] = bytes[2];
+            bytes[16 + 7] = bytes[3];
 
-        ulong lower = 0;
-        long upper = 0;
+            bytes[16 + 8] = bytes[15]; // Big endian 
+            bytes[16 + 9] = bytes[14];
+            bytes[16 + 10] = bytes[13];
+            bytes[16 + 11] = bytes[12];
+            bytes[16 + 12] = bytes[11];
+            bytes[16 + 13] = bytes[10];
+            bytes[16 + 14] = bytes[9];
+            bytes[16 + 15] = bytes[8];
 
-        var str = guid.ToString("N");
+            // Upper 64 bits (bytes 0-7)
+            long upper = BitConverter.ToInt64(bytes, 16 + 0);
 
-        for (var index = 0; index < str.Length; index++)
+            // Lower 64 bits (bytes 8-15)
+            ulong lower = BitConverter.ToUInt64(bytes, 16 + 8);
+
+            // Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
+            upper ^= ((long)1 << 63);
+
+            return new DuckDBHugeInt(lower, upper);
+        }
+        finally
         {
-            if (index >= 16)
-            {
-                lower = (lower << 4) | HexToChar(str[index]);
-            }
-            else
-            {
-                upper = (upper << 4) | HexToChar(str[index]);
-            }
+            ArrayPool<byte>.Shared.Return(bytes);
         }
-
-        // Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
-        upper ^= ((long)1 << 63);
-        return new DuckDBHugeInt(lower, upper);
     }
 }