ormlambda 3.34.6__tar.gz → 3.34.8__tar.gz

{ormlambda-3.34.6 → ormlambda-3.34.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.34.6
+Version: 3.34.8
 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

{ormlambda-3.34.6 → ormlambda-3.34.8}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.34.6"
+version = "3.34.8"
 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.34.8/src/ormlambda/sql/clauses/new_join.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+from collections import defaultdict
+from typing import override, Optional, TYPE_CHECKING, Type
+
+
+from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda import JoinType
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.comparer import Comparer
+from ormlambda.sql.elements import ClauseElement
+
+
+# TODOL [x]: Try to import Table module without circular import Error
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class Join(ClauseElement):
+    __visit_name__ = "join"
+    __slots__: tuple = (
+        "comparer",
+        "alias",
+        "from_clause",
+        "left_clause",
+        "right_clause",
+        "by",
+        "_dialect",
+    )
+
+    DEFAULT_TABLE: str = "{table}"
+
+    @override
+    def __repr__(self) -> str:
+        return f"{IQuery.__name__}: {self.query(self._dialect)}"
+
+    def __init__(
+        self,
+        comparer: Comparer,
+        right_alias: Optional[str] = DEFAULT_TABLE,
+        left_alias: Optional[str] = DEFAULT_TABLE,
+        by: JoinType = JoinType.LEFT_EXCLUSIVE,
+        *,
+        dialect: Dialect,
+        **kw,
+    ) -> None:
+        self.comparer = comparer
+        self._dialect = dialect
+        self.by = by
+
+        # COMMENT: When multiple columns reference the same table, we need to create an alias to maintain clear references.
+        self.alias: Optional[str] = right_alias
+        self.left_clause: ClauseInfo = comparer.left_condition(dialect)
+        self.left_clause.alias_table = left_alias if left_alias is not None else self.DEFAULT_TABLE
+
+        self.right_clause: ClauseInfo = comparer.right_condition(dialect)
+        self.right_clause.alias_table = right_alias if right_alias is not None else self.DEFAULT_TABLE
+        self.from_clause = ClauseInfo(self.right_clause.table, None, alias_table=self.alias, dialect=dialect)
+
+    def __eq__(self, __value: Join) -> bool:
+        return isinstance(__value, Join) and self.__hash__() == __value.__hash__()
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.by,
+                self.left_clause.query(self._dialect),
+                self.right_clause.query(self._dialect),
+                self.from_clause.query(self._dialect),
+            )
+        )
+
+    @classmethod
+    def join_selectors(cls, dialect: Dialect, *args: Join) -> str:
+        return "\n".join([x.query(dialect) for x in args])
+
+    def query(self, dialect: Dialect) -> str:
+        list_ = [
+            self.by.value,  # inner join
+            self.from_clause.query(dialect),
+            "ON",
+            self.left_clause.query(dialect),
+            "=",
+            self.right_clause.query(dialect),
+        ]
+        return " ".join([x for x in list_ if x is not None])
+
+    @classmethod
+    def sort_join_selectors(cls, joins: set[Join]) -> tuple[Join]:
+        # FIXME [x]: How to sort when needed because it's not necessary at this point. It is for testing purpouse
+        if len(joins) == 1:
+            return tuple(joins)
+
+        # create graph and sort it using 'Depth First Search' algorithm
+        graph: dict[str, list[str]] = defaultdict(list)
+        for join in joins:
+            graph[join.left_clause.alias_table].append(join.right_clause.alias_table)
+
+        sorted_graph = DFSTraversal.sort(graph)[::-1]
+
+        if not sorted_graph:
+            return tuple(joins)
+
+        # Mapped Join class using his unique alias
+        join_object_map: dict[str, Join] = {}
+        for obj in joins:
+            join_object_map[obj.alias] = obj
+
+        res = []
+        for table in sorted_graph:
+            tables = join_object_map.get(table, None)
+
+            if not tables:
+                continue
+            res.append(tables)
+        return res
+
+
+__all__ = ["Join"]

{ormlambda-3.34.6 → ormlambda-3.34.8}/src/ormlambda/sql/column/column.py

@@ -231,3 +231,7 @@ class Column[TProp]:
         from ormlambda.sql.comparer import Like
 
         return Like(self, pattern)
+
+    @property
+    def __name__(self)->str:
+        return self.column_name

{ormlambda-3.34.6 → ormlambda-3.34.8}/src/ormlambda/sql/table/table.py

@@ -159,14 +159,10 @@ class Table(metaclass=TableMeta):
         return [ForeignKey.MAPPED[x].table_object for x in order_table]
 
     def __eq__(self, __value: Any) -> bool:
-        if isinstance(__value, Table):
-            return all(
-                (
-                    self.__table_name__ == __value.__table_name__,
-                    tuple(self.to_dict().items()),
-                )
-            )
-        return False
+        return hash(self) == hash(__value)
+
+    def __hash__(self):
+        return hash((self.__table_name__, *list(self.to_dict().items())))
 
     @classmethod
     def table_alias(cls, column: Optional[str] = None) -> str: