Remove string comparison support

docs/mdsource/query-usage.source.md

@@ -246,25 +246,6 @@ Or:
 ```
 
 
-#### Case Sensitivity
-
-All string comparisons are, by default, done using no [StringComparison](https://msdn.microsoft.com/en-us/library/system.stringcomparison.aspx). A custom StringComparison can be used via the `case` attribute.
-
-```graphql
-{
-  entities
-  (where: {
-    path: "Property",
-    comparison: "endsWith",
-    value: "the value",
-    case: "Ordinal"})
-  {
-    property
-  }
-}
-```
-
-
 #### Null
 
 Null can be expressed by omitting the `value`:

docs/query-usage.md

@@ -253,25 +253,6 @@ Or:
 ```
 
 
-#### Case Sensitivity
-
-All string comparisons are, by default, done using no [StringComparison](https://msdn.microsoft.com/en-us/library/system.stringcomparison.aspx). A custom StringComparison can be used via the `case` attribute.
-
-```graphql
-{
-  entities
-  (where: {
-    path: "Property",
-    comparison: "endsWith",
-    value: "the value",
-    case: "Ordinal"})
-  {
-    property
-  }
-}
-```
-
-
 #### Null
 
 Null can be expressed by omitting the `value`:

src/Directory.Build.props

@@ -2,7 +2,7 @@
 <Project>
   <PropertyGroup>
     <NoWarn>CS1591;NU5104;CS1573;CS9107;NU1608;NU1109</NoWarn>
-    <Version>30.0.0</Version>
+    <Version>31.0.0</Version>
     <LangVersion>preview</LangVersion>
     <AssemblyVersion>1.0.0</AssemblyVersion>
     <PackageTags>EntityFrameworkCore, EntityFramework, GraphQL</PackageTags>

src/GraphQL.EntityFramework.sln

@@ -10,6 +10,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		Directory.Packages.props = Directory.Packages.props
 		mdsnippets.json = mdsnippets.json
 		global.json = global.json
+		..\readme.source.md = ..\readme.source.md
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.EntityFramework", "GraphQL.EntityFramework\GraphQL.EntityFramework.csproj", "{92E64F4E-6A8E-43C2-9C8D-694E0327BEF0}"

src/GraphQL.EntityFramework/EfGraphQLConventions.cs

@@ -84,7 +84,6 @@ static TDbContext DbContextFromProvider<TDbContext>(IServiceProvider provider, I
 
     static void RegisterScalarsAndArgs(IServiceCollection services)
     {
-        services.AddSingleton<EnumerationGraphType<StringComparison>>();
         services.AddSingleton<EnumerationGraphType<DayOfWeek>>();
         services.AddSingleton<WhereExpressionGraph>();
         services.AddSingleton<OrderByGraph>();

src/GraphQL.EntityFramework/Where/ExpressionBuilder.cs

@@ -40,7 +40,7 @@ static Expression MakePredicateBody(IReadOnlyCollection<WhereExpression> wheres)
             else
             {
                 // Get the predicate body for the single expression
-                nextExpression = MakePredicateBody(where.Path, where.Comparison, where.Value, where.Negate, where.Case);
+                nextExpression = MakePredicateBody(where.Path, where.Comparison, where.Value, where.Negate);
             }
 
             // If this is the first where processed
@@ -65,29 +65,29 @@ static Expression MakePredicateBody(IReadOnlyCollection<WhereExpression> wheres)
     /// <summary>
     /// Create a single predicate for the single set of supplied conditional arguments
     /// </summary>
-    public static Expression<Func<T, bool>> BuildPredicate(string path, Comparison comparison, string?[]? values, bool negate = false, StringComparison? stringComparison = null)
+    public static Expression<Func<T, bool>> BuildPredicate(string path, Comparison comparison, string?[]? values, bool negate = false)
     {
-        var expressionBody = MakePredicateBody(path, comparison, values, negate, stringComparison);
+        var expressionBody = MakePredicateBody(path, comparison, values, negate);
         var param = PropertyCache<T>.SourceParameter;
 
         return Expression.Lambda<Func<T, bool>>(expressionBody, param);
     }
 
-    static Expression MakePredicateBody(string path, Comparison comparison, string?[]? values, bool negate, StringComparison? stringComparison)
+    static Expression MakePredicateBody(string path, Comparison comparison, string?[]? values, bool negate)
     {
         Expression expressionBody;
 
         // If path includes list property access
         if (HasListPropertyInPath(path))
         {
             // Handle a list path
-            expressionBody = ProcessList(path, comparison, values!, stringComparison);
+            expressionBody = ProcessList(path, comparison, values!);
         }
         // Otherwise linear property access
         else
         {
             // Just get expression
-            expressionBody = GetExpression(path, comparison, values, stringComparison);
+            expressionBody = GetExpression(path, comparison, values);
         }
 
         // If the expression should be negated
@@ -99,7 +99,7 @@ static Expression MakePredicateBody(string path, Comparison comparison, string?[
         return expressionBody;
     }
 
-    static Expression ProcessList(string path, Comparison comparison, string?[]? values, StringComparison? stringComparison)
+    static Expression ProcessList(string path, Comparison comparison, string?[]? values)
     {
         // Get the path pertaining to individual list items
         var listPath = ListPropertyRegex().Match(path).Groups[1].Value;
@@ -118,7 +118,7 @@ static Expression ProcessList(string path, Comparison comparison, string?[]? val
         var buildPredicate = genericType
             .GetMethods(BindingFlags.Public | BindingFlags.Static)
             .SingleOrDefault(_ => _.Name == "BuildPredicate" &&
-                                  _.GetParameters().Length == 5);
+                                  _.GetParameters().Length == 4);
         if (buildPredicate == null)
         {
             throw new($"Could not find BuildPredicate method on {genericType.FullName}");
@@ -131,8 +131,7 @@ static Expression ProcessList(string path, Comparison comparison, string?[]? val
                     listPath,
                     comparison,
                     values!,
-                    false,
-                    stringComparison!
+                    false
                 ])!;
 
         // Generate a method info for the Any Enumerable Static Method
@@ -146,7 +145,7 @@ static Expression ProcessList(string path, Comparison comparison, string?[]? val
         return Expression.Call(anyInfo, property.Left, subPredicate);
     }
 
-    static Expression GetExpression(string path, Comparison comparison, string?[]? values, StringComparison? stringComparison)
+    static Expression GetExpression(string path, Comparison comparison, string?[]? values)
     {
         var property = PropertyCache<T>.GetProperty(path);
         Expression expressionBody;
@@ -156,18 +155,18 @@ static Expression GetExpression(string path, Comparison comparison, string?[]? v
             switch (comparison)
             {
                 case Comparison.NotIn:
-                    WhereValidator.ValidateString(comparison, stringComparison);
-                    expressionBody = NegateExpression(MakeStringListInComparison(values!, property, stringComparison)); // Ensure expression is negated
+                    WhereValidator.ValidateString(comparison);
+                    expressionBody = NegateExpression(MakeStringListInComparison(values!, property)); // Ensure expression is negated
                     break;
                 case Comparison.In:
-                    WhereValidator.ValidateString(comparison, stringComparison);
-                    expressionBody = MakeStringListInComparison(values!, property, stringComparison);
+                    WhereValidator.ValidateString(comparison);
+                    expressionBody = MakeStringListInComparison(values!, property);
                     break;
 
                 default:
-                    WhereValidator.ValidateSingleString(comparison, stringComparison);
+                    WhereValidator.ValidateSingleString(comparison);
                     var value = values?.Single();
-                    expressionBody = MakeSingleStringComparison(comparison, value, property, stringComparison);
+                    expressionBody = MakeSingleStringComparison(comparison, value, property);
                     break;
             }
         }
@@ -176,16 +175,16 @@ static Expression GetExpression(string path, Comparison comparison, string?[]? v
             switch (comparison)
             {
                 case Comparison.NotIn:
-                    WhereValidator.ValidateObject(property.PropertyType, comparison, stringComparison);
+                    WhereValidator.ValidateObject(property.PropertyType, comparison);
                     expressionBody = NegateExpression(MakeObjectListInComparision(values!, property));
                     break;
                 case Comparison.In:
-                    WhereValidator.ValidateObject(property.PropertyType, comparison, stringComparison);
+                    WhereValidator.ValidateObject(property.PropertyType, comparison);
                     expressionBody = MakeObjectListInComparision(values!, property);
                     break;
 
                 default:
-                    WhereValidator.ValidateSingleObject(property.PropertyType, comparison, null);
+                    WhereValidator.ValidateSingleObject(property.PropertyType, comparison);
                     var value = values?.Single();
                     var valueObject = TypeConverter.ConvertStringToType(value, property.PropertyType);
                     expressionBody = MakeSingleObjectComparison(comparison, valueObject, property);
@@ -211,20 +210,9 @@ static Expression MakeObjectListInComparision(string[] values, Property<T> prope
         return Expression.Call(constant, property.ListContains, property.Left);
     }
 
-    static Expression MakeStringListInComparison(string[] values, Property<T> property, StringComparison? comparison)
+    static Expression MakeStringListInComparison(string[] values, Property<T> property)
     {
-        MethodCallExpression equalsBody;
-
-        if (comparison is null)
-        {
-            // Do basic string compare
-            equalsBody = Expression.Call(null, ReflectionCache.StringEqual, ExpressionCache.StringParam, property.Left);
-        }
-        else
-        {
-            // String comparison with comparison type value
-            equalsBody = Expression.Call(null, ReflectionCache.StringEqualComparison, ExpressionCache.StringParam, property.Left, Expression.Constant(comparison));
-        }
+        var equalsBody = Expression.Call(null, ReflectionCache.StringEqual, ExpressionCache.StringParam, property.Left);
 
         // Make lambda for comparing each string value against property value
         var itemEvaluate = Expression.Lambda<Func<string, bool>>(equalsBody, ExpressionCache.StringParam);
@@ -233,55 +221,31 @@ static Expression MakeStringListInComparison(string[] values, Property<T> proper
         return Expression.Call(null, ReflectionCache.StringAny, Expression.Constant(values), itemEvaluate);
     }
 
-    static Expression MakeSingleStringComparison(Comparison comparison, string? value, Property<T> property, StringComparison? stringComparison)
+    static Expression MakeSingleStringComparison(Comparison comparison, string? value, Property<T> property)
     {
         var left = property.Left;
 
         var valueConstant = Expression.Constant(value, typeof(string));
         var nullCheck = Expression.NotEqual(left, ExpressionCache.Null);
 
-        if (stringComparison is null)
+        switch (comparison)
         {
-            switch (comparison)
-            {
-                case Comparison.Equal:
-                    return Expression.Call(ReflectionCache.StringEqual, left, valueConstant);
-                case Comparison.NotEqual:
-                    return Expression.Not(Expression.Call(ReflectionCache.StringEqual, left, valueConstant));
-                case Comparison.Like:
-                    return Expression.Call(null, ReflectionCache.StringLike, ExpressionCache.EfFunction, left, valueConstant);
-                case Comparison.StartsWith:
-                    var startsWithExpression = Expression.Call(left, ReflectionCache.StringStartsWith, valueConstant);
-                    return Expression.AndAlso(nullCheck, startsWithExpression);
-                case Comparison.EndsWith:
-                    var endsWithExpression = Expression.Call(left, ReflectionCache.StringEndsWith, valueConstant);
-                    return Expression.AndAlso(nullCheck, endsWithExpression);
-                case Comparison.Contains:
-                    var indexOfExpression = Expression.Call(left, ReflectionCache.StringIndexOf, valueConstant);
-                    var notEqualExpression = Expression.NotEqual(indexOfExpression, ExpressionCache.NegativeOne);
-                    return Expression.AndAlso(nullCheck, notEqualExpression);
-            }
-        }
-        else
-        {
-            var comparisonConstant = Expression.Constant(stringComparison, typeof(StringComparison));
-            switch (comparison)
-            {
-                case Comparison.Equal:
-                    return Expression.Call(ReflectionCache.StringEqualComparison, left, valueConstant, comparisonConstant);
-                case Comparison.NotEqual:
-                    return  Expression.Not(Expression.Call(ReflectionCache.StringEqualComparison, left, valueConstant, comparisonConstant));
-                case Comparison.StartsWith:
-                    var startsWithExpression = Expression.Call(left, ReflectionCache.StringStartsWithComparison, valueConstant, comparisonConstant);
-                    return Expression.AndAlso(nullCheck, startsWithExpression);
-                case Comparison.EndsWith:
-                    var endsWithExpression = Expression.Call(left, ReflectionCache.StringEndsWithComparison, valueConstant, comparisonConstant);
-                    return Expression.AndAlso(nullCheck, endsWithExpression);
-                case Comparison.Contains:
-                    var indexOfExpression = Expression.Call(left, ReflectionCache.StringIndexOfComparison, valueConstant, comparisonConstant);
-                    var notEqualExpression = Expression.NotEqual(indexOfExpression, ExpressionCache.NegativeOne);
-                    return Expression.AndAlso(nullCheck, notEqualExpression);
-            }
+            case Comparison.Equal:
+                return Expression.Call(ReflectionCache.StringEqual, left, valueConstant);
+            case Comparison.NotEqual:
+                return Expression.Not(Expression.Call(ReflectionCache.StringEqual, left, valueConstant));
+            case Comparison.Like:
+                return Expression.Call(null, ReflectionCache.StringLike, ExpressionCache.EfFunction, left, valueConstant);
+            case Comparison.StartsWith:
+                var startsWithExpression = Expression.Call(left, ReflectionCache.StringStartsWith, valueConstant);
+                return Expression.AndAlso(nullCheck, startsWithExpression);
+            case Comparison.EndsWith:
+                var endsWithExpression = Expression.Call(left, ReflectionCache.StringEndsWith, valueConstant);
+                return Expression.AndAlso(nullCheck, endsWithExpression);
+            case Comparison.Contains:
+                var indexOfExpression = Expression.Call(left, ReflectionCache.StringIndexOf, valueConstant);
+                var notEqualExpression = Expression.NotEqual(indexOfExpression, ExpressionCache.NegativeOne);
+                return Expression.AndAlso(nullCheck, notEqualExpression);
         }
 
         throw new($"Invalid comparison operator '{comparison}'.");

src/GraphQL.EntityFramework/Where/Graphs/WhereExpression.cs

@@ -4,7 +4,6 @@ public class WhereExpression
 {
     public string Path { get; set; } = string.Empty;
     public Comparison Comparison { get; set; } = Comparison.Equal;
-    public StringComparison? Case { get; set; }
     public string[]? Value { get; set; }
     public bool Negate { get; set; }
     public Connector Connector { get; set; } = Connector.And;

src/GraphQL.EntityFramework/Where/Graphs/WhereExpressionGraph.cs

@@ -9,7 +9,6 @@ public WhereExpressionGraph()
         Field(_ => _.Path, true);
         Field<ComparisonGraph>("comparison");
         Field(_ => _.Negate, true);
-        Field<EnumerationGraphType<StringComparison>>("case");
         Field(_ => _.Value, true);
         Field<ConnectorGraph>("connector");
         Field<ListGraphType<WhereExpressionGraph>>("GroupedExpressions");

src/GraphQL.EntityFramework/Where/ReflectionCache.cs

@@ -22,13 +22,9 @@
     static MethodInfo dateTimeOffsetListContains;
     static MethodInfo dateTimeOffsetNullableListContains;
     public static MethodInfo StringLike = typeof(DbFunctionsExtensions).GetMethod("Like", [typeof(DbFunctions), typeof(string), typeof(string)])!;
-    public static MethodInfo StringEqualComparison = typeof(string).GetMethod("Equals", [typeof(string), typeof(string), typeof(StringComparison)])!;
     public static MethodInfo StringEqual = typeof(string).GetMethod("Equals", [typeof(string), typeof(string)])!;
-    public static MethodInfo StringStartsWithComparison = typeof(string).GetMethod("StartsWith", [typeof(string), typeof(StringComparison)])!;
     public static MethodInfo StringStartsWith = typeof(string).GetMethod("StartsWith", [typeof(string)])!;
-    public static MethodInfo StringIndexOfComparison = typeof(string).GetMethod("IndexOf", [typeof(string), typeof(StringComparison)])!;
     public static MethodInfo StringIndexOf = typeof(string).GetMethod("IndexOf", [typeof(string)])!;
-    public static MethodInfo StringEndsWithComparison = typeof(string).GetMethod("EndsWith", [typeof(string), typeof(StringComparison)])!;
     public static MethodInfo StringEndsWith = typeof(string).GetMethod("EndsWith", [typeof(string)])!;
 
     static ReflectionCache()

src/GraphQL.EntityFramework/Where/WhereValidator.cs

@@ -1,6 +1,6 @@
 static class WhereValidator
 {
-    public static void ValidateObject(Type propertyType, Comparison comparison, StringComparison? @case)
+    public static void ValidateObject(Type propertyType, Comparison comparison)
     {
         if (comparison is
             Comparison.Contains or
@@ -10,23 +10,18 @@ Comparison.EndsWith or
         {
             throw new($"Cannot perform {comparison} on {propertyType.FullName}.");
         }
-
-        if (@case is not null)
-        {
-            throw new($"Cannot use {nameof(StringComparison)} when comparing {propertyType.FullName}.");
-        }
     }
 
-    public static void ValidateSingleObject(Type propertyType, Comparison comparison, StringComparison? @case)
+    public static void ValidateSingleObject(Type propertyType, Comparison comparison)
     {
-        ValidateObject(propertyType, comparison, @case);
+        ValidateObject(propertyType, comparison);
         if (comparison == Comparison.In)
         {
             throw new($"Cannot perform {comparison} on {propertyType.FullName}.");
         }
     }
 
-    public static void ValidateString(Comparison comparison, StringComparison? @case)
+    public static void ValidateString(Comparison comparison)
     {
         if (comparison is
             Comparison.GreaterThan or
@@ -36,16 +31,11 @@ Comparison.LessThanOrEqual or
         {
             throw new($"Cannot perform {comparison} on a String.");
         }
-
-        if (comparison == Comparison.Like && @case is not null)
-        {
-            throw new($"{nameof(Comparison.Like)} is not compatible with {nameof(StringComparison)}.");
-        }
     }
 
-    public static void ValidateSingleString(Comparison comparison, StringComparison? @case)
+    public static void ValidateSingleString(Comparison comparison)
     {
-        ValidateString(comparison, @case);
+        ValidateString(comparison);
         if (comparison == Comparison.In)
         {
             throw new($"Cannot perform {comparison} on a single String.");