Add regex and regex_phrase

Author: isaacvando

src/Internal/Query/Translator.cs

@@ -86,6 +86,14 @@ IRelationalTypeMappingSource typeMappingSource
                 argumentsPropagateNullability: [false],
                 returnType: typeof(bool)
             ),
+            nameof(Pdb.Regex) => _sqlExpressionFactory.Function(
+                name: "pdb.regex",
+                nullable: false,
+                arguments: [arguments[0]],
+                argumentsPropagateNullability: [false],
+                returnType: typeof(bool)
+            ),
+            nameof(Pdb.RegexPhrase) => BuildRegexPhrase(arguments),
             nameof(Pdb.RangeTerm) => BuildRangeTerm(arguments),
             nameof(Pdb.PhrasePrefix) => BuildPhrasePrefix(arguments),
             nameof(ParadeDbFunctionsExtensions.Snippet) => BuildSnippet(arguments),
@@ -149,6 +157,35 @@ IRelationalTypeMappingSource typeMappingSource
         );
     }
 
+    private SqlExpression? BuildRegexPhrase(IReadOnlyList<SqlExpression> arguments)
+    {
+        List<SqlExpression> args = [_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[0])];
+        List<string?> argNames = [null];
+
+        if (arguments[1] is not SqlConstantExpression { Value: null })
+        {
+            args.Add(_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[1]));
+            argNames.Add("slop");
+        }
+
+        if (arguments[2] is not SqlConstantExpression { Value: null })
+        {
+            args.Add(_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[2]));
+            argNames.Add("max_expansions");
+        }
+
+        return PgFunctionExpression.CreateWithNamedArguments(
+            name: "pdb.regex_phrase",
+            arguments: args,
+            argumentNames: argNames,
+            nullable: false,
+            argumentsPropagateNullability: new bool[args.Count],
+            builtIn: false,
+            type: typeof(bool),
+            typeMapping: null
+        );
+    }
+
     private SqlExpression? BuildRangeTerm(IReadOnlyList<SqlExpression> arguments)
     {
         List<SqlExpression> args = [_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[0])];

src/Pdb.cs

@@ -79,6 +79,9 @@ public static PdbQuery Exists() =>
     public static PdbQuery Parse(string pattern) =>
         throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Parse)));
 
+    public static PdbQuery Regex([StringSyntax(StringSyntaxAttribute.Regex)] string pattern) =>
+        throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Regex)));
+
     public static PdbQuery RangeTerm<T>(T value) =>
         throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(RangeTerm)));
 
@@ -91,4 +94,10 @@ [NotParameterized] RangeTermRelation relation
 
     public static PdbQuery PhrasePrefix(string[] tokens, int? maxExpansions = null) =>
         throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(PhrasePrefix)));
+
+    public static PdbQuery RegexPhrase(
+        [StringSyntax(StringSyntaxAttribute.Regex)] string[] phrases,
+        int? slop = null,
+        int? maxExpansions = null
+    ) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(RegexPhrase)));
 }

tests/QueryTests.cs

@@ -1638,6 +1638,94 @@ WHERE m.description @@@ pdb.parse('description:(sleek shoes) AND rating:>3')
         await query.ToListAsync();
     }
 
+    [Test]
+    public async Task RegexQuery()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        var query = context
+            .MockItems.Where(p => EF.Functions.Query(p.Description, Pdb.Regex("ru.*")))
+            .Select(p => p.Description);
+
+        var sql = """
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.regex('ru.*')
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
+    [Test]
+    public async Task RegexPhrase()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        var query = context
+            .MockItems.Where(p =>
+                EF.Functions.Query(p.Description, Pdb.RegexPhrase(new[] { "ru.*", "shoes" }))
+            )
+            .Select(p => p.Description);
+
+        var sql = """
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.regex_phrase(ARRAY['ru.*','shoes']::text[])
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
+    [Test]
+    public async Task RegexPhraseSlopAndMaxExpansions()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        var query = context
+            .MockItems.Where(p =>
+                EF.Functions.Query(
+                    p.Description,
+                    Pdb.RegexPhrase(new[] { "ru.*", "shoes" }, 2, 100)
+                )
+            )
+            .Select(p => p.Description);
+
+        var sql = """
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.regex_phrase(ARRAY['ru.*','shoes']::text[], slop => 2, max_expansions => 100)
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
+    [Test]
+    public async Task RegexPhraseMaxExpansions()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        var query = context
+            .MockItems.Where(p =>
+                EF.Functions.Query(
+                    p.Description,
+                    Pdb.RegexPhrase(new[] { "ru.*", "shoes" }, null, 100)
+                )
+            )
+            .Select(p => p.Description);
+
+        var sql = """
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.regex_phrase(ARRAY['ru.*','shoes']::text[], max_expansions => 100)
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
     [Test]
     public async Task PhrasePrefix()
     {