ormlambda 1.5.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

ormlambda/databases/my_sql/statements.py

@@ -1,11 +1,19 @@
-from typing import override, Type
+from __future__ import annotations
+from typing import override, Type, TYPE_CHECKING, Any, Callable, Optional
 
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda.components.select import ISelect
+    from ormlambda.components.where.abstract_where import AbstractWhere
+    from ormlambda.common.interfaces.IStatements import OrderType
+    from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+    from src.ormlambda.common.interfaces.IRepositoryBase import TypeExists
 
-from ...common.abstract_classes import AbstractSQLStatements
-from ...utils import Table
-from ...common.interfaces import IQuery, IRepositoryBase
-from ...components.select import ISelect
+    from ormlambda.databases.my_sql.clauses.select import SelectQuery
+    from ormlambda.databases.my_sql.clauses.count import CountQuery
 
+
+from ormlambda import AbstractSQLStatements
 from .clauses import DeleteQuery
 from .clauses import InsertQuery
 from .clauses import JoinSelector
@@ -16,71 +24,220 @@ from .clauses import SelectQuery
 from .clauses import UpsertQuery
 from .clauses import UpdateQuery
 from .clauses import WhereCondition
+from .clauses import CountQuery
+
+from mysql.connector import MySQLConnection, errors, errorcode
+
+
+import inspect
 
-from mysql.connector import MySQLConnection
+from ormlambda.utils import ForeignKey, Table
+from ormlambda.common.enums import JoinType
 
 
 class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
         super().__init__(model, repository=repository)
 
-    # region Private methods
-    def __repr__(self):
-        return f"<Model: {self.__class__.__name__}>"
+    @property
+    @override
+    def repository(self) -> IRepositoryBase[MySQLConnection]:
+        return self._repository
 
-    # endregion
+    @override
+    def create_table(self, if_exists: TypeExists = "fail") -> None:
+        name: str = self._model.__table_name__
+        if self._repository.table_exists(name):
+            if if_exists == "replace":
+                self._repository.drop_table(name)
+
+            elif if_exists == "fail":
+                raise errors.ProgrammingError(msg=f"Table '{self._model.__table_name__}' already exists", errno=errorcode.ER_TABLE_EXISTS_ERROR)
+
+            elif if_exists == "append":
+                counter: int = 0
+                char: str = ""
+                while self._repository.table_exists(name + char):
+                    counter += 1
+                    char = f"_{counter}"
+                name += char
+                self._model.__table_name__ = name
+
+        query = self._model.create_table_query()
+        self._repository.execute(query)
+        return None
 
-    @property
     @override
-    def INSERT_QUERY(self) -> Type[InsertQuery]:
-        return InsertQuery
+    def table_exists(self) -> bool:
+        return self._repository.table_exists(self._model.__table_name__)
 
-    @property
     @override
-    def UPSERT_QUERY(self) -> Type[UpsertQuery]:
-        return UpsertQuery
+    def insert(self, instances: T | list[T]) -> None:
+        insert = InsertQuery(self._model, self._repository)
+        insert.insert(instances)
+        insert.execute()
+        self._query_list.clear()
+        return None
 
-    @property
     @override
-    def UPDATE_QUERY(self) -> Type[UpsertQuery]:
-        return UpdateQuery
+    def delete(self, instances: Optional[T | list[T]] = None) -> None:
+        if instances is None:
+            response = self.select()
+            if len(response) == 0:
+                return None
+            # [0] because if we do not select anything, we retrieve all columns of the unic model, stored in tuple[tuple[model]] structure.
+            # We always going to have a tuple of one element
+            return self.delete(response)
+
+        delete = DeleteQuery(self._model, self._repository)
+        delete.delete(instances)
+        delete.execute()
+        # not necessary to call self._query_list.clear() because select() method already call it
+        return None
 
     @override
-    @property
-    def DELETE_QUERY(self) -> Type[DeleteQuery]:
-        return DeleteQuery
+    def upsert(self, instances: T | list[T]) -> None:
+        upsert = UpsertQuery(self._model, self._repository)
+        upsert.upsert(instances)
+        upsert.execute()
+        self._query_list.clear()
+        return None
 
-    @property
     @override
-    def LIMIT_QUERY(self) -> Type[IQuery]:
-        return LimitQuery
+    def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
+        update = UpdateQuery(self._model, self._repository, self._query_list["where"])
+        update.update(dicc)
+        update.execute()
+        self._query_list.clear()
+        return None
 
-    @property
     @override
-    def OFFSET_QUERY(self) -> Type[IQuery]:
-        return OffsetQuery
+    def limit(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
+        limit = LimitQuery(number)
+        # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
+        limit_list = self._query_list["limit"]
+        if len(limit_list) > 0:
+            self._query_list["limit"] = [limit]
+        else:
+            self._query_list["limit"].append(limit)
+        return self
 
-    @property
     @override
-    def JOIN_QUERY(self) -> Type[IQuery]:
-        return JoinSelector
+    def offset(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
+        offset = OffsetQuery(number)
+        self._query_list["offset"].append(offset)
+        return self
 
-    @property
     @override
-    def WHERE_QUERY(self) -> Type[IQuery]:
-        return WhereCondition
+    def count(self) -> int:
+        count_select: IQuery = CountQuery(self._model)
+        self._query_list["select"].append(count_select)
+        query = self.build()
+        return self.repository.read_sql(query)[0][0]
 
-    @property
     @override
-    def ORDER_QUERY(self) -> Type[IQuery]:
-        return OrderQuery
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements_two_generic[T, MySQLConnection]:
+        where = ForeignKey.MAPPED[table_left.__table_name__][table_right.__table_name__]
+        join_query = JoinSelector[table_left, Table](table_left, table_right, JoinType(by), where=where)
+        self._query_list["join"].append(join_query)
+        return self
 
-    @property
     @override
-    def SELECT_QUERY(self) -> Type[ISelect]:
-        return SelectQuery
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
+        # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
+        where_query = WhereCondition[T](function=lambda_, instances=(self._model,), **kwargs)
+        self._query_list["where"].append(where_query)
+        return self
 
-    @property
     @override
-    def repository(self) -> IRepositoryBase[MySQLConnection]:
-        return self._repository
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements_two_generic[T, MySQLConnection]:
+        order = OrderQuery[T](self._model, _lambda_col, order_type)
+        self._query_list["order"].append(order)
+        return self
+
+    @override
+    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+        if len(inspect.signature(selector).parameters) == 0:
+            # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models
+            result = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
+            # COMMENT: Always we want to retrieve tuple[tuple[Any]]. That's the reason to return result[0] when we ensure the user want only objects of the first table.
+            # Otherwise, we wil return the result itself
+            if flavour:
+                return result
+            return () if not result else result[0]
+        select: ISelect = SelectQuery(self._model, select_lambda=selector, by=by)
+        self._query_list["select"].append(select)
+
+        query: str = self.build()
+        if flavour:
+            result = self._return_flavour(query, flavour)
+            if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
+                return tuple([x[0] for x in result])
+            return result
+        return self._return_model(select, query)
+
+    @override
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+        self.limit(1)
+        if len(inspect.signature(selector).parameters) == 0:
+            response = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
+        else:
+            response = self.select(selector=selector, flavour=flavour, by=by)
+
+        if flavour:
+            return response[0] if response else None
+
+        # response var could be return more than one element when we work with models an we
+        # select columns from different tables using a join query
+        if len(response) == 1 and len(response[0]) == 1:
+            return response[0][0]
+        return tuple([res[0] for res in response])
+
+    @override
+    def build(self) -> str:
+        query: str = ""
+
+        self.__create_necessary_inner_join()
+        for x in self.__order__:
+            if sub_query := self._query_list.get(x, None):
+                if isinstance(sub_query[0], WhereCondition):
+                    query_ = self.__build_where_clause(sub_query)
+
+                # we must check if any join already exists on query string
+                elif isinstance(sub_query[0], JoinSelector):
+                    select_query: str = self._query_list["select"][0].query
+                    query_ = ""
+                    for join in sub_query:
+                        if join.query not in select_query:
+                            query_ += f"\n{join.query}"
+                else:
+                    query_ = "\n".join([x.query for x in sub_query])
+
+                query += f"\n{query_}" if query != "" else query_
+        self._query_list.clear()
+        return query
+
+    def __build_where_clause(self, where_condition: list[AbstractWhere]) -> str:
+        query: str = where_condition[0].query
+
+        for where in where_condition[1:]:
+            q = where.query.replace(where.WHERE, "AND")
+            and_, clause = q.split(" ", maxsplit=1)
+            query += f" {and_} ({clause})"
+        return query
+
+    def __create_necessary_inner_join(self) -> None:
+        # 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 "where" not in self._query_list:
+            return None
+
+        where: AbstractWhere = self._query_list["where"][0]
+        involved_tables = where.get_involved_tables()
+
+        select: ISelect = self._query_list["select"][0]
+        if not involved_tables or (set(involved_tables) == set(select.tables_heritage)):
+            return None
+
+        for l_tbl, r_tbl in involved_tables:
+            # FIXME [ ]: Checked what function was called by the self.join method before the change
+            self.join(l_tbl, r_tbl, by="INNER JOIN")

ormlambda/model_base.py

@@ -1,4 +1,3 @@
-# region imports
 from typing import Type
 
 
@@ -8,11 +7,10 @@ from .common.abstract_classes import AbstractSQLStatements
 from .databases.my_sql import MySQLStatements, MySQLRepository
 
 
-
 # endregion
 
 
-class BaseModel[T: Table]:
+class BaseModel[T: Type[Table]]:
     """
     Class to select the correct AbstractSQLStatements class depends on the repository.
 
@@ -29,7 +27,7 @@ class BaseModel[T: Table]:
         cls: AbstractSQLStatements[T, TRepo] = cls.statements_dicc.get(type(repository), None)
 
         if not cls:
-            raise Exception(f"Repository selected does not exits '{repository}'")
+            raise Exception(f"The selected repository '{repository}' does not exist.")
 
         self = object().__new__(cls)
         cls.__init__(self, model, repository)

ormlambda/utils/column.py

@@ -1,5 +1,6 @@
 from typing import Type
 
+
 class Column[T]:
     __slots__ = (
         "dtype",
@@ -13,7 +14,7 @@ class Column[T]:
 
     def __init__(
         self,
-        dtype:Type[T] = None,
+        dtype: Type[T] = None,
         column_name: str = None,
         column_value: T = None,
         *,
@@ -35,9 +36,9 @@ class Column[T]:
 
     def __to_string__(self, name: str, var_name: T, type_: str):
         dicc: dict = {
-            "dtype":type_,
+            "dtype": type_,
             "column_name": f"'{name}'",
-            "column_value": var_name, # must be the same variable name as the instance variable name in Table's __init__ class
+            "column_value": var_name,  # must be the same variable name as the instance variable name in Table's __init__ class
         }
         exec_str: str = f"{Column.__name__}[{type_}]("
         for x in self.__slots__:

ormlambda/utils/dtypes.py

@@ -49,7 +49,7 @@ MySQL 8.0 does not support year in two-digit format.
 
 from decimal import Decimal
 import datetime
-from typing import Any,Literal
+from typing import Any, Literal
 import numpy as np
 
 from .column import Column
@@ -61,10 +61,6 @@ NUMERIC_UNSIGNED = Literal["BIT(size)", "TINYINT(size)", "BOOL", "BOOLEAN", "SMA
 DATE = Literal["DATE", "DATETIME(fsp)", "TIMESTAMP(fsp)", "TIME(fsp)", "YEAR"]
 
 
-
-
-
-
 # FIXME [ ]: this method does not comply with the implemented interface; we need to adjust it in the future to scale it to other databases
 @staticmethod
 def transform_py_dtype_into_query_dtype(dtype: Any) -> str:
@@ -77,15 +73,17 @@ def transform_py_dtype_into_query_dtype(dtype: Any) -> str:
         datetime.datetime: "DATETIME",
         datetime.date: "DATE",
         bytes: "BLOB",
+        bytearray: "BLOB",
         str: "VARCHAR(255)",
-        np.uint64: "BIGINT UNSIGNED"
+        np.uint64: "BIGINT UNSIGNED",
     }
 
+    res = dicc.get(dtype, None)
+    if res is None:
+        raise ValueError(f"datatype '{dtype}' is not expected.")
     return dicc[dtype]
 
 
-
-
 # FIXME [ ]: this method does not comply with the implemented interface; we need to adjust it in the future to scale it to other databases
 def get_query_clausule(column_obj: Column) -> str:
     dtype: str = transform_py_dtype_into_query_dtype(column_obj.dtype)

ormlambda/utils/foreign_key.py

@@ -1,13 +1,51 @@
-from collections import defaultdict
-from typing import Callable, TYPE_CHECKING, Type
+from __future__ import annotations
+from typing import Callable, TYPE_CHECKING, NamedTuple, Type, Optional, overload
 from .lambda_disassembler import Disassembler
 
 if TYPE_CHECKING:
     from .table_constructor import Table
 
 
-class ForeignKey[Tbl1:Table, Tbl2:Table]:
-    MAPPED: dict[Tbl1, dict[Tbl2, Callable[[Tbl1, Tbl2], bool]]] = defaultdict(dict)
+class ReferencedTable[T1: Type[Table], T2: Type[Table]](NamedTuple):
+    obj: T2
+    relationship: Callable[[T1, T2], bool]
+
+
+class TableInfo[T1: Type[Table], T2: Type[Table]]:
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, table_object: T1) -> None: ...
+
+    def __init__(self, table_object: Optional[T1] = None) -> None:
+        self._table_object: Optional[T1] = table_object
+        self._referenced_tables: dict[str, ReferencedTable[T1, T2]] = {}
+
+    def __repr__(self) -> str:
+        return f"<{TableInfo.__name__}> class '{self.table_object}' dependent tables -> [{', '.join(tuple(self.referenced_tables))}]"
+
+    @property
+    def referenced_tables(self) -> dict[str, ReferencedTable[T1, T2]]:
+        return self._referenced_tables
+
+    def update_referenced_tables(self, referenced_table: Type[Table], relationship: Callable[[T1, T2], bool]) -> None:
+        self._referenced_tables.update({referenced_table.__table_name__: ReferencedTable[T1, T2](referenced_table, relationship)})
+
+    @property
+    def table_object(self) -> Optional[Type[Table]]:
+        return self._table_object
+
+    @table_object.setter
+    def table_object(self, value: Type[Table]) -> None:
+        self._table_object = value
+
+    @property
+    def has_relationship(self) -> bool:
+        return len(self._referenced_tables) > 0
+
+
+class ForeignKey[Tbl1: Type[Table], Tbl2: Type[Table]]:
+    MAPPED: dict[str, TableInfo[Tbl1, Tbl2]] = {}
 
     def __new__(
         cls,
@@ -20,17 +58,24 @@ class ForeignKey[Tbl1:Table, Tbl2:Table]:
         return referenced_table
 
     @classmethod
-    def add_foreign_key(cls, orig_table: str, referenced_table: "Table", relationship: Callable[[Tbl1, Tbl2], bool]) -> None:
-        cls.MAPPED[orig_table][referenced_table] = relationship
+    def add_foreign_key(cls, orig_table: str, referenced_table: Table, relationship: Callable[[Tbl1, Tbl2], bool]) -> None:
+        if orig_table not in cls.MAPPED:
+            cls.MAPPED[orig_table] = TableInfo()
+
+        # if referenced_table not in cls.MAPPED[orig_table]:
+        cls.MAPPED[orig_table].update_referenced_tables(referenced_table, relationship)
+
         return None
 
     @classmethod
-    def create_query(cls, orig_table: "Table") -> list[str]:
+    def create_query(cls, orig_table: Table) -> list[str]:
         clauses: list[str] = []
-        for referenced_table, _lambda in ForeignKey[Tbl1, Tbl2].MAPPED[orig_table].items():
-            dissambler: Disassembler = Disassembler(_lambda)
+
+        fk: TableInfo[Tbl1, Tbl2] = ForeignKey[Tbl1, Tbl2].MAPPED[orig_table.__table_name__]
+        for referenced_table_obj in fk.referenced_tables.values():
+            dissambler: Disassembler = Disassembler(referenced_table_obj.relationship)
             orig_col: str = dissambler.cond_1.name
             referenced_col: str = dissambler.cond_2.name
 
-            clauses.append(f"FOREIGN KEY ({orig_col}) REFERENCES {referenced_table.__table_name__}({referenced_col})")
+            clauses.append(f"FOREIGN KEY ({orig_col}) REFERENCES {referenced_table_obj.obj.__table_name__}({referenced_col})")
         return clauses

ormlambda/utils/lambda_disassembler/__init__.py

@@ -1,4 +1,4 @@
 from .disassembler import Disassembler  # noqa: F401
 from .nested_element import NestedElement  # noqa: F401
 from .tree_instruction import TreeInstruction, TupleInstruction  # noqa: F401
-from .name_of import nameof  # noqa: F401
+from .name_of import nameof  # noqa: F401

ormlambda/utils/lambda_disassembler/dis_types.py

@@ -1,9 +1,6 @@
 from enum import Enum
 
 
-
-
-
 class OpName(Enum):
     CACHE = "CACHE"
     POP_TOP = "POP_TOP"
@@ -112,25 +109,25 @@ class OpName(Enum):
     INSTRUMENTED_END_SEND = "INSTRUMENTED_END_SEND"
     INSTRUMENTED_INSTRUCTION = "INSTRUMENTED_INSTRUCTION"
     INSTRUMENTED_LINE = "INSTRUMENTED_LINE"
-    FOR_ITER= 'FOR_ITER'
-    JUMP_FORWARD= 'JUMP_FORWARD'
-    POP_JUMP_IF_FALSE= 'POP_JUMP_IF_FALSE'
-    POP_JUMP_IF_TRUE= 'POP_JUMP_IF_TRUE'
-    SEND= 'SEND'
-    POP_JUMP_IF_NOT_NONE= 'POP_JUMP_IF_NOT_NONE'
-    POP_JUMP_IF_NONE= 'POP_JUMP_IF_NONE'
-    JUMP_BACKWARD_NO_INTERRUPT= 'JUMP_BACKWARD_NO_INTERRUPT'
-    JUMP_BACKWARD= 'JUMP_BACKWARD'
-    STORE_NAME= 'STORE_NAME'
-    DELETE_NAME= 'DELETE_NAME'
-    STORE_ATTR= 'STORE_ATTR'
-    DELETE_ATTR= 'DELETE_ATTR'
-    STORE_GLOBAL= 'STORE_GLOBAL'
-    DELETE_GLOBAL= 'DELETE_GLOBAL'
-    LOAD_NAME= 'LOAD_NAME'
-    LOAD_ATTR= 'LOAD_ATTR'
-    IMPORT_NAME= 'IMPORT_NAME'
-    IMPORT_FROM= 'IMPORT_FROM'
-    LOAD_GLOBAL= 'LOAD_GLOBAL'
-    LOAD_SUPER_ATTR= 'LOAD_SUPER_ATTR'
-    LOAD_FROM_DICT_OR_GLOBALS= 'LOAD_FROM_DICT_OR_GLOBALS'
+    FOR_ITER = "FOR_ITER"
+    JUMP_FORWARD = "JUMP_FORWARD"
+    POP_JUMP_IF_FALSE = "POP_JUMP_IF_FALSE"
+    POP_JUMP_IF_TRUE = "POP_JUMP_IF_TRUE"
+    SEND = "SEND"
+    POP_JUMP_IF_NOT_NONE = "POP_JUMP_IF_NOT_NONE"
+    POP_JUMP_IF_NONE = "POP_JUMP_IF_NONE"
+    JUMP_BACKWARD_NO_INTERRUPT = "JUMP_BACKWARD_NO_INTERRUPT"
+    JUMP_BACKWARD = "JUMP_BACKWARD"
+    STORE_NAME = "STORE_NAME"
+    DELETE_NAME = "DELETE_NAME"
+    STORE_ATTR = "STORE_ATTR"
+    DELETE_ATTR = "DELETE_ATTR"
+    STORE_GLOBAL = "STORE_GLOBAL"
+    DELETE_GLOBAL = "DELETE_GLOBAL"
+    LOAD_NAME = "LOAD_NAME"
+    LOAD_ATTR = "LOAD_ATTR"
+    IMPORT_NAME = "IMPORT_NAME"
+    IMPORT_FROM = "IMPORT_FROM"
+    LOAD_GLOBAL = "LOAD_GLOBAL"
+    LOAD_SUPER_ATTR = "LOAD_SUPER_ATTR"
+    LOAD_FROM_DICT_OR_GLOBALS = "LOAD_FROM_DICT_OR_GLOBALS"

ormlambda/utils/lambda_disassembler/tree_instruction.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from typing import Any, Callable, NamedTuple, Self, Optional
 from dis import Instruction, Bytecode
-from ...common.enums.condition_types import ConditionType
+from ormlambda.common.enums.condition_types import ConditionType
 from .dis_types import OpName
 from .nested_element import NestedElement
 

ormlambda/utils/module_tree/dynamic_module.py

@@ -6,7 +6,9 @@ import importlib.util
 import inspect
 import re
 
-from ..table_constructor import Table
+from ormlambda import ForeignKey
+
+from ormlambda import Table
 from .dfs_traversal import DFSTraversal
 
 
@@ -180,12 +182,12 @@ class ModuleTree:
         """
         tables: list[tuple[str, Table]] = self.get_member_table(self.load_module("", self.module_path))
 
-        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
+        graph: dict[str, list[str]] = defaultdict(list)
         for _, tbl in tables:
-            graph[tbl] = tbl.find_dependent_tables()
+            graph[tbl.__table_name__] = [x.__table_name__ for x in tbl.find_dependent_tables()]
 
         sorted_tables = DFSTraversal.sort(graph)
-        res = [x.create_table_query() for x in sorted_tables]
+        res = [ForeignKey.MAPPED[x].table_object.create_table_query() for x in sorted_tables]
         return res
 
     @staticmethod

ormlambda/utils/table_constructor.py

@@ -1,5 +1,4 @@
 import base64
-from collections import defaultdict
 import datetime
 from decimal import Decimal
 from typing import Any, Iterable, Optional, Type, dataclass_transform
@@ -9,7 +8,7 @@ from .dtypes import get_query_clausule
 from .module_tree.dfs_traversal import DFSTraversal
 from .column import Column
 
-from .foreign_key import ForeignKey
+from .foreign_key import ForeignKey, TableInfo
 
 MISSING = Column()
 
@@ -156,7 +155,7 @@ class TableMeta(type):
         if not isinstance(cls_object.__table_name__, str):
             raise Exception(f"class variable '__table_name__' of '{cls_object.__name__}' class must be 'str'")
 
-        TableMeta.__add_fk_if_exists__(cls_object)
+        TableMeta.__add_to_ForeignKey(cls_object)
         self = __init_constructor__(cls_object)
         return self
 
@@ -164,14 +163,17 @@ class TableMeta(type):
         return f"{TableMeta.__name__}: {cls.__table_name__}"
 
     @staticmethod
-    def __add_fk_if_exists__(cls: "Table") -> None:
+    def __add_to_ForeignKey(cls: "Table") -> None:
         """
         When creating a Table class, we cannot pass the class itself as a parameter in a function that initializes a class variable.
-        To fix this, we first add the table name and then, when instantiating the object, we replace the table name with the class itself.
+        To fix this, we first add the table name as key and then, we add the class itself in the TableInfo class.
         """
-        if data := ForeignKey.MAPPED.get(cls.__table_name__):
-            ForeignKey.MAPPED[cls] = data
-            del ForeignKey.MAPPED[cls.__table_name__]
+        if table_info := ForeignKey.MAPPED.get(cls.__table_name__, None):
+            table_info.table_object = cls
+        else:
+            ForeignKey.MAPPED[cls.__table_name__] = TableInfo()
+            ForeignKey.MAPPED[cls.__table_name__].table_object = cls
+
         return None
 
 
@@ -285,24 +287,39 @@ class Table(metaclass=TableMeta):
 
     @classmethod
     def find_dependent_tables(cls) -> tuple["Table", ...]:
-        def get_involved_tables(graph: dict[Table, list[Table]], table: Table) -> None:
-            for tbl in ForeignKey[Table, Table].MAPPED[table].keys():
-                if ForeignKey.MAPPED[tbl]:
-                    get_involved_tables(graph, tbl)
-                graph[tbl] = list(ForeignKey.MAPPED[tbl].keys())
-                return None
-
-        graph: dict[Table, list[Table]] = defaultdict(list)
-        graph[cls] = list(ForeignKey.MAPPED[cls].keys())
-        get_involved_tables(graph, cls)
+        # TODOL: Dive into new way to return dependent tables
+        def get_involved_tables(graph: dict[Table, list[Table]], table_name: str) -> None:
+            """
+            Create a graph to be ordered
+            """
+            table = ForeignKey[Table, Table].MAPPED[table_name]
+            for x in table.referenced_tables:
+                if data := ForeignKey.MAPPED.get(x, None):
+                    get_involved_tables(graph, data.table_object.__table_name__)
+
+            graph[table.table_object.__table_name__] = list(table.referenced_tables)
+            return None
+
+        graph: dict[Table, list[Table]] = {}
+        dependent = ForeignKey.MAPPED.get(cls.__table_name__, None)
+        if dependent is None:
+            return tuple([])
+
+        graph[cls.__table_name__] = list(dependent.referenced_tables)
+        get_involved_tables(graph, cls.__table_name__)
 
         dfs = DFSTraversal.sort(graph)
-        return dfs[: dfs.index(cls)]
 
-    def __hash__(self) -> int:
-        return hash(self.to_dict().values())
+        order_table = dfs[: dfs.index(cls.__table_name__)]
+
+        return [ForeignKey.MAPPED[x].table_object for x in order_table]
 
     def __eq__(self, __value: Any) -> bool:
         if isinstance(__value, Table):
-            return hash(self) == hash(__value)
+            return all(
+                (
+                    self.__table_name__ == __value.__table_name__,
+                    tuple(self.to_dict().items()),
+                )
+            )
         return False