now performing joins for where clauses

Author: Daniel Townsend

piccolo/columns/base.py

@@ -75,8 +75,31 @@ def __ne__(self, value) -> Where:  # type: ignore
     def __hash__(self):
         return hash(self._name)
 
+    def get_full_name(self, just_alias=False) -> str:
+        """
+        Returns the full column name, taking into account joins.
+        """
+        column_name = self._name
+
+        if not self.call_chain:
+            return f"{self.table.Meta.tablename}.{column_name}"
+
+        column_name = (
+            "$".join([i._name for i in self.call_chain])
+            + f"${column_name}"
+        )
+
+        alias = f"{self.call_chain[-1].table_alias}.{self._name}"
+        if just_alias:
+            return alias
+        else:
+            return f'{alias} AS "{column_name}"'
+
     @property
     def querystring(self) -> QueryString:
+        """
+        Used when creating tables.
+        """
         name = getattr(self, '_name', '')
         column_type = getattr(
             self,

piccolo/columns/combination.py

@@ -77,7 +77,7 @@ def querystring(self) -> QueryString:
 
         # TODO Want something cleaner than this.
         template = self.operator.template.format(
-            name=self.column._name,
+            name=self.column.get_full_name(just_alias=True),
             value='{}',
             values='{}'
         )

piccolo/query/methods/select.py

@@ -82,34 +82,21 @@ def querystring(self) -> QueryString:
         if len(self.selected_columns) == 0:
             columns_str = "*"
         else:
-            ###################################################################
-            # JOIN
-
-            self.check_valid_call_chain(self.selected_columns)
-
-            joins = self.get_joins(self.selected_columns)
-
-            ###################################################################
-
-            column_names: t.List[str] = []
-            for column in self.selected_columns:
-                column_name = column._name
+            column_names: t.List[str] = [
+                c.get_full_name() for c in self.selected_columns
+            ]
+            columns_str = ", ".join(column_names)
 
-                if not column.call_chain:
-                    column_names.append(
-                        f"{self.table.Meta.tablename}.{column_name}"
-                    )
-                    continue
+        #######################################################################
+        # JOIN
 
-                column_name = (
-                    "$".join([i._name for i in column.call_chain])
-                    + f"${column_name}"
-                )
+        self.check_valid_call_chain(self.selected_columns)
 
-                alias = f"{column.call_chain[-1].table_alias}.{column._name}"
-                column_names.append(f'{alias} AS "{column_name}"')
+        select_joins = self.get_joins(self.selected_columns)
+        where_joins = self.get_joins(self.get_where_columns())
 
-            columns_str = ", ".join(column_names)
+        # Combine all joins, and remove duplicates
+        joins = list(OrderedDict.fromkeys(select_joins + where_joins))
 
         #######################################################################
 

piccolo/query/mixins.py

@@ -2,7 +2,7 @@
 import dataclasses
 import typing as t
 
-from piccolo.columns import And, Column
+from piccolo.columns import And, Column, Where, Or
 from piccolo.custom_types import Combinable
 from piccolo.querystring import QueryString
 
@@ -56,6 +56,23 @@ class WhereMixin():
     def __init__(self):
         super().__init__()
         self._where: t.Optional[Combinable] = []
+        self._where_columns: t.List[Column] = []
+
+    def get_where_columns(self):
+        """
+        Retrieves all columns used in the where clause - in case joins are
+        needed.
+        """
+        self._where_columns = []
+        self.extract_columns(self._where)
+        return self._where_columns
+
+    def extract_columns(self, combinable: Combinable):
+        if isinstance(combinable, Where):
+            self._where_columns.append(combinable.column)
+        elif isinstance(combinable, And) or isinstance(combinable, Or):
+            self.extract_columns(combinable.first)
+            self.extract_columns(combinable.second)
 
     def where(self, where: Combinable):
         if self._where: