feat: Add lenient and conjunction mode options to parse (#63)

Author: isaacvando

src/Extensions/ParadeDbFunctionsExtensions.cs

@@ -155,6 +155,15 @@ public static bool Exists<TProperty>(this DbFunctions _, TProperty property) =>
     public static bool Parse<TProperty>(this DbFunctions _, TProperty property, string pattern) =>
         throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Parse)));
 
+    [DbFunction]
+    public static bool Parse<TProperty>(
+        this DbFunctions _,
+        TProperty property,
+        string pattern,
+        bool? lenient = null,
+        bool? conjunctionMode = null
+    ) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Parse)));
+
     [DbFunction]
     public static bool Regex<TProperty>(
         this DbFunctions _,

src/Internal/Query/Translator.cs

@@ -87,13 +87,7 @@ IRelationalTypeMappingSource typeMappingSource
             ),
             nameof(ParadeDbFunctionsExtensions.Parse) => BuildQueryBuilderFunction(
                 arguments[1],
-                _sqlExpressionFactory.Function(
-                    name: "pdb.parse",
-                    nullable: false,
-                    arguments: [arguments[2]],
-                    argumentsPropagateNullability: [false],
-                    returnType: typeof(bool)
-                )
+                BuildParse(arguments)
             ),
             nameof(ParadeDbFunctionsExtensions.Regex) => BuildQueryBuilderFunction(
                 arguments[1],
@@ -159,6 +153,40 @@ IRelationalTypeMappingSource typeMappingSource
         };
     }
 
+    private SqlExpression BuildParse(IReadOnlyList<SqlExpression> arguments)
+    {
+        List<SqlExpression> args = [_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[2])];
+        List<string?> argNames = [null];
+
+        Add(3, "lenient");
+        Add(4, "conjunction_mode");
+
+        void Add(int index, string name)
+        {
+            if (
+                arguments.Count <= index
+                || arguments[index] is SqlConstantExpression { Value: null }
+            )
+            {
+                return;
+            }
+
+            args.Add(_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[index]));
+            argNames.Add(name);
+        }
+
+        return PgFunctionExpression.CreateWithNamedArguments(
+            name: "pdb.parse",
+            arguments: args,
+            argumentNames: argNames,
+            nullable: false,
+            argumentsPropagateNullability: new bool[args.Count],
+            builtIn: false,
+            type: typeof(bool),
+            typeMapping: null
+        );
+    }
+
     private SqlExpression BuildPhrasePrefix(IReadOnlyList<SqlExpression> arguments)
     {
         List<SqlExpression> args = [arguments[2]];

tests/QueryTests.cs

@@ -1636,6 +1636,74 @@ WHERE m.description @@@ pdb.parse('description:(sleek shoes) AND rating:>3')
         await query.ToListAsync();
     }
 
+    [Test]
+    public async Task Parse_Lenient()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        var query = context
+            .MockItems.Where(p => EF.Functions.Parse(p.Description, "sleek shoes", lenient: true))
+            .Select(p => p.Description);
+
+        var sql = """
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.parse('sleek shoes', lenient => TRUE)
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
+    [Test]
+    public async Task Parse_ConjunctionMode()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        var query = context
+            .MockItems.Where(p =>
+                EF.Functions.Parse(p.Description, "description:(sleek shoes)", null, true)
+            )
+            .Select(p => p.Description);
+
+        var sql = """
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.parse('description:(sleek shoes)', conjunction_mode => TRUE)
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
+    [Test]
+    public async Task Parse_WithVariableParameters()
+    {
+        await using var context = DbFixture.CreateContext();
+
+        string pattern = "description:(sleek shoes)";
+        bool lenient = true;
+        bool conjunctionMode = true;
+
+        var query = context
+            .MockItems.Where(p =>
+                EF.Functions.Parse(p.Description, pattern, lenient, conjunctionMode)
+            )
+            .Select(p => p.Description);
+
+        var sql = """
+            -- @pattern='description:(sleek shoes)'
+            -- @lenient='True' (Nullable = true)
+            -- @conjunctionMode='True' (Nullable = true)
+            SELECT m.description
+            FROM mock_items AS m
+            WHERE m.description @@@ pdb.parse(@pattern, lenient => @lenient, conjunction_mode => @conjunctionMode)
+            """;
+
+        AssertSql(query, sql);
+        await query.ToListAsync();
+    }
+
     [Test]
     public async Task RegexQuery()
     {