Fix two failures in Not processing in expressions

Fix edge case in 'Not' processing, introduced with the other 'not' fix

Author: rhuijben

RepoDb.Core/RepoDb.Tests/RepoDb.UnitTests/Equalities/QueryGroupEqualityTest.cs

@@ -1,8 +1,8 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using RepoDb.Enumerations;
 using RepoDb.Extensions;
-using System.Collections;
-using System.Collections.Generic;
 
 namespace RepoDb.UnitTests.Equalities
 {
@@ -128,6 +128,22 @@ public void TestQueryGroupHashCodeEqualityForCollidedExpressions()
 
             // Assert
             Assert.IsFalse(equal);
+            Assert.AreEqual(objA.QueryGroups.Count, objB.QueryGroups.Count);
+        }
+
+        [TestMethod]
+        public void TestQueryGroupHashCodeEqualityForCollidedExpressions2()
+        {
+            // Prepare
+            var objA = QueryGroup.Parse<EntityClass>(c => c.Id == 1 && !(c.Value != 1));
+            var objB = QueryGroup.Parse<EntityClass>(c => c.Id != 1 && c.Value == 1);
+
+            // Act
+            var equal = (objA.GetHashCode() == objB.GetHashCode());
+
+            // Assert
+            Assert.IsFalse(equal);
+            Assert.AreEqual(objA.QueryGroups?.Count, objB.QueryGroups?.Count);
         }
 
         [TestMethod]

RepoDb.Core/RepoDb/QueryGroup/ParseExpression.cs

@@ -1,8 +1,8 @@
-using RepoDb.Enumerations;
-using RepoDb.Extensions;
-using System;
+using System;
 using System.Linq;
 using System.Linq.Expressions;
+using RepoDb.Enumerations;
+using RepoDb.Extensions;
 
 namespace RepoDb
 {
@@ -145,12 +145,24 @@ private static QueryGroup Parse<TEntity>(BinaryExpression expression)
         private static QueryGroup Parse<TEntity>(UnaryExpression expression)
             where TEntity : class
         {
-            return expression.Operand switch
+            if (expression.NodeType == ExpressionType.Not || expression.NodeType == ExpressionType.Convert)
             {
-                MemberExpression memberExpression => Parse<TEntity>(memberExpression, expression.NodeType),
-                MethodCallExpression methodCallExpression => Parse<TEntity>(methodCallExpression, expression.NodeType),
-                _ => null
-            };
+                // These two handle
+                if (expression.Operand is MemberExpression memberExpression && Parse<TEntity>(memberExpression, expression.NodeType) is { } r1)
+                    return r1;
+                else if (expression.Operand is MethodCallExpression methodCallExpression && Parse<TEntity>(methodCallExpression, expression.NodeType) is { } r2)
+                    return r2;
+            }
+
+            if (Parse<TEntity>(expression.Operand) is { } r)
+            {
+                // Wrap result in A NOT expression
+                return new QueryGroup(r, true);
+            }
+            else
+            {
+                throw new NotSupportedException($"Unary operation '{expression.NodeType}' is currently not supported.");
+            }
         }
 
         /*

RepoDb.Core/RepoDb/Reflection/Compiler/Options.cs renamed to RepoDb.Core/RepoDb/Reflection/Compiler/Compiler.Options.cs

@@ -88,6 +88,55 @@ await connection.InsertAllAsync(
             Assert.IsTrue((await connection.QueryAsync<DateOnlyTestData>(where: x => x.DateOnlyNullable == new DateOnly(2026, 1, 1), transaction: t)).Count() == 1);
         }
 
+        [TestMethod]
+        public async Task CompareValuesTests()
+        {
+            await using var connection = new SqlConnection(Database.ConnectionString);
+            await connection.OpenAsync();
+            await using var t = await connection.BeginTransactionAsync();
+
+            await connection.InsertAllAsync(
+                new DateOnlyTestData[] {
+                    new()
+                    {
+                        DateOnly = new DateOnly(2024,1,1),
+                        DateOnlyNullable = null,
+                    },
+                    new ()
+                    {
+                        DateOnly = new DateOnly(2025,1,1),
+                        DateOnlyNullable = new DateOnly(2026,1,1),
+                    }
+                },
+                transaction: t);
+
+
+            // This one used to fail with NotSupportedException as '!' was not interpreted correctly
+            var notEqualValue = new DateOnly(2024, 1, 1);
+            var n = await connection.UpdateAsync<DateOnlyTestData>(
+                new()
+                {
+                    DateOnly = new DateOnly(2027, 1, 1)
+                },
+                where: QueryGroup.Parse<DateOnlyTestData>(x => !(x.DateOnly == notEqualValue)),
+                fields: Field.Parse<DateOnlyTestData>(x => x.DateOnly),
+                transaction: t);
+
+            Assert.AreEqual(1, n);
+
+            // This one used to fail by silently ignoring the '!(x.DateOnlyNullable == notEqualValue2)' part
+            var notEqualValue2 = new DateOnly(2029, 1, 1);
+            var n2 = await connection.UpdateAsync<DateOnlyTestData>(
+                new()
+                {
+                    DateOnly = new DateOnly(2030, 1, 1)
+                },
+                where: QueryGroup.Parse<DateOnlyTestData>(x => x.DateOnlyNullable == null || !(x.DateOnlyNullable == notEqualValue2)),
+                fields: Field.Parse<DateOnlyTestData>(x => x.DateOnly),
+                transaction: t);
+            Assert.AreEqual(2, n2);
+        }
+
 
 
         public class DateOnlyTestData