Add support for string comparison methods (#3744)

* add support for string.compare
* add support for string.compareto
* add test cases

Author: lukedukeus

src/LinqTests/Operators/string_compare_operator.cs

@@ -0,0 +1,42 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Marten.Testing.Documents;
+using Marten.Testing.Harness;
+using Shouldly;
+
+namespace LinqTests.Operators;
+
+public class string_compare_operator: IntegrationContext
+{
+    [Fact]
+    public async Task string_compare_works()
+    {
+        theSession.Store(new Target { String = "Apple" });
+        theSession.Store(new Target { String = "Banana" });
+        theSession.Store(new Target { String = "Cherry" });
+        theSession.Store(new Target { String = "Durian" });
+        await theSession.SaveChangesAsync();
+
+        var queryable = theSession.Query<Target>().Where(x => string.Compare(x.String, "Cherry") > 0);
+
+        queryable.ToList().Count.ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task string_compare_to_works()
+    {
+        theSession.Store(new Target { String = "Apple" });
+        theSession.Store(new Target { String = "Banana" });
+        theSession.Store(new Target { String = "Cherry" });
+        theSession.Store(new Target { String = "Durian" });
+        await theSession.SaveChangesAsync();
+
+        var queryable = theSession.Query<Target>().Where(x => x.String.CompareTo("Banana") > 0);
+
+        queryable.ToList().Count.ShouldBe(2);
+    }
+
+    public string_compare_operator(DefaultStoreFixture fixture) : base(fixture)
+    {
+    }
+}

src/Marten/Linq/Parsing/CompareToComparable.cs

@@ -0,0 +1,34 @@
+using System.Linq.Expressions;
+using Marten.Exceptions;
+using Marten.Linq.Members;
+using Weasel.Postgresql.SqlGeneration;
+
+namespace Marten.Linq.Parsing;
+
+internal class CompareToComparable: IComparableMember
+{
+    private readonly SimpleExpression _left;
+    private readonly SimpleExpression _right;
+
+    public CompareToComparable(SimpleExpression left, SimpleExpression right)
+    {
+        _left = left;
+        _right = right;
+    }
+
+    public ISqlFragment CreateComparison(string op, ConstantExpression constant)
+    {
+        // Only compare to 0 is valid: CompareTo() > 0 → ">", CompareTo() == 0 → "=", etc.
+        if (constant.Value is int intValue && intValue == 0)
+        {
+            var leftFragment = _left.FindValueFragment();
+            var rightFragment = _right.FindValueFragment();
+
+            return new ComparisonFilter(leftFragment, rightFragment, op);
+        }
+
+        throw new BadLinqExpressionException(
+            "string.CompareTo() must be compared to 0 (e.g., x.Name.CompareTo(\"A\") > 0)");
+    }
+}
+

src/Marten/Linq/Parsing/SimpleExpression.cs

@@ -1,7 +1,6 @@
 #nullable disable
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -306,6 +305,29 @@ protected override Expression VisitParameter(ParameterExpression node)
 
     protected override Expression VisitMethodCall(MethodCallExpression node)
     {
+        if (node.Object == null &&
+            node.Method.DeclaringType == typeof(string) &&
+            node.Method.Name == "Compare" &&
+            node.Arguments.Count == 2 &&
+            node.Method.IsStatic)
+        {
+            var leftArg = new SimpleExpression(_queryableMembers, node.Arguments[0]);
+            var rightArg = new SimpleExpression(_queryableMembers, node.Arguments[1]);
+            Comparable = new StringCompareComparable(leftArg, rightArg);
+            return null;
+        }
+
+        if (node.Method.DeclaringType == typeof(string) &&
+            node.Method.Name == "CompareTo" &&
+            node.Arguments.Count == 1)
+        {
+            var left = new SimpleExpression(_queryableMembers, node.Object);
+            var right = new SimpleExpression(_queryableMembers, node.Arguments[0]);
+
+            Comparable = new CompareToComparable(left, right);
+            return null;
+        }
+
         if (node.Object == null && !(node.Arguments.FirstOrDefault() is MemberExpression))
         {
             // It's a method of a static, so this has to be a constant

src/Marten/Linq/Parsing/StringCompareComparable.cs

@@ -0,0 +1,33 @@
+using System.Linq.Expressions;
+using Marten.Exceptions;
+using Marten.Linq.Members;
+using Weasel.Postgresql.SqlGeneration;
+
+namespace Marten.Linq.Parsing;
+
+internal class StringCompareComparable: IComparableMember
+{
+    private readonly SimpleExpression _left;
+    private readonly SimpleExpression _right;
+
+    internal StringCompareComparable(SimpleExpression left, SimpleExpression right)
+    {
+        _left = left;
+        _right = right;
+    }
+
+    public ISqlFragment CreateComparison(string op, ConstantExpression constant)
+    {
+        if (constant.Value is int intValue && intValue == 0)
+        {
+            var leftFragment = _left.FindValueFragment();
+            var rightFragment = _right.FindValueFragment();
+
+            return new ComparisonFilter(leftFragment, rightFragment, op);
+        }
+        else
+        {
+            throw new BadLinqExpressionException("string.Compare must be compared to 0");
+        }
+    }
+}