Support Contains on byte arrays

Resolves #4601

Author: roji

src/EFCore.SqlServer/Query/Internal/SqlServerByteArrayMethodTranslator.cs

@@ -0,0 +1,48 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace Microsoft.EntityFrameworkCore.SqlServer.Query.Internal
+{
+    public class SqlServerByteArrayMethodTranslator : IMethodCallTranslator
+    {
+        private readonly ISqlExpressionFactory _sqlExpressionFactory;
+
+        public SqlServerByteArrayMethodTranslator(ISqlExpressionFactory sqlExpressionFactory)
+        {
+            _sqlExpressionFactory = sqlExpressionFactory;
+        }
+
+        public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList<SqlExpression> arguments)
+        {
+            if (method.IsGenericMethod
+                && method.GetGenericMethodDefinition().Equals(EnumerableMethods.Contains)
+                && arguments[0].Type == typeof(byte[]))
+            {
+                instance = arguments[0];
+                var typeMapping = instance.TypeMapping;
+
+                var pattern = arguments[1] is SqlConstantExpression constantExpression
+                    ? (SqlExpression)_sqlExpressionFactory.Constant(new[] { (byte)constantExpression.Value }, typeMapping)
+                    : _sqlExpressionFactory.Convert(arguments[1], typeof(byte[]), typeMapping);
+
+                return _sqlExpressionFactory.GreaterThan(
+                    _sqlExpressionFactory.Function(
+                        "CHARINDEX",
+                        new[] { pattern, instance },
+                        typeof(int)),
+                    _sqlExpressionFactory.Constant(0));
+            }
+
+            return null;
+        }
+    }
+}

src/EFCore.SqlServer/Query/Internal/SqlServerMethodCallTranslatorProvider.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Query;
 
@@ -24,7 +25,8 @@ public SqlServerMethodCallTranslatorProvider([NotNull] RelationalMethodCallTrans
                     new SqlServerMathTranslator(sqlExpressionFactory),
                     new SqlServerNewGuidTranslator(sqlExpressionFactory),
                     new SqlServerObjectToStringTranslator(sqlExpressionFactory),
-                    new SqlServerStringMethodTranslator(sqlExpressionFactory)
+                    new SqlServerStringMethodTranslator(sqlExpressionFactory),
+                    new SqlServerByteArrayMethodTranslator(sqlExpressionFactory)
                 });
         }
     }

test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs

@@ -7282,6 +7282,25 @@ on ll.Name equals h.CommanderName
                       select h);
         }
 
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Byte_array_contains_literal(bool async)
+        {
+            return AssertQuery(
+                async,
+                ss => ss.Set<Squad>().Where(s => s.Banner != null && s.Banner.Contains((byte)1)));
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Byte_array_contains_parameter(bool async)
+        {
+            var someByte = (byte)1;
+            return AssertQuery(
+                async,
+                ss => ss.Set<Squad>().Where(s => s.Banner != null && s.Banner.Contains(someByte)));
+        }
+
         protected async Task AssertTranslationFailed(Func<Task> testCode)
         {
             Assert.Contains(

test/EFCore.Specification.Tests/TestModels/GearsOfWarModel/GearsOfWarData.cs

@@ -105,7 +105,11 @@ public virtual IQueryable<TEntity> Set<TEntity>()
         }
 
         public static IReadOnlyList<Squad> CreateSquads()
-            => new List<Squad> { new Squad { Id = 1, Name = "Delta", Banner = new byte[] { 0x00, 0x01 } }, new Squad { Id = 2, Name = "Kilo", Banner = null } };
+            => new List<Squad>
+            {
+                new Squad { Id = 1, Name = "Delta", Banner = new byte[] { 0x00, 0x01 } },
+                new Squad { Id = 2, Name = "Kilo", Banner = new byte[] { 0x02, 0x03 } }
+            };
 
         public static IReadOnlyList<Mission> CreateMissions()
             => new List<Mission>

test/EFCore.SqlServer.FunctionalTests/Query/GearsOfWarQuerySqlServerTest.cs

@@ -7265,6 +7265,28 @@ ELSE NULL
 END IS NULL)");
         }
 
+        public override async Task Byte_array_contains_literal(bool async)
+        {
+            await base.Byte_array_contains_literal(async);
+
+            AssertSql(
+                @"SELECT [s].[Id], [s].[Banner], [s].[InternalNumber], [s].[Name]
+FROM [Squads] AS [s]
+WHERE [s].[Banner] IS NOT NULL AND (CHARINDEX(0x01, [s].[Banner]) > 0)");
+        }
+
+        public override async Task Byte_array_contains_parameter(bool async)
+        {
+            await base.Byte_array_contains_parameter(async);
+
+            AssertSql(
+                @"@__someByte_0='1' (Size = 1)
+
+SELECT [s].[Id], [s].[Banner], [s].[InternalNumber], [s].[Name]
+FROM [Squads] AS [s]
+WHERE [s].[Banner] IS NOT NULL AND (CHARINDEX(CAST(@__someByte_0 AS varbinary(max)), [s].[Banner]) > 0)");
+        }
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
     }

test/EFCore.Sqlite.FunctionalTests/Query/GearsOfWarQuerySqliteTest.cs

@@ -116,6 +116,10 @@ public override async Task Select_datetimeoffset_comparison_in_projection(bool a
 FROM ""Missions"" AS ""m""");
         }
 
+        public override Task Byte_array_contains_literal(bool async) => null;
+
+        public override Task Byte_array_contains_parameter(bool async) => null;
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
     }