ormlambda 0.1.0__py3-none-any.whl

ormlambda/databases/my_sql/clauses/joins.py

@@ -0,0 +1,103 @@
+from typing import override, Callable, overload, Optional, TypeVar
+
+# from ..table import Table
+
+from ....common.interfaces.IQueryCommand import IQuery
+from ....utils.lambda_disassembler import Disassembler
+from ....common.enums import JoinType
+
+# TODOL: Try to import Table module without circular import Error
+Table = TypeVar("Table")
+
+
+class JoinSelector[TLeft, TRight](IQuery):
+    __slots__: tuple = (
+        "_orig_table",
+        "_table_right",
+        "_by",
+        "_left_col",
+        "_right_col",
+        "_compareop",
+    )
+
+    @overload
+    def __init__(
+        self,
+        table_left: TLeft,
+        table_right: TRight,
+        col_left: str,
+        col_right: str,
+        by: JoinType,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        table_left: TLeft,
+        table_right: TRight,
+        by: JoinType,
+        where: Callable[[TLeft, TRight], bool],
+    ) -> None: ...
+
+    def __init__(
+        self,
+        table_left: Table,
+        table_right: Table,
+        by: JoinType,
+        col_left: Optional[str] = None,
+        col_right: Optional[str] = None,
+        where: Optional[Callable[[TLeft, TRight], bool]] = None,
+    ) -> None:
+        self._orig_table: Table = table_left
+        self._table_right: Table = table_right
+        self._by: JoinType = by
+
+        if all(x is None for x in (col_left, col_right, where)):
+            raise ValueError("You must specify at least 'where' clausule or ('_left_col',_right_col')")
+
+        if where is None:
+            self._left_col: str = col_left
+            self._right_col: str = col_right
+            self._compareop: str = "="
+        else:
+            _dis: Disassembler[TLeft, TRight] = Disassembler[TLeft, TRight](where)
+            self._left_col: str = _dis.cond_1.name
+            self._right_col: str = _dis.cond_2.name
+            self._compareop: str = _dis.compare_op
+
+    def __eq__(self, __value: "JoinSelector") -> bool:
+        return isinstance(__value, JoinSelector) and self.__hash__() == __value.__hash__()
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self._orig_table,
+                self._table_right,
+                self._by,
+                self._left_col,
+                self._right_col,
+                self._compareop,
+            )
+        )
+
+    @classmethod
+    def join_selectors(cls, *args: "JoinSelector") -> str:
+        return "\n".join([x.query for x in args])
+
+    @property
+    @override
+    def query(self) -> str:
+        # {inner join} table_name on
+        #   table_name.first col = table_name.second_col
+
+        left_col = f"{self._orig_table.__table_name__}.{self._left_col}"
+        right_col = f"{self._table_right.__table_name__}.{self._right_col}"
+        list_ = [
+            self._by.value,  # inner join
+            self._table_right.__table_name__,  # table_name
+            "ON",
+            left_col,  # first_col
+            self._compareop,  # =
+            right_col,  # second_col
+        ]
+        return " ".join(list_)

ormlambda/databases/my_sql/clauses/limit.py

@@ -0,0 +1,17 @@
+from typing import override
+
+from ....common.interfaces.IQueryCommand import IQuery
+
+
+class LimitQuery(IQuery):
+    LIMIT = "LIMIT"
+
+    def __init__(self, number: int) -> None:
+        if not isinstance(number, int):
+            raise ValueError
+        self._number: int = number
+
+    @override
+    @property
+    def query(self) -> str:
+        return f"{self.LIMIT} {self._number}"

ormlambda/databases/my_sql/clauses/offset.py

@@ -0,0 +1,17 @@
+from typing import override
+
+from ....common.interfaces.IQueryCommand import IQuery
+
+
+class OffsetQuery(IQuery):
+    OFFSET = "OFFSET"
+
+    def __init__(self, number: int) -> None:
+        if not isinstance(number, int):
+            raise ValueError
+        self._number: int = number
+
+    @override
+    @property
+    def query(self) -> str:
+        return f"{self.OFFSET} {self._number}"

ormlambda/databases/my_sql/clauses/order.py

@@ -0,0 +1,29 @@
+from typing import override, Callable
+
+from ....utils.lambda_disassembler.tree_instruction import TreeInstruction
+from ....common.interfaces.IQueryCommand import IQuery
+from ....common.interfaces.IStatements import OrderType
+
+ASC = "ASC"
+DESC = "DESC"
+
+
+class OrderQuery[T](IQuery):
+    ORDER = "ORDER BY"
+
+    def __init__(self, instance: T, order_lambda: Callable[[T], None], order_type: OrderType) -> None:
+        if not self._valid_order_type(order_type):
+            raise Exception("order_type only can be 'ASC' or 'DESC'")
+
+        self._instance: T = instance
+        self._order_lambda: Callable[[T], None] = order_lambda
+        self._order_type: str = order_type
+        self._column: str = TreeInstruction(order_lambda).to_list()[0].nested_element.name
+
+    def _valid_order_type(self, _value: str) -> bool:
+        return _value in (ASC, DESC)
+
+    @override
+    @property
+    def query(self) -> str:
+        return f"{self.ORDER} {self._instance.__table_name__}.{self._column} {self._order_type}"

ormlambda/databases/my_sql/clauses/select.py

@@ -0,0 +1,172 @@
+from typing import Callable, Optional, Type, override
+import inspect
+
+from ....utils.lambda_disassembler import TreeInstruction, TupleInstruction, NestedElement
+from ....components.select import ISelect, TableColumn
+from ....utils import Table, ForeignKey
+from ....utils.table_constructor import TableMeta
+
+from . import JoinSelector, JoinType
+
+
+class SelectQuery[T: Table, *Ts](ISelect):
+    SELECT = "SELECT"
+
+    def __init__(
+        self,
+        tables: T | tuple[T, *Ts] = (),
+        select_lambda: Optional[Callable[[T, *Ts], None]] = lambda: None,
+        *,
+        by: JoinType = JoinType.INNER_JOIN,
+    ) -> None:
+        if not isinstance(tables, tuple):
+            tables = tuple([tables])
+
+        self._first_table: T = tables[0]
+        self._tables: tuple[T, *Ts] = tables
+        self._select_lambda: Optional[Callable[[T, *Ts], None]] = select_lambda
+        self._by: JoinType = by
+
+        self._tables_heritage: list[tuple[Table, Table]] = []
+        self._lambda_var_to_table_dicc: dict[str, Table] = self._assign_lambda_variables_to_table(select_lambda)
+
+        self._select_list: list[TableColumn] = self._rename_recursive_column_list(select_lambda)
+
+    def _rename_recursive_column_list(self, _lambda: Optional[Callable[[T], None]]) -> list[TableColumn]:
+        """
+        Recursive function tu replace variable names by Select Query
+
+        lambda a: (a.pk_address, a.city.pk_city, a.city.country.pk_country)
+
+        >>> # convert lambda expression into list of values
+        >>> select_list = [
+        >>>     "a.pk_address",
+        >>>     "a.city",
+        >>>     "a.city.pk_city",
+        >>>     "a.city.country",
+        >>>     "a.city.country.pk_country",
+        >>> ]
+        >>> result = _rename_recursive_column_list(select_list)
+        >>> print(result)
+        >>> # result = [
+        >>> #   "address.pk_address"
+        >>> #   "city.*"
+        >>> #   "city.pk_city"
+        >>> #   "country.*"
+        >>> #   "country.pk_country"
+        ]
+        """
+        instruction_list: list[TupleInstruction] = TreeInstruction(_lambda).to_list()
+        column_list: list[TableColumn] = []
+
+        for ti in instruction_list:
+            obj = self._lambda_var_to_table_dicc[ti.var]
+
+            var = obj.__table_name__
+            new_nested = ti.nested_element.parents
+            new_nested[0] = var
+            ti = TupleInstruction(var, NestedElement(new_nested))
+            self._get_parents(obj, ti, column_list)
+        return column_list
+
+    def _get_parents(self, tbl_obj: Table, tuple_inst: TupleInstruction, column_list: list[TableColumn]) -> None:
+        if self._user_want_all_col(tbl_obj, tuple_inst):
+            column_list.extend(list(TableColumn.all_columns(tbl_obj)))
+            return None
+
+        # if the 'last_el' var is a property, we'll know the user will want retrieve a column of the same instance of the 'tbl_obj'. Otherwise the user will want to get a column of the other instance
+        last_el: str = tuple_inst.nested_element.name
+        if self._user_want_column_of_the_same_table(tbl_obj, tuple_inst):
+            return column_list.append(TableColumn(tbl_obj, last_el))
+
+        parents: list[str] = tuple_inst.nested_element.parents
+        first_el = parents[1]
+        new_ti = TupleInstruction(first_el, NestedElement[str](parents[1:]))  # create new TupleInstruction from the second parent to the top
+        new_attr = self.get_attribute_of(tbl_obj, first_el)  # could be Table or property
+
+        self._add_fk_relationship(tbl_obj, new_attr)
+        return self._get_parents(new_attr, new_ti, column_list)
+
+    def _add_fk_relationship(self, t1: Table, t2: Table) -> None:
+        tuple_ = tuple([t1, t2])
+        if tuple_ not in self._tables_heritage:
+            self._tables_heritage.append(tuple_)
+        return None
+
+    @staticmethod
+    def _user_want_all_col(tbl: Table, ti: TupleInstruction) -> bool:
+        """
+        if  ti.nested_element.parents length is 1 says that the element is the table itself (table.*)
+        """
+        return issubclass(tbl.__class__, Table | TableMeta) and len(ti.nested_element.parents) == 1
+
+    def _user_want_column_of_the_same_table(self, table: Table, ti: TupleInstruction) -> bool:
+        last_el: str = ti.nested_element.name
+        first_el = ti.nested_element.parents[1]
+
+        table_attr = self.get_attribute_of(table, first_el)
+
+        return last_el in table.__dict__ and isinstance(table_attr, property)
+
+    @staticmethod
+    def get_attribute_of[TProp: Table](table: TProp, _value: str) -> Optional[TProp | property]:
+        try:
+            return getattr(table.__class__, _value)
+        except Exception:
+            return getattr(table, _value, None)
+
+    def _assign_lambda_variables_to_table(self, _lambda: Callable[[T], None]) -> dict[str, Type[Table]]:
+        """
+        return a dictionary with the lambda's parameters as keys and Type[Table] as the values
+
+
+        >>> res = _assign_lambda_variables_to_table(lambda a,ci,co: ...)
+        >>> print(res)
+        >>> # {
+        >>> #   "a": Address,
+        >>> #   "ci": City,
+        >>> #   "co": Country,
+        >>> # }
+        """
+        lambda_vars = tuple(inspect.signature(_lambda).parameters)
+
+        dicc: dict[str, Table] = {}
+        for i in range(len(lambda_vars)):
+            dicc[lambda_vars[i]] = self._tables[i]
+        return dicc
+
+    def _convert_select_list(self) -> str:
+        self._select_list = self._select_list if self._select_list else tuple(TableColumn.all_columns(self._first_table))
+
+        return ", ".join(col.column for col in self._select_list)
+
+    @override
+    @property
+    def query(self) -> str:
+        select_str = self._convert_select_list()
+        query: str = f"{self.SELECT} {select_str} FROM {self._first_table.__table_name__}"
+
+        involved_tables = self.get_involved_tables()
+        if not involved_tables:
+            return query
+
+        sub_query: str = ""
+        for l_tbl, r_tbl in involved_tables:
+            join = JoinSelector(l_tbl, r_tbl, by=self._by, where=ForeignKey.MAPPED[l_tbl][r_tbl])
+            sub_query += f" {join.query}"
+
+        query += sub_query
+        return query
+
+    @override
+    @property
+    def select_list(self) -> list[TableColumn]:
+        return self._select_list
+
+    @override
+    @property
+    def tables_heritage(self) -> list[tuple[Table, Table]]:
+        return self._tables_heritage
+
+    def get_involved_tables(self) -> tuple[tuple[Table, Table]]:
+        return tuple(self._tables_heritage)

ormlambda/databases/my_sql/clauses/update.py

@@ -0,0 +1,52 @@
+from typing import Type, override, Any
+from mysql.connector import MySQLConnection
+
+from ....components.update import UpdateQueryBase
+from ....utils import Table, Column
+from ....common.interfaces import IRepositoryBase
+from .where_condition import WhereCondition
+
+
+class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase[MySQLConnection]]):
+    def __init__(self, model: T, repository: Any, where: list[WhereCondition]) -> None:
+        super().__init__(model, repository, where)
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "UPDATE"
+
+    @override
+    def execute(self) -> None:
+        if self._where:
+            self._query += " " + WhereCondition.join_condition(*self._where)
+        return self._repository.execute_with_values(self._query, self._values)
+
+    @override
+    def update(self, dicc: Any | dict[str | property, Any]) -> None:
+        if not isinstance(dicc, dict):
+            raise TypeError
+
+        name_cols: list[str] = []
+
+        for col, value in dicc.items():
+            if isinstance(col, str):
+                string_col = col
+            else:
+                string_col = self._model.__properties_mapped__.get(col, None)
+                if not string_col:
+                    raise KeyError(f"Class '{self._model.__name__}' has not {col} mapped.")
+            if self.__is_valid__(string_col, value):
+                name_cols.append(string_col)
+                self._values.append(value)
+
+        set_query: str = ",".join(["=".join([col, "%s"]) for col in name_cols])
+
+        self._query = f"{self.CLAUSE} {self._model.__table_name__} SET {set_query}"
+        return None
+
+    def __is_valid__(self, col: str, value: Any) -> bool:
+        instance_table: Table = self._model(**{col: value})
+
+        column: Column = getattr(instance_table, f"_{col}")
+        return not column.is_auto_generated

ormlambda/databases/my_sql/clauses/upsert.py

@@ -0,0 +1,68 @@
+from typing import override, Any
+
+from ....utils import Table
+from ....components.upsert import UpsertQueryBase
+from ....common.interfaces import IRepositoryBase
+from mysql.connector import MySQLConnection
+
+from .insert import InsertQuery
+
+
+class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase[MySQLConnection]]):
+    def __init__(self, model: T, repository: Any) -> None:
+        super().__init__(model, repository)
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "ON DUPLICATE KEY UPDATE"
+
+    @override
+    def execute(self) -> None:
+        return self._repository.executemany_with_values(self._query, self._values)
+
+    @override
+    def upsert(self, instances: T | list[T]) -> None:
+        """
+        Esta funcion se enfoca para trabajar con listas, aunque el argumneto changes sea un unico diccionario.
+
+        Accedemos a la primera posicion de la lista 'changes[0]' porque en la query solo estamos poniendo marcadores de posicion, alias y nombres de columnas
+
+        EXAMPLE
+        ------
+
+        MySQL
+        -----
+
+        INSERT INTO NAME_TABLE(PK_COL,COL2)
+        VALUES
+        (1,'PABLO'),
+        (2,'MARINA') AS _val
+        ON DUPLICATE KEY UPDATE
+        COL2 = _val.COL2;
+
+        Python
+        -----
+
+        INSERT INTO NAME_TABLE(PK_COL,COL2)
+        VALUES (%s, %s') AS _val
+        ON DUPLICATE KEY UPDATE
+        COL2 = _val.COL2;
+
+        """
+        insert = InsertQuery[T](self._model, self._repository)
+        insert.insert(instances)
+
+        if isinstance(instances, Table):
+            instances = tuple([instances])
+        ALIAS = "VALUES"
+
+        cols = instances[0].get_columns()
+        pk_key = instances[0].get_pk().column_name
+
+        alternative = ", ".join([f"{col}={ALIAS}({col})" for col in cols if col != pk_key])
+        query = f"{insert._query} {self.CLAUSE} {alternative};"
+
+        self._query = query
+        self._values = insert.values
+        return None

ormlambda/databases/my_sql/clauses/where_condition.py

@@ -0,0 +1,219 @@
+from typing import Any, Callable, Optional, override
+import inspect
+
+from ....common.enums import ConditionType
+from ....utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction
+from ....common.interfaces.IQueryCommand import IQuery
+from ....components.where.abstract_where import AbstractWhere
+from ....utils import Table
+
+
+class WhereConditionByArg[TProp1, TProp2](IQuery):
+    def __init__(self, cond1: TProp1, cond2: TProp2, symbol: ConditionType) -> None:
+        self.cond1: TProp1 = cond1
+        self.cond2: TProp2 = cond2
+        self.symbol: ConditionType = symbol
+
+    @property
+    def query(self) -> str:
+        return f"WHERE {self.cond1} {self.symbol.value} {self.cond2}"
+
+
+class WhereCondition[*Inst](AbstractWhere):
+    """
+    The purpose of this class is to create 'WHERE' condition queries properly.
+
+    Args.
+        - instances: tuple[*Inst],
+            - passed all instance that we are going to use inside of `function` arg
+
+        - function: Callable[[*Inst], bool] = lambda: None,
+            - lambda function to create condition between instance variables
+        - **kwargs: Any,
+            - We use this clause by passing all the variables that we want to replace inside the lambda function.
+            When we try to disassemble the lambda function, we see that the variables were not replaced by their values.
+            Instead, we only got the variable names, not the values.
+            Due to this problem, we need to specify the correct dictionary to map variable names to their values.
+
+    >>> var = 100
+    >>> _lambda = lambda a: a.city_id <= var
+    >>> ... #Dissamble _lambda method
+    >>> parts_of_lambda = [
+    >>>     "city_id"
+    >>>     "<="
+    >>>     "var"                   <-------- We excepted 100
+    >>> ]
+    """
+
+    __slots__ = [
+        "_instances",
+        "_function",
+        "_tree",
+        "_kwargs",
+        "_lambda_param_map",
+    ]
+
+    def __init__(
+        self,
+        instances: tuple[*Inst],
+        function: Callable[[*Inst], bool] = lambda: None,
+        **kwargs: Any,
+    ) -> None:
+        self._instances: tuple[Table] = instances
+        self._function: Callable[[*Inst], bool] = function
+        self._kwargs: dict[str, tuple[*Inst]] = kwargs
+        self._tree: TreeInstruction = TreeInstruction(function)
+        self._lambda_param_map: dict[str, Table] = self._create_lambda_param_map()
+
+    def _create_lambda_param_map(self) -> dict[str, Table]:
+        """
+        The method is responsible for mapping the variables present in the lambda function so that they are replaced with the instance of the model Table.
+        """
+        assert len(lamda_param := inspect.signature(self._function).parameters) == len(self._instances)
+
+        _temp_instances = list(self._instances)[::-1]  # we copied and translated tuple instance due to pop each value in order to param
+        new_dicc: dict[str, Table] = {}
+        for param in lamda_param.keys():
+            new_dicc[param] = _temp_instances.pop()
+
+        return new_dicc
+
+    @override
+    @property
+    def query(self) -> str:
+        if len(self._tree.compare_op) == 0:
+            return self._build_with_lambda_as_column_name()
+        return self._build_with_lambda_as_condition()
+
+    def _build_with_lambda_as_column_name(self) -> str:
+        conditions, compare_sign = self.create_conditions_list_and_compare_sign()
+        c1, c2 = conditions
+        return f"{self.WHERE} {c1} {compare_sign[0]} {c2}"
+
+    def _replace_values(self, ti: TupleInstruction) -> str:
+        instance: Any = self._kwargs[ti.var]
+        if isinstance(instance, Table):
+            data = getattr(instance, ti.nested_element.name)
+        else:
+            data = instance
+
+        return f"'{data}'" if isinstance(data, str) else data
+
+    def _build_with_lambda_as_condition(self) -> Callable[[], Any]:
+        n: int = len(self._tree.compare_op)
+        dicc_selector: dict[int, Callable[[], str]] = {
+            1: self.__one_sign,
+            2: self.__two_sign,
+        }
+        return dicc_selector[n]()
+
+    def __one_sign(self) -> str:
+        """lambda x: x <= 10"""
+        (c1, c2), _ = self.create_conditions_list_and_compare_sign()
+
+        return f"{self.WHERE} {c1} {self._tree.compare_op[0]} {c2}"
+
+    def _get_table_for_tuple_instruction(self, ti: TupleInstruction) -> Optional[Table]:
+        if ti.var not in self._lambda_param_map:
+            return None
+
+        involved_tables: list[Table] = [self._lambda_param_map[ti.var]]
+
+        def get_attr_tbl(tbl: Table, class_var: str) -> Optional[Table]:
+            tbl_attrs = (tbl, class_var)
+            if hasattr(*tbl_attrs):
+                attr = getattr(*tbl_attrs)
+
+                if not isinstance(attr, property) and issubclass(attr, Table):
+                    return attr
+            return None
+
+        for name in ti.nested_element.parents[1:]:
+            attr = get_attr_tbl(involved_tables[-1], name)
+            if attr is not None:
+                involved_tables.append(attr)
+
+        return involved_tables[-1].__table_name__
+
+    def __two_sign(self) -> str:
+        """lambda x: 100 <= x <= 500"""
+        self.__valid_between_comparable_sign()
+        conds, _ = self.create_conditions_list_and_compare_sign()
+        c1, c2, c3 = conds
+        cond1 = WhereConditionByArg[str, str](c1, c2, ConditionType(self._tree.compare_op[0]))
+        cond2 = WhereConditionByArg[str, str](c2, c3, ConditionType(self._tree.compare_op[1]))
+
+        return WhereCondition.join_condition(cond1, cond2, restrictive=True)
+
+    def __valid_between_comparable_sign(self) -> bool:
+        if not len(self._tree.compare_op) == 2:
+            raise Exception("Number of comparable signs distinct from 2.")
+        return True
+
+    @classmethod
+    def join_condition(cls, *args: WhereConditionByArg, restrictive=False) -> str:
+        BY: str = "AND" if restrictive else "OR"
+        query: str = f"{cls.WHERE} "
+
+        n = len(args)
+        for i in range(n):
+            condition: IQuery = args[i]
+            query += "(" + condition.query.removeprefix(f"{cls.WHERE} ") + ")"
+            if i != n - 1:
+                query += f" {BY} "
+
+        return query
+
+    @override
+    def get_involved_tables(self) -> tuple[tuple[Table, Table]]:
+        return_involved_tables: list[tuple[Table, Table]] = []
+        involved_tables: list[Table] = [self._instances[0]]
+
+        def get_attr_tbl(instance: Table, tbl_name: str) -> Optional[Table]:
+            inst_tbl_name = (instance, tbl_name)
+            if hasattr(*inst_tbl_name):
+                attr = getattr(*inst_tbl_name)
+
+                if not isinstance(attr, property) and issubclass(attr, Table):
+                    return attr
+            return None
+
+        tables: list[str] = self._tree.to_list()[0].nested_element.parents[1:]  # Avoid lambda variable
+        for tbl_name in tables:
+            tbl = involved_tables[-1]
+            attr = get_attr_tbl(tbl, tbl_name)
+            if attr is not None:
+                involved_tables.append(attr)
+                return_involved_tables.append(tuple([tbl, attr]))
+        return tuple(return_involved_tables)
+
+    def create_conditions_list_and_compare_sign(self) -> tuple[list[str], list[str]]:
+        compare_sign: list[str] = []
+        conds: list[str] = []
+        for ti in self._tree.to_list():
+            key = ti.var
+            ne = ti.nested_element
+
+            if hasattr(ConditionType, str(ne.name)):
+                cond_type: ConditionType = getattr(ConditionType, ne.name)
+                compare_sign.append(cond_type.value)
+
+            elif key in self._kwargs:
+                conds.append(self._replace_values(ti))
+            else:
+                _name_table = self._get_table_for_tuple_instruction(ti)
+                _name_table_str = f"{_name_table}." if _name_table else ""
+
+                _name = ne.name
+                if not _name_table:
+                    _name = self._wrapp_condition_id_str(ne.name)
+
+                conds.append(f"{_name_table_str}{_name}")
+        return conds, compare_sign
+
+    def _wrapp_condition_id_str(self, name: Any):
+        if not name:
+            return "NULL"
+        if not isinstance(name, str):
+            return name
+        return f"'{name}'"