allow like clauses without wildcards (piccolo-orm#192)

It previously wasn't possible to do a LIKE clause with no wildcards. So if you just wanted to match on 'FOO', 'Foo', and 'foo', and not 'foo bar' or 'baz foo'.

Author: dantownsend

docs/src/piccolo/query_clauses/where.rst

@@ -72,7 +72,11 @@ The percentage operator is required to designate where the match should occur.
         b.name.like('%is%')  # Matches anywhere in string
     ).run_sync()
 
-``ilike`` is identical, except it's case insensitive.
+    b.select().where(
+        b.name.like('Pythonistas')  # Matches the entire string
+    ).run_sync()
+
+``ilike`` is identical, except it's Postgres specific and case insensitive.
 
 -------------------------------------------------------------------------------
 

piccolo/columns/base.py

@@ -424,25 +424,38 @@ def not_in(self, values: t.List[t.Any]) -> Where:
         return Where(column=self, values=values, operator=NotIn)
 
     def like(self, value: str) -> Where:
-        if "%" not in value:
-            raise ValueError("% is required for like operators")
+        """
+        Both SQLite and Postgres support LIKE, but they mean different things.
+
+        In Postgres, LIKE is case sensitive (i.e. 'foo' equals 'foo', but
+        'foo' doesn't equal 'Foo').
+
+        In SQLite, LIKE is case insensitive for ASCII characters
+        (i.e. 'foo' equals 'Foo'). But not for non-ASCII characters. To learn
+        more, see the docs:
+
+        https://sqlite.org/lang_expr.html#the_like_glob_regexp_and_match_operators
+
+        """
         return Where(column=self, value=value, operator=Like)
 
     def ilike(self, value: str) -> Where:
-        if "%" not in value:
-            raise ValueError("% is required for ilike operators")
+        """
+        Only Postgres supports ILIKE. It's used for case insensitive matching.
+
+        For SQLite, it's just proxied to a LIKE query instead.
+
+        """
         if self._meta.engine_type == "postgres":
             operator: t.Type[ComparisonOperator] = ILike
         else:
             colored_warning(
-                "SQLite doesn't support ILIKE currently, falling back to LIKE."
+                "SQLite doesn't support ILIKE, falling back to LIKE."
             )
             operator = Like
         return Where(column=self, value=value, operator=operator)
 
     def not_like(self, value: str) -> Where:
-        if "%" not in value:
-            raise ValueError("% is required for like operators")
         return Where(column=self, value=value, operator=NotLike)
 
     def __lt__(self, value) -> Where:

tests/columns/test_base.py

@@ -10,25 +10,6 @@ class MyTable(Table):
     name = Varchar()
 
 
-class TestColumn(TestCase):
-    def test_like_raises(self):
-        """
-        Make sure an invalid 'like' argument raises an exception. Should
-        contain a % symbol.
-        """
-        column = MyTable.name
-        with self.assertRaises(ValueError):
-            column.like("guido")
-
-        with self.assertRaises(ValueError):
-            column.ilike("guido")
-
-        # Make sure valid args don't raise an exception.
-        for arg in ["%guido", "guido%", "%guido%"]:
-            column.like("%foo")
-            column.ilike("foo%")
-
-
 class TestCopy(TestCase):
     def test_copy(self):
         """