Clean up PR dotnet#22497

Author: bricelam

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

@@ -31,7 +31,7 @@ public SqliteMethodCallTranslatorProvider([NotNull] RelationalMethodCallTranslat
                     new SqliteByteArrayMethodTranslator(sqlExpressionFactory),
                     new SqliteDateTimeAddTranslator(sqlExpressionFactory),
                     new SqliteMathTranslator(sqlExpressionFactory),
-                    new SqliteRegexTranslator(sqlExpressionFactory),
+                    new SqliteRegexMethodTranslator(sqlExpressionFactory),
                     new SqliteStringMethodTranslator(sqlExpressionFactory)
                 });
         }

src/EFCore.Sqlite.Core/Query/Internal/SqliteRegexTranslator.cs renamed to src/EFCore.Sqlite.Core/Query/Internal/SqliteRegexMethodTranslator.cs

@@ -19,28 +19,34 @@ namespace Microsoft.EntityFrameworkCore.Sqlite.Query.Internal
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public class SqliteRegexTranslator : IMethodCallTranslator
+    public class SqliteRegexMethodTranslator : IMethodCallTranslator
     {
+        private readonly static MethodInfo _regexIsMatchMethodInfo
+            = typeof(Regex).GetRuntimeMethod(nameof(Regex.IsMatch), new Type[] { typeof(string), typeof(string) });
+
         private readonly ISqlExpressionFactory _sqlExpressionFactory;
-        private readonly static MethodInfo regexIsMatchMethod = typeof(Regex).GetMethod(nameof(Regex.IsMatch), new Type[] { typeof(string), typeof(string) });
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
         ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public SqliteRegexTranslator([NotNull] ISqlExpressionFactory sqlExpressionFactory)
+        public SqliteRegexMethodTranslator([NotNull] ISqlExpressionFactory sqlExpressionFactory)
         {
+            Check.NotNull(sqlExpressionFactory, nameof(sqlExpressionFactory));
+
             _sqlExpressionFactory = sqlExpressionFactory;
         }
+
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
         ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public virtual SqlExpression Translate(SqlExpression instance,
+        public virtual SqlExpression Translate(
+            SqlExpression instance,
             MethodInfo method,
             IReadOnlyList<SqlExpression> arguments,
             IDiagnosticsLogger<DbLoggerCategory.Query> logger)
@@ -49,15 +55,22 @@ public virtual SqlExpression Translate(SqlExpression instance,
             Check.NotNull(arguments, nameof(arguments));
             Check.NotNull(logger, nameof(logger));
 
-
-            if (method.Equals(regexIsMatchMethod))
+            if (method.Equals(_regexIsMatchMethodInfo))
             {
-                return _sqlExpressionFactory.Function("regexp",
-                    new[] { arguments[1], arguments[0] },
-                    false,
-                    new[] { false, false },
-                    typeof(bool),
-                    arguments[0].TypeMapping);
+                var input = arguments[0];
+                var pattern = arguments[1];
+                var stringTypeMapping = ExpressionExtensions.InferTypeMapping(input, pattern);
+
+                return _sqlExpressionFactory.Function(
+                    "regexp",
+                    new[]
+                    {
+                        _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping),
+                        _sqlExpressionFactory.ApplyTypeMapping(input, stringTypeMapping)
+                    },
+                    nullable: true,
+                    argumentsPropagateNullability: new[] { true, true },
+                    typeof(bool));
             }
 
             return null;

src/EFCore.Sqlite.Core/Storage/Internal/SqliteRelationalConnection.cs

@@ -115,13 +115,14 @@ private void InitializeDbConnection(DbConnection connection)
                     sqliteConnection.DefaultTimeout = _commandTimeout.Value;
                 }
 
-                sqliteConnection.CreateFunction<string, string, bool>(
+                sqliteConnection.CreateFunction<string, string, bool?>(
                     "regexp",
                     (pattern, input) =>
                     {
-                        if (input == null || pattern == null)
+                        if (input == null
+                            || pattern == null)
                         {
-                            return false;
+                            return null;
                         }
 
                         return Regex.IsMatch(input, pattern);
@@ -146,7 +147,8 @@ private void InitializeDbConnection(DbConnection connection)
 
                         return Convert.ToDouble(dividend, CultureInfo.InvariantCulture)
                             % Convert.ToDouble(divisor, CultureInfo.InvariantCulture);
-                    });
+                    },
+                    isDeterministic: true);
 
                 sqliteConnection.CreateFunction(
                     name: "ef_add",
@@ -176,7 +178,6 @@ private void InitializeDbConnection(DbConnection connection)
                     isDeterministic: true);
             }
             else
-
             {
                 _logger.UnexpectedConnectionTypeWarning(connection.GetType());
             }

test/EFCore.Cosmos.FunctionalTests/Query/NorthwindFunctionsQueryCosmosTest.cs

@@ -1049,6 +1049,16 @@ public override Task Int_Compare_to_simple_zero(bool async)
             return base.Int_Compare_to_simple_zero(async);
         }
 
+        public override Task Regex_IsMatch_MethodCall(bool async)
+        {
+            return AssertTranslationFailed(() => base.Regex_IsMatch_MethodCall(async));
+        }
+
+        public override Task Regex_IsMatch_MethodCall_constant_input(bool async)
+        {
+            return AssertTranslationFailed(() => base.Regex_IsMatch_MethodCall_constant_input(async));
+        }
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
 

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

@@ -1590,9 +1590,20 @@ public virtual Task Projecting_Math_Truncate_and_ordering_by_it_twice3(bool asyn
         [MemberData(nameof(IsAsyncData))]
         public virtual Task Regex_IsMatch_MethodCall(bool async)
         {
-            return AssertQuery(async,
-                ss => ss.Set<Customer>().Where(o => Regex.IsMatch(o.CustomerID, @"^T")),
+            return AssertQuery(
+                async,
+                ss => ss.Set<Customer>().Where(o => Regex.IsMatch(o.CustomerID, "^T")),
                 entryCount: 6);
         }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Regex_IsMatch_MethodCall_constant_input(bool async)
+        {
+            return AssertQuery(
+                async,
+                ss => ss.Set<Customer>().Where(o => Regex.IsMatch("ALFKI", o.CustomerID)),
+                entryCount: 1);
+        }
     }
 }

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

@@ -1548,11 +1548,17 @@ public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice3(bo
             //WHERE [o].[OrderID] < 10250
             //ORDER BY [A] DESC");
         }
+
         public override Task Regex_IsMatch_MethodCall(bool async)
         {
             return AssertTranslationFailed(() => base.Regex_IsMatch_MethodCall(async));
         }
 
+        public override Task Regex_IsMatch_MethodCall_constant_input(bool async)
+        {
+            return AssertTranslationFailed(() => base.Regex_IsMatch_MethodCall_constant_input(async));
+        }
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
 

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

@@ -520,6 +520,15 @@ public override async Task Regex_IsMatch_MethodCall(bool async)
 WHERE regexp('^T', ""c"".""CustomerID"")");
         }
 
+        public override async Task Regex_IsMatch_MethodCall_constant_input(bool async)
+        {
+            await base.Regex_IsMatch_MethodCall_constant_input(async);
+
+            AssertSql(@"SELECT ""c"".""CustomerID"", ""c"".""Address"", ""c"".""City"", ""c"".""CompanyName"", ""c"".""ContactName"", ""c"".""ContactTitle"", ""c"".""Country"", ""c"".""Fax"", ""c"".""Phone"", ""c"".""PostalCode"", ""c"".""Region""
+FROM ""Customers"" AS ""c""
+WHERE regexp(""c"".""CustomerID"", 'ALFKI')");
+        }
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
     }