ormlambda 3.34.5__tar.gz → 3.34.7__tar.gz

{ormlambda-3.34.5 → ormlambda-3.34.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.34.5
+Version: 3.34.7
 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.5 → ormlambda-3.34.7}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.34.5"
+version = "3.34.7"
 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.7/src/ormlambda/dialects/mysql/__init__.py

@@ -0,0 +1,84 @@
+from . import base
+from . import mysqlconnector
+
+from .base import BIGINT
+from .base import BINARY
+from .base import BIT
+from .base import BLOB
+from .base import BOOLEAN
+from .base import CHAR
+from .base import DATE
+from .base import DATETIME
+from .base import DECIMAL
+from .base import DOUBLE
+from .base import FLOAT
+from .base import INTEGER
+from .base import LONGBLOB
+from .base import LONGTEXT
+from .base import MEDIUMBLOB
+from .base import MEDIUMINT
+from .base import MEDIUMTEXT
+from .base import NCHAR
+from .base import NUMERIC
+from .base import NVARCHAR
+from .base import REAL
+from .base import SMALLINT
+from .base import TEXT
+from .base import TIME
+from .base import TIMESTAMP
+from .base import TINYBLOB
+from .base import TINYINT
+from .base import TINYTEXT
+from .base import VARBINARY
+from .base import VARCHAR
+from .base import YEAR
+
+
+
+__all__ = (
+    "BIGINT",
+    "BINARY",
+    "BIT",
+    "BLOB",
+    "BOOLEAN",
+    "CHAR",
+    "DATE",
+    "DATETIME",
+    "DECIMAL",
+    "DOUBLE",
+    "ENUM",
+    "FLOAT",
+    "INET4",
+    "INET6",
+    "INTEGER",
+    "INTEGER",
+    "JSON",
+    "LONGBLOB",
+    "LONGTEXT",
+    "MEDIUMBLOB",
+    "MEDIUMINT",
+    "MEDIUMTEXT",
+    "NCHAR",
+    "NVARCHAR",
+    "NUMERIC",
+    "SET",
+    "SMALLINT",
+    "REAL",
+    "TEXT",
+    "TIME",
+    "TIMESTAMP",
+    "TINYBLOB",
+    "TINYINT",
+    "TINYTEXT",
+    "VARBINARY",
+    "VARCHAR",
+    "YEAR",
+    "dialect",
+    "insert",
+    "Insert",
+    "match",
+)
+
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect

{ormlambda-3.34.5 → ormlambda-3.34.7}/src/ormlambda/dialects/mysql/base.py

@@ -46,6 +46,7 @@ from ormlambda.sql.sqltypes import (
     DATE,
     UUID,
     VARBINARY,
+    BINARY,
 )
 
 

ormlambda-3.34.7/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.5 → ormlambda-3.34.7}/src/ormlambda/sql/sqltypes.py

@@ -561,6 +561,12 @@ class BLOB(LargeBinary):
     __visit_name__ = "BLOB"
 
 
+class BINARY(_Binary):
+    """The SQL BINARY type."""
+
+    __visit_name__ = "BINARY"
+
+
 class VARCHAR(String):
     __visit_name__ = "VARCHAR"
 

{ormlambda-3.34.5 → ormlambda-3.34.7}/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:

ormlambda-3.34.5/src/ormlambda/dialects/mysql/__init__.py

@@ -1,8 +0,0 @@
-from . import base
-from . import mysqlconnector
-
-# default dialect
-base.dialect = dialect = mysqlconnector.dialect
-
-
-from .types import *  # noqa: F403