31355: SQLite: Add EF.Functions.Unhex (#31454)

Fixes #31355

Co-authored-by: Brice Lambson <[email protected]>

Author: smnsht

src/EFCore.Sqlite.Core/Extensions/SqliteDbFunctionsExtensions.cs

@@ -43,6 +43,33 @@ public static bool Glob(this DbFunctions _, string matchExpression, string patte
     public static string Hex(this DbFunctions _, byte[] bytes)
         => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Hex)));
 
+    /// <summary>
+    ///     Maps to the SQLite <c>unhex</c> function which returns a BLOB representing decoding of the hexadecimal string.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-database-functions">Database functions</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlite">Accessing SQLite databases with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
+    /// <param name="value">The hexadecimal string.</param>
+    /// <returns>Decoded hexadecimal string as binary value.</returns>
+    public static byte[] Unhex(this DbFunctions _, string value)
+        => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Unhex)));
+
+    /// <summary>
+    ///     Maps to the SQLite <c>unhex</c> function which returns a BLOB representing decoding of the hexadecimal string.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-database-functions">Database functions</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlite">Accessing SQLite databases with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
+    /// <param name="value">The hexadecimal string.</param>
+    /// <param name="ignoreChars">Characters that are ignored in <paramref name="value"/>.</param>
+    /// <returns>Decoded hexadecimal string as binary value.</returns>
+    public static byte[] Unhex(this DbFunctions _, string value, string ignoreChars)
+        => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Unhex)));
+
     /// <summary>
     ///     Maps to the SQLite <c>substr</c> function which returns a subarray of the specified value. The subarray starts
     ///     at <paramref name="startIndex" /> and continues to the end of the value.

src/EFCore.Sqlite.Core/Query/Internal/SqliteHexMethodTranslator.cs

@@ -13,9 +13,15 @@ namespace Microsoft.EntityFrameworkCore.Sqlite.Query.Internal;
 /// </summary>
 public class SqliteHexMethodTranslator : IMethodCallTranslator
 {
-    private static readonly MethodInfo MethodInfo = typeof(SqliteDbFunctionsExtensions)
+    private static readonly MethodInfo HexMethodInfo = typeof(SqliteDbFunctionsExtensions)
         .GetMethod(nameof(SqliteDbFunctionsExtensions.Hex), new[] { typeof(DbFunctions), typeof(byte[]) })!;
 
+    private static readonly MethodInfo UnhexMethodInfo = typeof(SqliteDbFunctionsExtensions)
+        .GetMethod(nameof(SqliteDbFunctionsExtensions.Unhex), new[] { typeof(DbFunctions), typeof(string) })!;
+
+    private static readonly MethodInfo UnhexWithIgnoreCharsMethodInfo = typeof(SqliteDbFunctionsExtensions)
+        .GetMethod(nameof(SqliteDbFunctionsExtensions.Unhex), new[] { typeof(DbFunctions), typeof(string), typeof(string) })!;
+
     private readonly ISqlExpressionFactory _sqlExpressionFactory;
 
     /// <summary>
@@ -41,7 +47,7 @@ public SqliteHexMethodTranslator(ISqlExpressionFactory sqlExpressionFactory)
         IReadOnlyList<SqlExpression> arguments,
         IDiagnosticsLogger<DbLoggerCategory.Query> logger)
     {
-        if (method.Equals(MethodInfo))
+        if (method.Equals(HexMethodInfo))
         {
             return _sqlExpressionFactory.Function(
                 "hex",
@@ -51,6 +57,17 @@ public SqliteHexMethodTranslator(ISqlExpressionFactory sqlExpressionFactory)
                 typeof(string));
         }
 
+        if (method.Equals(UnhexMethodInfo)
+            || method.Equals(UnhexWithIgnoreCharsMethodInfo))
+        {
+            return _sqlExpressionFactory.Function(
+                "unhex",
+                arguments.Skip(1),
+                nullable: true,
+                arguments.Skip(1).Select(_ => true).ToArray(),
+                typeof(byte[]));
+        }
+
         return null;
     }
 }

test/EFCore.Sqlite.FunctionalTests/BuiltInDataTypesSqliteTest.cs

@@ -1546,6 +1546,46 @@ SELECT hex("o"."Bytes")
         Assert.Equal(expectedResults, results);
     }
 
+    [ConditionalFact]
+    public virtual void Can_query_using_unhex_function()
+    {
+        using var context = CreateContext();
+
+        var results = context.Set<ObjectBackedDataTypes>()
+            .Select(e => EF.Functions.Unhex(EF.Functions.Hex(e.Bytes))).ToList();
+
+        AssertSql(
+"""
+SELECT unhex(hex("o"."Bytes"))
+FROM "ObjectBackedDataTypes" AS "o"
+""");
+
+        var expectedResults = context.Set<ObjectBackedDataTypes>().AsEnumerable()
+            .Select(e => e.Bytes).ToList();
+
+        Assert.Equal(expectedResults, results);
+    }
+
+    [ConditionalFact]
+    public virtual void Can_query_using_unhex_function_with_ignore_chars()
+    {
+        using var context = CreateContext();
+
+        var results = context.Set<ObjectBackedDataTypes>()
+            .Select(e => EF.Functions.Unhex(EF.Functions.Hex(e.Bytes) + "!?", "!?")).ToList();
+
+        AssertSql(
+"""
+SELECT unhex(COALESCE(hex("o"."Bytes"), '') || '!?', '!?')
+FROM "ObjectBackedDataTypes" AS "o"
+""");
+
+        var expectedResults = context.Set<ObjectBackedDataTypes>().AsEnumerable()
+            .Select(e => e.Bytes).ToList();
+
+        Assert.Equal(expectedResults, results);
+    }
+
     [ConditionalFact]
     public virtual void Can_query_using_substr_function()
     {