multiple arguments in WHERE clause (piccolo-orm#244)

* WHERE clause now will support multiple arguments(and empty clause) based on discussion piccolo-orm#237

* updated Docs

Author: AliSayyah

docs/src/piccolo/query_clauses/where.rst

@@ -191,6 +191,21 @@ Using multiple ``where`` clauses is equivalent to an AND.
         b.popularity < 1000
     ).run_sync()
 
+Also, multiple arguments inside ``where`` clause is equivalent to an AND.
+
+.. code-block:: python
+
+    b = Band
+
+    # These are equivalent:
+    b.select().where(
+        (b.popularity >= 100) & (b.popularity < 1000)
+    ).run_sync()
+
+    b.select().where(
+        b.popularity >= 100, b.popularity < 1000
+    ).run_sync()
+
 Using And / Or directly
 ~~~~~~~~~~~~~~~~~~~~~~~
 

piccolo/query/methods/count.py

@@ -20,8 +20,8 @@ def __init__(self, table: t.Type[Table], **kwargs):
         super().__init__(table, **kwargs)
         self.where_delegate = WhereDelegate()
 
-    def where(self, where: Combinable) -> Count:
-        self.where_delegate.where(where)
+    def where(self, *where: Combinable) -> Count:
+        self.where_delegate.where(*where)
         return self
 
     async def response_handler(self, response) -> bool:

piccolo/query/methods/delete.py

@@ -24,8 +24,8 @@ def __init__(self, table: t.Type[Table], force: bool = False, **kwargs):
         self.force = force
         self.where_delegate = WhereDelegate()
 
-    def where(self, where: Combinable) -> Delete:
-        self.where_delegate.where(where)
+    def where(self, *where: Combinable) -> Delete:
+        self.where_delegate.where(*where)
         return self
 
     def _validate(self):

piccolo/query/methods/exists.py

@@ -21,8 +21,8 @@ def __init__(self, table: t.Type[Table], **kwargs):
         super().__init__(table, **kwargs)
         self.where_delegate = WhereDelegate()
 
-    def where(self, where: Combinable) -> Exists:
-        self.where_delegate.where(where)
+    def where(self, *where: Combinable) -> Exists:
+        self.where_delegate.where(*where)
         return self
 
     async def response_handler(self, response) -> bool:

piccolo/query/methods/objects.py

@@ -155,8 +155,8 @@ def order_by(self, *columns: Column, ascending=True) -> Objects:
         self.order_by_delegate.order_by(*columns, ascending=ascending)
         return self
 
-    def where(self, where: Combinable) -> Objects:
-        self.where_delegate.where(where)
+    def where(self, *where: Combinable) -> Objects:
+        self.where_delegate.where(*where)
         return self
 
     async def batch(

piccolo/query/methods/select.py

@@ -246,8 +246,8 @@ def output(
         )
         return self
 
-    def where(self, where: Combinable) -> Select:
-        self.where_delegate.where(where)
+    def where(self, *where: Combinable) -> Select:
+        self.where_delegate.where(*where)
         return self
 
     async def batch(

piccolo/query/methods/update.py

@@ -30,8 +30,8 @@ def values(
         self.values_delegate.values(values)
         return self
 
-    def where(self, where: Combinable) -> Update:
-        self.where_delegate.where(where)
+    def where(self, *where: Combinable) -> Update:
+        self.where_delegate.where(*where)
         return self
 
     def validate(self):

piccolo/query/mixins.py

@@ -113,11 +113,12 @@ def _extract_columns(self, combinable: Combinable):
             self._extract_columns(combinable.first)
             self._extract_columns(combinable.second)
 
-    def where(self, where: Combinable):
-        if self._where:
-            self._where = And(self._where, where)
-        else:
-            self._where = where
+    def where(self, *where: Combinable):
+        for arg in where:
+            if self._where:
+                self._where = And(self._where, arg)
+            else:
+                self._where = arg
 
 
 @dataclass

tests/table/test_select.py

@@ -63,6 +63,18 @@ def test_where_equals(self):
         )
         self.assertEqual(response, [{"name": "Pythonistas"}])
 
+        # check multiple arguments inside WHERE clause
+        response = (
+            Band.select(Band.name)
+            .where(Band.manager.id == 1, Band.popularity == 500)
+            .run_sync()
+        )
+        self.assertEqual(response, [])
+
+        # check empty WHERE clause
+        response = Band.select(Band.name).where().run_sync()
+        self.assertEqual(response, [{"name": "Pythonistas"}])
+
     @postgres_only
     def test_where_like_postgres(self):
         """
@@ -148,7 +160,6 @@ def test_where_ilike_sqlite(self):
             "%ist%",
             "%IST%",
         ):
-
             self.assertEqual(
                 Band.select(Band.name)
                 .where(Band.name.ilike(ilike_query))