Fix for issue 131; Introduce NotLike into Ado & InMemory Adapters wit…

…h tests
avatasia · Dec 7, 2011 · 88c23c6 · 88c23c6
1 parent 57006bc
commit 88c23c6
Show file tree

Hide file tree

Showing 6 changed files with 66 additions and 5 deletions.
diff --git a/Simple.Data.Ado/AdoAdapter.cs b/Simple.Data.Ado/AdoAdapter.cs
@@ -436,7 +436,8 @@ public override IEnumerable<IEnumerable<IDictionary<string, object>>> RunQueries
 
         public override bool IsExpressionFunction(string functionName, params object[] args)
         {
-            return functionName.Equals("like", StringComparison.OrdinalIgnoreCase)
+            return (functionName.Equals("like", StringComparison.OrdinalIgnoreCase) ||
+                    functionName.Equals("notlike", StringComparison.OrdinalIgnoreCase))
                    && args.Length == 1
                    && args[0] is string;
         }

diff --git a/Simple.Data.BehaviourTest/FindTest.cs b/Simple.Data.BehaviourTest/FindTest.cs
@@ -187,6 +187,14 @@ public void TestFindWithLike()
             Parameter(0).Is("Foo");
         }
 
+        [Test]
+        public void TestFindWithNotLike()
+        {
+            _db.Users.Find(_db.Users.Name.NotLike("Foo"));
+            GeneratedSqlIs("select " + usersColumns + " from [dbo].[Users] where [dbo].[Users].[name] not like @p1");
+            Parameter(0).Is("Foo");
+        }
+
         [Test]
         public void TestFindAllWithLike()
         {
@@ -195,6 +203,14 @@ public void TestFindAllWithLike()
             Parameter(0).Is("Foo");
         }
 
+        [Test]
+        public void TestFindAllWithNotLike()
+        {
+            _db.Users.FindAll(_db.Users.Name.NotLike("Foo")).ToList();
+            GeneratedSqlIs("select [dbo].[Users].[id],[dbo].[Users].[name],[dbo].[Users].[password],[dbo].[Users].[age] from [dbo].[Users] where [dbo].[Users].[name] not like @p1");
+            Parameter(0).Is("Foo");
+        }
+
         [Test]
         public void TestFindAllByNamedParameterSingleColumn()
         {

diff --git a/Simple.Data.InMemoryTest/InMemoryTests.cs b/Simple.Data.InMemoryTest/InMemoryTests.cs
@@ -59,6 +59,32 @@ public void AllShouldReturnAllRecords()
             Assert.AreEqual(2, records.Count);
         }
 
+        [Test]
+        public void TestFindAllByPartialName()
+        {
+            Database.UseMockAdapter(new InMemoryAdapter());
+            var db = Database.Open();
+            db.Test.Insert(Id: 1, Name: "Alice");
+            db.Test.Insert(Id: 2, Name: "Bob");
+            db.Test.Insert(Id: 2, Name: "Clive");
+            List<dynamic> records = db.Test.FindAll(db.Test.Name.Like("A%")).ToList();
+            Assert.IsNotNull(records);
+            Assert.AreEqual(1, records.Count);
+        }
+
+        [Test]
+        public void TestFindAllByExcludedPartialName()
+        {
+            Database.UseMockAdapter(new InMemoryAdapter());
+            var db = Database.Open();
+            db.Test.Insert(Id: 1, Name: "Alice");
+            db.Test.Insert(Id: 2, Name: "Bob");
+            db.Test.Insert(Id: 2, Name: "Clive");
+            List<dynamic> records = db.Test.FindAll(db.Test.Name.NotLike("A%")).ToList();
+            Assert.IsNotNull(records);
+            Assert.AreEqual(2, records.Count);
+        }
+
         [Test]
         public void SelectShouldReturnSubsetOfColumns()
         {

diff --git a/Simple.Data.SqlTest/FindTests.cs b/Simple.Data.SqlTest/FindTests.cs
@@ -70,6 +70,14 @@ public void TestFindAllByPartialName()
             Assert.AreEqual(1, users.Count());
         }
 
+        [Test]
+        public void TestFindAllByExcludedPartialName()
+        {
+            var db = DatabaseHelper.Open();
+            IEnumerable<User> users = db.Users.FindAll(db.Users.Name.NotLike("Bob")).ToList<User>();
+            Assert.AreEqual(2, users.Count());
+        }
+
         [Test]
         public void TestAllCount()
         {

diff --git a/Simple.Data/InMemoryAdapter.cs b/Simple.Data/InMemoryAdapter.cs
@@ -179,8 +179,10 @@ public override int Delete(string tableName, SimpleExpression criteria)
 
         public override bool IsExpressionFunction(string functionName, params object[] args)
         {
-            return functionName.Equals("like", StringComparison.OrdinalIgnoreCase) && args.Length == 1 &&
-                   args[0] is string;
+            return (functionName.Equals("like", StringComparison.OrdinalIgnoreCase) ||
+                    functionName.Equals("notlike", StringComparison.OrdinalIgnoreCase))
+                   && args.Length == 1
+                   && args[0] is string;
         }
 
         public void SetAutoIncrementColumn(string tableName, string columnName)

diff --git a/Simple.Data/QueryPolyfills/WhereClauseHandler.cs b/Simple.Data/QueryPolyfills/WhereClauseHandler.cs
@@ -34,7 +34,8 @@ private Func<IDictionary<string, object>, bool> FunctionExpressionToWhereClause(
         {
             var function = arg.RightOperand as SimpleFunction;
             if (ReferenceEquals(function, null)) throw new InvalidOperationException("Expression type of function but no function supplied.");
-            if (function.Name.Equals("like", StringComparison.OrdinalIgnoreCase))
+            if (function.Name.Equals("like", StringComparison.OrdinalIgnoreCase) ||
+                function.Name.Equals("notlike", StringComparison.OrdinalIgnoreCase))
             {
                 var pattern = function.Args[0].ToString();
                 if (pattern.Contains("%") || pattern.Contains("_")) // SQL Server LIKE
@@ -44,7 +45,14 @@ private Func<IDictionary<string, object>, bool> FunctionExpressionToWhereClause(
 
                 var regex = new Regex("^" + pattern + "$", RegexOptions.Multiline | RegexOptions.IgnoreCase);
 
-                return d => Resolve(d, arg.LeftOperand).Count > 0 && Resolve(d, arg.LeftOperand).OfType<string>().Any(regex.IsMatch);
+                if (function.Name.Equals("like", StringComparison.OrdinalIgnoreCase))
+                {
+                    return d => Resolve(d, arg.LeftOperand).Count > 0 && Resolve(d, arg.LeftOperand).OfType<string>().Any(regex.IsMatch);
+                }
+                if (function.Name.Equals("notlike", StringComparison.OrdinalIgnoreCase))
+                {
+                    return d => Resolve(d, arg.LeftOperand).Count > 0 && Resolve(d, arg.LeftOperand).OfType<string>().All(input => !regex.IsMatch(input));
+                }
             }
 
             throw new NotSupportedException("Expression Function not supported.");