ormlambda 3.11.2__tar.gz → 3.12.2__tar.gz

{ormlambda-3.11.2 → ormlambda-3.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ormlambda
-Version: 3.11.2
+Version: 3.12.2
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com
@@ -316,7 +316,7 @@ res = AddressModel.count(Address.address_id, execute=True)
 
 The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
 
-#### Usage
+### Usage
 
 ```python
 response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
@@ -347,6 +347,60 @@ As you can see in the response, the result is a dictionary where the keys are a
 
 Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
 
+
+## 2. Group by
+
+The `groupby` method is used to filter results based on aggregate functions.
+
+### Usage
+```python
+from ormlambda import Column, ORM, create_engine
+from test.config import DATABASE_URL
+
+
+class Response(BaseModel):
+    district: str
+    count: int
+
+engine= create_engine(DATABASE_URL)
+model = ORM(Address,engine)
+
+count_name = Column(column_name="count")
+
+res = (
+    self.model
+    .groupby(Address.district)
+    .select(
+        (
+            Address.district,
+            self.model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+## 3. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+### Usage
+```python
+res = (
+    model
+    .groupby(Address.district)
+    .having(count_name > 4)
+    .select(
+        (
+            Address.district,
+            model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+
 ## Using BaseModel for Custom Responses (Pydantic)
 
 You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
@@ -391,14 +445,6 @@ print(select.city)
 print(select.country)
 ```
 
-
-<!-- ### 2. Having
-
-The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
-
-#### Usage -->
-
-
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python

{ormlambda-3.11.2 → ormlambda-3.12.2}/README.md

@@ -302,7 +302,7 @@ res = AddressModel.count(Address.address_id, execute=True)
 
 The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
 
-#### Usage
+### Usage
 
 ```python
 response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
@@ -333,6 +333,60 @@ As you can see in the response, the result is a dictionary where the keys are a
 
 Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
 
+
+## 2. Group by
+
+The `groupby` method is used to filter results based on aggregate functions.
+
+### Usage
+```python
+from ormlambda import Column, ORM, create_engine
+from test.config import DATABASE_URL
+
+
+class Response(BaseModel):
+    district: str
+    count: int
+
+engine= create_engine(DATABASE_URL)
+model = ORM(Address,engine)
+
+count_name = Column(column_name="count")
+
+res = (
+    self.model
+    .groupby(Address.district)
+    .select(
+        (
+            Address.district,
+            self.model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+## 3. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+### Usage
+```python
+res = (
+    model
+    .groupby(Address.district)
+    .having(count_name > 4)
+    .select(
+        (
+            Address.district,
+            model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+
 ## Using BaseModel for Custom Responses (Pydantic)
 
 You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
@@ -377,14 +431,6 @@ print(select.city)
 print(select.country)
 ```
 
-
-<!-- ### 2. Having
-
-The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
-
-#### Usage -->
-
-
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python

{ormlambda-3.11.2 → ormlambda-3.12.2}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.11.2"
+version = "3.12.2"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/__init__.py

@@ -21,4 +21,4 @@ from .model.base_model import (
     ORM as ORM,
 )  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
 
-from .engine import create_engine, URL, make_url # noqa: F401
+from .engine import create_engine, URL, make_url  # noqa: F401

ormlambda-3.12.2/src/ormlambda/common/abstract_classes/clause_info_converter.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+import typing as tp
+from ormlambda import Table
+
+from ormlambda.sql.clause_info import ClauseInfo, AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda import ForeignKey
+
+from ormlambda.sql.types import AliasType, TableType, ColumnType
+
+
+class ClauseInfoConverter[T, TProp](tp.Protocol):
+    @classmethod
+    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]: ...
+
+
+class ConvertFromAnyType(ClauseInfoConverter[None, None]):
+    @classmethod
+    def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        return [
+            ClauseInfo[None](
+                table=None,
+                column=data,
+                alias_table=alias_table,
+                alias_clause=kwargs.get("alias", None),
+                context=context,
+            )
+        ]
+
+
+class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
+    @classmethod
+    def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[RT]]:
+        return ConvertFromTable[RT].convert(data.tright, data.alias, context, **kwargs)
+
+
+class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
+    @classmethod
+    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
+        attributes = {
+            "table": data.table,
+            "column": data,
+            "alias_table": alias_table,
+            "alias_clause": "{table}_{column}",
+            "context": context,
+            **kwargs,
+        }
+        clause_info = ClauseInfo[None](**attributes)
+        return [clause_info]
+
+
+class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
+    @classmethod
+    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        return [data]
+
+
+class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
+    @classmethod
+    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]:
+        """
+        if the data is Table, means that we want to retrieve all columns
+        """
+        return cls._extract_all_clauses(data, alias_table, context, **kwargs)
+
+    @staticmethod
+    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[TableType[T]]]:
+        # all columns
+        column_clauses = []
+        for column in table.get_columns():
+            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context, **kwargs))
+        return column_clauses

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/common/abstract_classes/decomposition_query.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 import typing as tp
-import abc
 from ormlambda import Table, Column
 
 from ormlambda.common.interfaces import IDecompositionQuery, ICustomAlias
@@ -10,8 +9,15 @@ from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, Cla
 from ormlambda import ForeignKey
 from ormlambda.common.global_checker import GlobalChecker
 
-from ormlambda.sql.types import AliasType, TableType, ColumnType
-
+from ormlambda.sql.types import TableType, ColumnType
+from .clause_info_converter import (
+    ClauseInfoConverter,
+    ConvertFromAnyType,
+    ConvertFromForeignKey,
+    ConvertFromColumn,
+    ConvertFromIAggregate,
+    ConvertFromTable,
+)
 
 type TableTupleType[T, *Ts] = tuple[T:TableType, *Ts]
 type ValueType = tp.Union[
@@ -22,69 +28,6 @@ type ValueType = tp.Union[
 ]
 
 
-class ClauseInfoConverter[T, TProp](abc.ABC):
-    @classmethod
-    @abc.abstractmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[T]]: ...
-
-
-class ConvertFromAnyType(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        return [
-            ClauseInfo[None](
-                table=None,
-                column=data,
-                alias_table=alias_table,
-                alias_clause=None,
-                context=context,
-            )
-        ]
-
-
-class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
-    @classmethod
-    def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None) -> list[ClauseInfo[RT]]:
-        return ConvertFromTable[RT].convert(data.tright, data.alias, context)
-
-
-class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
-    @classmethod
-    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
-        clause_info = ClauseInfo[None](
-            table=data.table,
-            column=data,
-            alias_table=alias_table,
-            alias_clause="{table}_{column}",
-            context=context,
-        )
-        return [clause_info]
-
-
-class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        return [data]
-
-
-class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
-    @classmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[T]]:
-        """
-        if the data is Table, means that we want to retrieve all columns
-        """
-        return cls._extract_all_clauses(data, alias_table, context)
-
-    @staticmethod
-    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None) -> list[ClauseInfo[TableType[T]]]:
-        # all columns
-        column_clauses = []
-        for column in table.get_columns():
-            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context))
-        return column_clauses
-
-
 class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
     def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType]) -> None: ...
@@ -93,7 +36,8 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
     def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str, context: ClauseContextType = ...) -> None: ...
 
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str = "{table}", *, context: ClauseContextType = ClauseInfoContext()) -> None:
+    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str = "{table}", *, context: ClauseContextType = ClauseInfoContext(), **kwargs) -> None:
+        self.kwargs = kwargs
         self._tables: tuple[TableType[T]] = tables if isinstance(tables, tp.Iterable) else (tables,)
 
         self._columns: tp.Callable[[T], tuple] = columns
@@ -145,7 +89,7 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
         }
         classConverter = next((converter for obj, converter in VALUE_TYPE_MAPPED.items() if validation(data, obj)), ConvertFromAnyType)
 
-        return classConverter.convert(data, alias_table=self._alias_table, context=self._context)
+        return classConverter.convert(data, alias_table=self._alias_table, context=self._context, **self.kwargs)
 
     def __add_clause[TTable: TableType](self, clauses: list[ClauseInfo[TTable]] | ClauseInfo[TTable]) -> None:
         if not isinstance(clauses, tp.Iterable):

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/common/abstract_classes/non_query_base.py

@@ -5,11 +5,11 @@ from typing import Any, Optional, Type, override, TYPE_CHECKING
 from ormlambda.common.interfaces.INonQueryCommand import INonQueryCommand
 
 if TYPE_CHECKING:
-    from ormlambda.repository import IRepositoryBase
+    from ormlambda.repository import BaseRepository
     from ormlambda import Table
 
 
-class NonQueryBase[T: Type[Table], TRepo: IRepositoryBase](INonQueryCommand):
+class NonQueryBase[T: Type[Table], TRepo: BaseRepository](INonQueryCommand):
     __slots__: tuple[str, ...] = ("_model", "_repository", "_values", "_query")
 
     def __init__(self, model: T, repository: TRepo) -> None:

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/common/interfaces/ICustomAlias.py

@@ -1,4 +1,4 @@
-from ormlambda.common.interfaces import IDecompositionQuery
+# from ormlambda.common.interfaces import IDecompositionQuery
 
 
 class ICustomAlias[T, *Ts]: ...

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/components/delete/abstract_delete.py

@@ -3,13 +3,13 @@ from abc import abstractmethod
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ormlambda import Table, IRepositoryBase
+    from ormlambda import Table, BaseRepository
 from ormlambda.common.abstract_classes import NonQueryBase
 
 from .IDelete import IDelete
 
 
-class DeleteQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IDelete[T]):
+class DeleteQueryBase[T: Table, TRepo: BaseRepository](NonQueryBase[T, TRepo], IDelete[T]):
     def __init__(self, model: T, repository: TRepo) -> None:
         super().__init__(model, repository)
 

ormlambda-3.12.2/src/ormlambda/components/join/__init__.py

@@ -0,0 +1 @@
+from .join_context import JoinContext, TupleJoinType  # noqa: F401

ormlambda-3.12.2/src/ormlambda/databases/my_sql/clauses/drop_table.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from typing import Literal, override, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mysql.connector import MySQLConnection
+
+from ormlambda.repository import BaseRepository
+
+
+TypeExists = Literal["fail", "replace", "append"]
+
+
+class DropTable:
+    def __init__(self, repository: BaseRepository[MySQLConnection]) -> None:
+        self._repository: BaseRepository[MySQLConnection] = repository
+
+    @override
+    def execute(self, name: str = None) -> None:
+        query = rf"{self.CLAUSE} {name}"
+        self._repository.execute(query)
+        return None
+
+    @property
+    @override
+    def CLAUSE(self) -> str:
+        return "DROP TABLE"

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,7 +1,6 @@
 import typing as tp
 from ormlambda import Table
-from ormlambda.sql.clause_info.clause_info import AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
+from ormlambda.sql.clause_info import AggregateFunctionBase, ClauseInfoContext
 from ormlambda.sql.types import ColumnType
 
 

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/databases/my_sql/clauses/select.py

@@ -21,11 +21,13 @@ class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
         *,
         alias_table: AliasType[ClauseInfo] = "{table}",
         context: Optional[ClauseInfoContext] = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             tables,
             columns,
             context=context,
+            **kwargs,
         )
         self._alias_table = alias_table
         # We always need to add the self alias of the Select

{ormlambda-3.11.2 → ormlambda-3.12.2}/src/ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,15 +1,19 @@
-from typing import override, Any
+from __future__ import annotations
+from typing import override, TYPE_CHECKING
 
 from ormlambda import Table
 from ormlambda.components.upsert import UpsertQueryBase
-from ormlambda.repository import IRepositoryBase
-from mysql.connector import MySQLConnection
+from ormlambda.repository import IRepositoryBase, BaseRepository
+
 
 from .insert import InsertQuery
 
+if TYPE_CHECKING:
+    from mysql.connector import MySQLConnection
+
 
 class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: Any) -> None:
+    def __init__(self, model: T, repository: BaseRepository[MySQLConnection]) -> None:
         super().__init__(model, repository)
 
     @override

ormlambda-3.12.2/src/ormlambda/databases/my_sql/query_builder.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+from typing import Iterable, TypedDict, Optional
+
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
+from ormlambda.databases.my_sql.clauses.joins import JoinSelector
+from ormlambda import ForeignKey
+
+from ormlambda.common.interfaces import IQuery
+
+
+from ormlambda.sql.clause_info import ClauseInfo
+from .clauses import Limit
+from .clauses import Offset
+from .clauses import Order
+from .clauses import Select
+
+from .clauses import Where
+from .clauses import Having
+from .clauses import GroupBy
+
+
+from ormlambda.common.enums import JoinType
+
+
+class OrderType(TypedDict):
+    Select: Select
+    JoinSelector: JoinSelector
+    Where: Where
+    Order: Order
+    GroupBy: GroupBy
+    Having: Having
+    Limit: Limit
+    Offset: Offset
+
+
+class QueryBuilder(IQuery):
+    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
+
+    def __init__(self, by: JoinType = JoinType.INNER_JOIN):
+        self._context = ClauseInfoContext()
+        self._query_list: OrderType = {}
+        self._by = by
+
+        self._joins: Optional[IQuery] = None
+        self._select: Optional[IQuery] = None
+        self._where: Optional[IQuery] = None
+        self._order: Optional[IQuery] = None
+        self._group_by: Optional[IQuery] = None
+        self._limit: Optional[IQuery] = None
+        self._offset: Optional[IQuery] = None
+
+    def add_statement[T](self, clause: ClauseInfo[T]):
+        self.update_context(clause)
+        self._query_list[type(clause).__name__] = clause
+
+    @property
+    def by(self) -> JoinType:
+        return self._by
+
+    @by.setter
+    def by(self, value: JoinType) -> None:
+        self._by = value
+
+    @property
+    def JOINS(self) -> Optional[set[JoinSelector]]:
+        return self._joins
+
+    @property
+    def SELECT(self) -> IQuery:
+        return self._query_list.get("Select", None)
+
+    @property
+    def WHERE(self) -> IQuery:
+        where = self._query_list.get("Where", None)
+        if not isinstance(where, Iterable):
+            if not where:
+                return ()
+            return (where,)
+        return where
+
+    @property
+    def ORDER(self) -> IQuery:
+        return self._query_list.get("Order", None)
+
+    @property
+    def GROUP_BY(self) -> IQuery:
+        return self._query_list.get("GroupBy", None)
+
+    @property
+    def HAVING(self) -> IQuery:
+        where = self._query_list.get("Having", None)
+        if not isinstance(where, Iterable):
+            if not where:
+                return ()
+            return (where,)
+        return where
+
+    @property
+    def LIMIT(self) -> IQuery:
+        return self._query_list.get("Limit", None)
+
+    @property
+    def OFFSET(self) -> IQuery:
+        return self._query_list.get("Offset", None)
+
+    @property
+    def query(self) -> str:
+        # COMMENT: (select.query, query)We must first create an alias for 'FROM' and then define all the remaining clauses.
+        # This order is mandatory because it adds the clause name to the context when accessing the .query property of 'FROM'
+
+        extract_joins = self.pop_tables_and_create_joins_from_ForeignKey(self._by)
+
+        JOINS = self.stringify_foreign_key(extract_joins, " ")
+        query_list: tuple[str, ...] = (
+            self.SELECT.query,
+            JOINS,
+            Where.join_condition(self.WHERE, True, self._context) if self.WHERE else None,
+            self.GROUP_BY.query if self.GROUP_BY else None,
+            Having.join_condition(self.HAVING, True, self._context) if self.HAVING else None,
+            self.ORDER.query if self.ORDER else None,
+            self.LIMIT.query if self.LIMIT else None,
+            self.OFFSET.query if self.OFFSET else None,
+        )
+        return " ".join([x for x in query_list if x])
+
+    def stringify_foreign_key(self, joins: set[JoinSelector], sep: str = "\n") -> Optional[str]:
+        if not joins:
+            return None
+        sorted_joins = JoinSelector.sort_join_selectors(joins)
+        return f"{sep}".join([join.query for join in sorted_joins])
+
+    def pop_tables_and_create_joins_from_ForeignKey(self, by: JoinType = JoinType.INNER_JOIN) -> set[JoinSelector]:
+        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
+        if not ForeignKey.stored_calls:
+            return None
+
+        joins = set()
+        # Always it's gonna be a set of two
+        # FIXME [x]: Resolved when we get Compare object instead ClauseInfo. For instance, when we have multiples condition using '&' or '|'
+        for fk in ForeignKey.stored_calls.copy():
+            fk = ForeignKey.stored_calls.pop(fk)
+            self._context._add_table_alias(fk.tright, fk.alias)
+            join = JoinSelector(fk.resolved_function(self._context), by, context=self._context, alias=fk.alias)
+            joins.add(join)
+
+        return joins
+
+    def clear(self) -> None:
+        self.__init__()
+        return None
+
+    def update_context(self, clause: ClauseInfo) -> None:
+        if not hasattr(clause, "context"):
+            return None
+
+        if clause.context is not None:
+            self._context.update(clause.context)
+        clause.context = self._context