From 96e50146420cf364230a4c1c4e6d107e6d6f7ae6 Mon Sep 17 00:00:00 2001 From: Simon Cropp Date: Wed, 16 Apr 2025 16:03:13 +1000 Subject: [PATCH 1/4] remove StringComparison support --- .../Where/ExpressionBuilder.cs | 114 ++++++------------ .../Where/Graphs/StringComparisonGraph.cs | 14 --- .../Where/Graphs/WhereExpression.cs | 1 - .../Where/Graphs/WhereExpressionGraph.cs | 1 - .../Where/ReflectionCache.cs | 4 - .../Where/WhereValidator.cs | 22 +--- .../SchemaPrint.Print.verified.txt | 10 -- src/Tests/ExpressionBuilderTests.cs | 12 +- .../IntegrationTests.SchemaPrint.verified.txt | 10 -- .../MappingTests.SchemaPrint.verified.txt | 10 -- 10 files changed, 50 insertions(+), 148 deletions(-) delete mode 100644 src/GraphQL.EntityFramework/Where/Graphs/StringComparisonGraph.cs diff --git a/src/GraphQL.EntityFramework/Where/ExpressionBuilder.cs b/src/GraphQL.EntityFramework/Where/ExpressionBuilder.cs index d8b16762b..f9f85f111 100644 --- a/src/GraphQL.EntityFramework/Where/ExpressionBuilder.cs +++ b/src/GraphQL.EntityFramework/Where/ExpressionBuilder.cs @@ -40,7 +40,7 @@ static Expression MakePredicateBody(IReadOnlyCollection 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,15 +65,15 @@ static Expression MakePredicateBody(IReadOnlyCollection wheres) /// /// Create a single predicate for the single set of supplied conditional arguments /// - public static Expression> BuildPredicate(string path, Comparison comparison, string?[]? values, bool negate = false, StringComparison? stringComparison = null) + public static Expression> 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.SourceParameter; return Expression.Lambda>(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; @@ -81,13 +81,13 @@ static Expression MakePredicateBody(string path, Comparison comparison, string?[ 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.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 prope return Expression.Call(constant, property.ListContains, property.Left); } - static Expression MakeStringListInComparison(string[] values, Property property, StringComparison? comparison) + static Expression MakeStringListInComparison(string[] values, Property 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>(equalsBody, ExpressionCache.StringParam); @@ -233,55 +221,31 @@ static Expression MakeStringListInComparison(string[] values, Property proper return Expression.Call(null, ReflectionCache.StringAny, Expression.Constant(values), itemEvaluate); } - static Expression MakeSingleStringComparison(Comparison comparison, string? value, Property property, StringComparison? stringComparison) + static Expression MakeSingleStringComparison(Comparison comparison, string? value, Property 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}'."); diff --git a/src/GraphQL.EntityFramework/Where/Graphs/StringComparisonGraph.cs b/src/GraphQL.EntityFramework/Where/Graphs/StringComparisonGraph.cs deleted file mode 100644 index fedf2a9f1..000000000 --- a/src/GraphQL.EntityFramework/Where/Graphs/StringComparisonGraph.cs +++ /dev/null @@ -1,14 +0,0 @@ -class StringComparisonGraph : - EnumerationGraphType -{ - public StringComparisonGraph() - { - Name = nameof(StringComparison); - Add("currentCulture", StringComparison.CurrentCulture); - Add("currentCultureIgnoreCase", StringComparison.CurrentCultureIgnoreCase); - Add("invariantCulture", StringComparison.InvariantCulture); - Add("invariantCultureIgnoreCase", StringComparison.InvariantCultureIgnoreCase); - Add("ordinal", StringComparison.Ordinal); - Add("ordinalIgnoreCase", StringComparison.OrdinalIgnoreCase); - } -} diff --git a/src/GraphQL.EntityFramework/Where/Graphs/WhereExpression.cs b/src/GraphQL.EntityFramework/Where/Graphs/WhereExpression.cs index be5d3328b..f3c7a8552 100644 --- a/src/GraphQL.EntityFramework/Where/Graphs/WhereExpression.cs +++ b/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; diff --git a/src/GraphQL.EntityFramework/Where/Graphs/WhereExpressionGraph.cs b/src/GraphQL.EntityFramework/Where/Graphs/WhereExpressionGraph.cs index 3e32b0e67..8c502699b 100644 --- a/src/GraphQL.EntityFramework/Where/Graphs/WhereExpressionGraph.cs +++ b/src/GraphQL.EntityFramework/Where/Graphs/WhereExpressionGraph.cs @@ -9,7 +9,6 @@ public WhereExpressionGraph() Field(_ => _.Path, true); Field("comparison"); Field(_ => _.Negate, true); - Field>("case"); Field(_ => _.Value, true); Field("connector"); Field>("GroupedExpressions"); diff --git a/src/GraphQL.EntityFramework/Where/ReflectionCache.cs b/src/GraphQL.EntityFramework/Where/ReflectionCache.cs index 34c94d964..4ed769417 100644 --- a/src/GraphQL.EntityFramework/Where/ReflectionCache.cs +++ b/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() diff --git a/src/GraphQL.EntityFramework/Where/WhereValidator.cs b/src/GraphQL.EntityFramework/Where/WhereValidator.cs index 32e9d4e67..0eef460eb 100644 --- a/src/GraphQL.EntityFramework/Where/WhereValidator.cs +++ b/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."); diff --git a/src/SampleWeb.Tests/SchemaPrint.Print.verified.txt b/src/SampleWeb.Tests/SchemaPrint.Print.verified.txt index 5893cfc7e..198693e5c 100644 --- a/src/SampleWeb.Tests/SchemaPrint.Print.verified.txt +++ b/src/SampleWeb.Tests/SchemaPrint.Print.verified.txt @@ -69,7 +69,6 @@ input WhereExpression { path: String comparison: Comparison negate: Boolean - case: StringComparison value: [String] connector: Connector groupedExpressions: [WhereExpression] @@ -91,15 +90,6 @@ enum Comparison { startsWith } -enum StringComparison { - CURRENT_CULTURE - CURRENT_CULTURE_IGNORE_CASE - INVARIANT_CULTURE - INVARIANT_CULTURE_IGNORE_CASE - ORDINAL - ORDINAL_IGNORE_CASE -} - enum Connector { and or diff --git a/src/Tests/ExpressionBuilderTests.cs b/src/Tests/ExpressionBuilderTests.cs index af95e8514..745200c8b 100644 --- a/src/Tests/ExpressionBuilderTests.cs +++ b/src/Tests/ExpressionBuilderTests.cs @@ -444,8 +444,7 @@ public class TargetWithField [InlineData("Name", Comparison.Contains, "son 2", "Person 2")] [InlineData("Name", Comparison.StartsWith, "Person 2", "Person 2")] [InlineData("Name", Comparison.EndsWith, "son 2", "Person 2")] - [InlineData("Name", Comparison.EndsWith, "person 2", "Person 2", false, StringComparison.OrdinalIgnoreCase)] - [InlineData("Age", Comparison.Equal, "13", "Person 2")] + [InlineData("Name", Comparison.EndsWith, "person 2", "Person 2", false)] [InlineData("Age", Comparison.Equal, "13", "Person 2")] [InlineData("Age", Comparison.GreaterThan, "12", "Person 2")] [InlineData("Age", Comparison.Equal, "12", "Person 2", true)] [InlineData("Age", Comparison.GreaterThanOrEqual, "13", "Person 2")] @@ -453,7 +452,7 @@ public class TargetWithField [InlineData("Age", Comparison.LessThanOrEqual, "12", "Person 1")] [InlineData("DateOfBirth", Comparison.Equal, "2001-10-10T10:10:10+00:00", "Person 1")] [InlineData("DateOfBirth.Day", Comparison.Equal, "11", "Person 2")] - public void Combos(string name, Comparison expression, string value, string expectedName, bool negate = false, StringComparison? stringComparison = null) + public void Combos(string name, Comparison expression, string value, string expectedName, bool negate = false) { var people = new List { @@ -473,7 +472,7 @@ public void Combos(string name, Comparison expression, string value, string expe var result = people .AsQueryable() - .Where(ExpressionBuilder.BuildPredicate(name, expression, [value], negate, stringComparison)) + .Where(ExpressionBuilder.BuildPredicate(name, expression, [value], negate)) .Single(); Assert.Equal(expectedName, result.Name); } @@ -489,7 +488,6 @@ public void Combos(string name, Comparison expression, string value, string expe [InlineData("Employees[Name]", Comparison.Contains, "son 2", "Company 1")] [InlineData("Employees[Name]", Comparison.StartsWith, "Person 2", "Company 1")] [InlineData("Employees[Name]", Comparison.EndsWith, "son 2", "Company 1")] - [InlineData("Employees[Name]", Comparison.EndsWith, "person 2", "Company 1", false, StringComparison.OrdinalIgnoreCase)] [InlineData("Employees[Age]", Comparison.Equal, "12", "Company 1")] [InlineData("Employees[Age]", Comparison.GreaterThan, "12", "Company 2")] [InlineData("Employees[Age]", Comparison.Equal, "12", "Company 2", true)] @@ -499,7 +497,7 @@ public void Combos(string name, Comparison expression, string value, string expe [InlineData("Employees[DateOfBirth]", Comparison.Equal, "2001-10-10T10:10:10+00:00", "Company 1")] [InlineData("Employees[DateOfBirth.Day]", Comparison.Equal, "11", "Company 2")] [InlineData("Employees[Company.Employees[Name]]", Comparison.Contains, "son 2", "Company 1")] - public void ListMemberQueryCombos(string name, Comparison expression, string value, string expectedName, bool negate = false, StringComparison? stringComparison = null) + public void ListMemberQueryCombos(string name, Comparison expression, string value, string expectedName, bool negate = false) { var companies = new List { @@ -560,7 +558,7 @@ public void ListMemberQueryCombos(string name, Comparison expression, string val var result = companies .AsQueryable() - .Where(ExpressionBuilder.BuildPredicate(name, expression, [value], negate, stringComparison)) + .Where(ExpressionBuilder.BuildPredicate(name, expression, [value], negate)) .Single(); Assert.Equal(expectedName, result.Name); } diff --git a/src/Tests/IntegrationTests/IntegrationTests.SchemaPrint.verified.txt b/src/Tests/IntegrationTests/IntegrationTests.SchemaPrint.verified.txt index 234f72014..ffc66aea0 100644 --- a/src/Tests/IntegrationTests/IntegrationTests.SchemaPrint.verified.txt +++ b/src/Tests/IntegrationTests/IntegrationTests.SchemaPrint.verified.txt @@ -103,7 +103,6 @@ input WhereExpression { path: String comparison: Comparison negate: Boolean - case: StringComparison value: [String] connector: Connector groupedExpressions: [WhereExpression] @@ -125,15 +124,6 @@ enum Comparison { startsWith } -enum StringComparison { - CURRENT_CULTURE - CURRENT_CULTURE_IGNORE_CASE - INVARIANT_CULTURE - INVARIANT_CULTURE_IGNORE_CASE - ORDINAL - ORDINAL_IGNORE_CASE -} - enum Connector { and or diff --git a/src/Tests/Mapping/MappingTests.SchemaPrint.verified.txt b/src/Tests/Mapping/MappingTests.SchemaPrint.verified.txt index 8bd519747..3735acd1f 100644 --- a/src/Tests/Mapping/MappingTests.SchemaPrint.verified.txt +++ b/src/Tests/Mapping/MappingTests.SchemaPrint.verified.txt @@ -30,7 +30,6 @@ input WhereExpression { path: String comparison: Comparison negate: Boolean - case: StringComparison value: [String] connector: Connector groupedExpressions: [WhereExpression] @@ -52,15 +51,6 @@ enum Comparison { startsWith } -enum StringComparison { - CURRENT_CULTURE - CURRENT_CULTURE_IGNORE_CASE - INVARIANT_CULTURE - INVARIANT_CULTURE_IGNORE_CASE - ORDINAL - ORDINAL_IGNORE_CASE -} - enum Connector { and or From 3ef263719e77c1afed2deb888be6e99c5f7d7f0f Mon Sep 17 00:00:00 2001 From: Simon Cropp Date: Wed, 16 Apr 2025 16:05:46 +1000 Subject: [PATCH 2/4] . --- docs/mdsource/query-usage.source.md | 19 ------------------- docs/query-usage.md | 19 ------------------- src/GraphQL.EntityFramework.sln | 1 + .../EfGraphQLConventions.cs | 1 - 4 files changed, 1 insertion(+), 39 deletions(-) diff --git a/docs/mdsource/query-usage.source.md b/docs/mdsource/query-usage.source.md index 67a7dd88e..17022442b 100644 --- a/docs/mdsource/query-usage.source.md +++ b/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`: diff --git a/docs/query-usage.md b/docs/query-usage.md index ba3d233ba..c077e3e3a 100644 --- a/docs/query-usage.md +++ b/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`: diff --git a/src/GraphQL.EntityFramework.sln b/src/GraphQL.EntityFramework.sln index 6e34b3d6c..cd50be8d8 100644 --- a/src/GraphQL.EntityFramework.sln +++ b/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}" diff --git a/src/GraphQL.EntityFramework/EfGraphQLConventions.cs b/src/GraphQL.EntityFramework/EfGraphQLConventions.cs index 9e3bf0434..7f6096076 100644 --- a/src/GraphQL.EntityFramework/EfGraphQLConventions.cs +++ b/src/GraphQL.EntityFramework/EfGraphQLConventions.cs @@ -84,7 +84,6 @@ static TDbContext DbContextFromProvider(IServiceProvider provider, I static void RegisterScalarsAndArgs(IServiceCollection services) { - services.AddSingleton>(); services.AddSingleton>(); services.AddSingleton(); services.AddSingleton(); From 399caa2903dd958fdcbf08e2f0a1cc0bd241b007 Mon Sep 17 00:00:00 2001 From: Simon Cropp Date: Wed, 16 Apr 2025 16:05:57 +1000 Subject: [PATCH 3/4] Update Directory.Build.props --- src/Directory.Build.props | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Directory.Build.props b/src/Directory.Build.props index 3a4501dab..9ceb42acf 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -2,7 +2,7 @@ CS1591;NU5104;CS1573;CS9107;NU1608;NU1109 - 30.0.0 + 31.0.0 preview 1.0.0 EntityFrameworkCore, EntityFramework, GraphQL From c4c95a319e6e5a7811ab20c7108d0dd25e9c1a50 Mon Sep 17 00:00:00 2001 From: Simon Cropp Date: Wed, 16 Apr 2025 16:14:13 +1000 Subject: [PATCH 4/4] Update ExpressionBuilderTests.cs --- src/Tests/ExpressionBuilderTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Tests/ExpressionBuilderTests.cs b/src/Tests/ExpressionBuilderTests.cs index 745200c8b..19dcba477 100644 --- a/src/Tests/ExpressionBuilderTests.cs +++ b/src/Tests/ExpressionBuilderTests.cs @@ -444,7 +444,7 @@ public class TargetWithField [InlineData("Name", Comparison.Contains, "son 2", "Person 2")] [InlineData("Name", Comparison.StartsWith, "Person 2", "Person 2")] [InlineData("Name", Comparison.EndsWith, "son 2", "Person 2")] - [InlineData("Name", Comparison.EndsWith, "person 2", "Person 2", false)] [InlineData("Age", Comparison.Equal, "13", "Person 2")] + [InlineData("Age", Comparison.Equal, "13", "Person 2")] [InlineData("Age", Comparison.GreaterThan, "12", "Person 2")] [InlineData("Age", Comparison.Equal, "12", "Person 2", true)] [InlineData("Age", Comparison.GreaterThanOrEqual, "13", "Person 2")]