Merge pull request piccolo-orm#119 from piccolo-orm/improved_where_clause

the `where` clause can now accept `Table` instances

Author: dantownsend

piccolo/columns/combination.py

@@ -6,8 +6,8 @@
 from piccolo.custom_types import Combinable, Iterable
 from piccolo.querystring import QueryString
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    from piccolo.columns.base import Column  # noqa
+if t.TYPE_CHECKING:
+    from piccolo.columns.base import Column
 
 
 class CombinableMixin(object):
@@ -92,10 +92,43 @@ def __init__(
         omitted, vs None, which is a valid value for a where clause.
         """
         self.column = column
-        self.value = value
-        self.values = values
+        self.value = self.clean_value(value)
+
+        if values == UNDEFINED:
+            self.values = values
+        else:
+            self.values = [self.clean_value(i) for i in values]  # type: ignore
+
         self.operator = operator
 
+    def clean_value(self, value: t.Any) -> t.Any:
+        """
+        If a where clause contains a Table instance, we should convert that
+        to a column reference. For example:
+
+        .. code-block:: python
+
+            manager = Manager.objects.where(
+                Manager.name == 'Guido'
+            ).first().run_sync()
+
+            # The where clause should be:
+            Band.select().where(Band.manager.id == guido.id).run_sync()
+            # Or
+            Band.select().where(Band.manager == guido.id).run_sync()
+
+            # If the object is passed in, i.e. `guido` instead of `guido.id`,
+            # it should still work.
+            Band.select().where(Band.manager == guido).run_sync()
+
+        """
+        from piccolo.table import Table
+
+        if isinstance(value, Table):
+            return value.id
+        else:
+            return value
+
     @property
     def values_querystring(self) -> QueryString:
         if isinstance(self.values, Undefined):

tests/table/test_select.py

@@ -5,7 +5,7 @@
 from piccolo.query.methods.select import Count
 
 from ..base import DBTestCase, postgres_only, sqlite_only
-from ..example_app.tables import Band, Concert
+from ..example_app.tables import Band, Concert, Manager
 
 
 class TestSelect(DBTestCase):
@@ -28,6 +28,30 @@ def test_query_some_columns(self):
 
         self.assertDictEqual(response[0], {"name": "Pythonistas"})
 
+    def test_where_equals(self):
+        self.insert_row()
+
+        manager = Manager.objects().first().run_sync()
+
+        # This is the recommended way of running these types of queries:
+        response = (
+            Band.select(Band.name)
+            .where(Band.manager.id == manager.id)
+            .run_sync()
+        )
+        self.assertEqual(response, [{"name": "Pythonistas"}])
+
+        # Other cases which should work:
+        response = (
+            Band.select(Band.name).where(Band.manager == manager).run_sync()
+        )
+        self.assertEqual(response, [{"name": "Pythonistas"}])
+
+        response = (
+            Band.select(Band.name).where(Band.manager.id == manager).run_sync()
+        )
+        self.assertEqual(response, [{"name": "Pythonistas"}])
+
     def test_where_like(self):
         self.insert_rows()