add null support to query

loresoft · May 19, 2024 · a96aa1b · a96aa1b
1 parent d7abba4
commit a96aa1b
Show file tree

Hide file tree

Showing 6 changed files with 150 additions and 6 deletions.
diff --git a/src/MediatR.CommandQuery/Extensions/QueryExtensions.cs b/src/MediatR.CommandQuery/Extensions/QueryExtensions.cs
@@ -59,6 +59,11 @@ public static IQueryable<T> Filter<T>(this IQueryable<T> query, EntityFilter fil
         if (string.IsNullOrWhiteSpace(predicate))
             return query;
 
-        return query.Where(predicate, parameters);
+        var config = new ParsingConfig
+        {
+            UseParameterizedNamesInDynamicQuery = true,
+        };
+
+        return query.Where(config, predicate, parameters);
     }
 }
diff --git a/src/MediatR.CommandQuery/Queries/EntityFilterOperators.cs b/src/MediatR.CommandQuery/Queries/EntityFilterOperators.cs
@@ -12,4 +12,6 @@ public static class EntityFilterOperators
     public const string GreaterThan = "gt";
     public const string GreaterThanOrEqual = "gte";
     public const string In = "in";
+    public const string IsNull = "IsNull";
+    public const string IsNotNull = "IsNotNull";
 }
diff --git a/src/MediatR.CommandQuery/Queries/LinqExpressionBuilder.cs b/src/MediatR.CommandQuery/Queries/LinqExpressionBuilder.cs
@@ -14,7 +14,15 @@ public class LinqExpressionBuilder
         { EntityFilterOperators.LessThan, "<" },
         { EntityFilterOperators.LessThanOrEqual, "<=" },
         { EntityFilterOperators.GreaterThan, ">" },
-        { EntityFilterOperators.GreaterThanOrEqual, ">=" }
+        { EntityFilterOperators.GreaterThanOrEqual, ">=" },
+        { "equals", "==" },
+        { "not equals", "!=" },
+        { "starts with", EntityFilterOperators.StartsWith },
+        { "ends with", EntityFilterOperators.EndsWith },
+        { "is null", EntityFilterOperators.IsNull },
+        { "is empty", EntityFilterOperators.IsNull },
+        { "is not null", EntityFilterOperators.IsNotNull },
+        { "is not empty", EntityFilterOperators.IsNotNull },
     };
 
     private readonly StringBuilder _expression = new();
@@ -73,26 +81,48 @@ private void WriteExpression(EntityFilter entityFilter)
         var value = entityFilter.Value;
 
         // translate operator
-        var o = string.IsNullOrWhiteSpace(entityFilter.Operator) ? "==" : entityFilter.Operator;
-        _operatorMap.TryGetValue(o, out var comparison);
+        var operatorValue = string.IsNullOrWhiteSpace(entityFilter.Operator) ? "==" : entityFilter.Operator;
+        _operatorMap.TryGetValue(operatorValue, out var comparison);
         if (string.IsNullOrEmpty(comparison))
-            comparison = o.Trim();
+            comparison = operatorValue.Trim();
 
         // use function call
         var negation = comparison.StartsWith("!") || comparison.StartsWith("not", StringComparison.OrdinalIgnoreCase) ? "!" : string.Empty;
 
         if (comparison.EndsWith(EntityFilterOperators.StartsWith, StringComparison.OrdinalIgnoreCase))
+        {
             _expression.Append(negation).Append(name).Append(".StartsWith(@").Append(index).Append(')');
+            _values.Add(value);
+        }
         else if (comparison.EndsWith(EntityFilterOperators.EndsWith, StringComparison.OrdinalIgnoreCase))
+        {
             _expression.Append(negation).Append(name).Append(".EndsWith(@").Append(index).Append(')');
+            _values.Add(value);
+        }
         else if (comparison.EndsWith(EntityFilterOperators.Contains, StringComparison.OrdinalIgnoreCase))
+        {
             _expression.Append(negation).Append(name).Append(".Contains(@").Append(index).Append(')');
+            _values.Add(value);
+        }
+        else if (comparison.EndsWith(EntityFilterOperators.IsNull, StringComparison.OrdinalIgnoreCase))
+        {
+            _expression.Append(name).Append(" == NULL");
+        }
+        else if (comparison.EndsWith(EntityFilterOperators.IsNotNull, StringComparison.OrdinalIgnoreCase))
+        {
+            _expression.Append(name).Append(" != NULL");
+        }
         else if (comparison.EndsWith(EntityFilterOperators.In, StringComparison.OrdinalIgnoreCase))
+        {
             _expression.Append(negation).Append("it.").Append(name).Append(" in @").Append(index);
+            _values.Add(value);
+        }
         else
+        {
             _expression.Append(name).Append(' ').Append(comparison).Append(" @").Append(index);
+            _values.Add(value);
+        }
 
-        _values.Add(value);
     }
 
     private bool WriteGroup(EntityFilter entityFilter)

diff --git a/src/MediatR.CommandQuery/Services/ActivityTimer.cs b/src/MediatR.CommandQuery/Services/ActivityTimer.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Text;
 
 namespace MediatR.CommandQuery.Services;
 

diff --git a/test/MediatR.CommandQuery.EntityFrameworkCore.SqlServer.Tests/Acceptance/PriorityTests.cs b/test/MediatR.CommandQuery.EntityFrameworkCore.SqlServer.Tests/Acceptance/PriorityTests.cs
@@ -83,4 +83,77 @@ public async Task EntityQueryIn()
         listResult.Should().NotBeNull();
         listResult.Total.Should().Be(2);
     }
+
+    [Fact]
+    [Trait("Category", "SqlServer")]
+    public async Task EntityQueryDescriptionNull()
+    {
+        var mediator = ServiceProvider.GetService<IMediator>();
+        mediator.Should().NotBeNull();
+
+        var mapper = ServiceProvider.GetService<IMapper>();
+        mapper.Should().NotBeNull();
+
+        // Query Entity
+        var entityQuery = new EntityQuery
+        {
+            Sort = new List<EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } },
+            Filter = new EntityFilter { Name = "Description", Operator = "IsNull" }
+        };
+        var listQuery = new EntityPagedQuery<PriorityReadModel>(MockPrincipal.Default, entityQuery);
+
+        var listResult = await mediator.Send(listQuery);
+        listResult.Should().NotBeNull();
+    }
+
+    [Fact]
+    [Trait("Category", "SqlServer")]
+    public async Task EntityQueryDescriptionNOtNull()
+    {
+        var mediator = ServiceProvider.GetService<IMediator>();
+        mediator.Should().NotBeNull();
+
+        var mapper = ServiceProvider.GetService<IMapper>();
+        mapper.Should().NotBeNull();
+
+        // Query Entity
+        var entityQuery = new EntityQuery
+        {
+            Sort = new List<EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } },
+            Filter = new EntityFilter { Name = "Description", Operator = "is not null" }
+        };
+        var listQuery = new EntityPagedQuery<PriorityReadModel>(MockPrincipal.Default, entityQuery);
+
+        var listResult = await mediator.Send(listQuery);
+        listResult.Should().NotBeNull();
+    }
+
+
+    [Fact]
+    [Trait("Category", "SqlServer")]
+    public async Task EntityQueryMultipleFilters()
+    {
+        var mediator = ServiceProvider.GetService<IMediator>();
+        mediator.Should().NotBeNull();
+
+        var mapper = ServiceProvider.GetService<IMapper>();
+        mapper.Should().NotBeNull();
+
+        // Query Entity
+        var entityQuery = new EntityQuery
+        {
+            Sort = new List<EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } },
+            Filter = new EntityFilter
+            {
+                Filters = new List<EntityFilter> {
+                    new EntityFilter { Name = "Description", Operator = "is null" },
+                    new EntityFilter { Name = "Name", Operator = "equals", Value = "High" }
+                }
+            }
+        };
+        var listQuery = new EntityPagedQuery<PriorityReadModel>(MockPrincipal.Default, entityQuery);
+
+        var listResult = await mediator.Send(listQuery);
+        listResult.Should().NotBeNull();
+    }
 }
diff --git a/test/MediatR.CommandQuery.Tests/Queries/LinqExpressionBuilderTest.cs b/test/MediatR.CommandQuery.Tests/Queries/LinqExpressionBuilderTest.cs
@@ -118,6 +118,39 @@ public void FilterContains()
         builder.Parameters[0].Should().Be("Berry");
     }
 
+    [Fact]
+    public void FilterIsNull()
+    {
+        var entityFilter = new EntityFilter
+        {
+            Name = "Name",
+            Operator = EntityFilterOperators.IsNull
+        };
+        var builder = new LinqExpressionBuilder();
+        builder.Build(entityFilter);
+
+        builder.Expression.Should().NotBeEmpty();
+        builder.Expression.Should().Be("Name == NULL");
+
+        builder.Parameters.Count.Should().Be(0);
+    }
+
+    [Fact]
+    public void FilterIsNotNull()
+    {
+        var entityFilter = new EntityFilter
+        {
+            Name = "Name",
+            Operator = EntityFilterOperators.IsNotNull
+        };
+        var builder = new LinqExpressionBuilder();
+        builder.Build(entityFilter);
+
+        builder.Expression.Should().NotBeEmpty();
+        builder.Expression.Should().Be("Name != NULL");
+
+        builder.Parameters.Count.Should().Be(0);
+    }
 
     [Fact]
     public void FilterIn()