ormlambda 2.11.2__py3-none-any.whl → 3.7.0__py3-none-any.whl

ormlambda/databases/my_sql/statements.py

@@ -1,62 +1,188 @@
 from __future__ import annotations
-from typing import Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
-import inspect
-from mysql.connector import MySQLConnection, errors, errorcode
-import functools
+from typing import Concatenate, Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
+from mysql.connector import errors, errorcode
+
+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 mysql.connector import MySQLConnection
 
 
 if TYPE_CHECKING:
     from ormlambda import Table
-    from ormlambda.components.where.abstract_where import AbstractWhere
-    from ormlambda.common.interfaces.IStatements import OrderTypes
-    from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
-    from ormlambda.common.interfaces.IRepositoryBase import TypeExists
-    from ormlambda.common.interfaces import IAggregate
-    from ormlambda.common.interfaces.IStatements import WhereTypes
+    from ormlambda.statements.types import OrderTypes
+    from ormlambda.sql.types import ColumnType
+    from ormlambda.repository.interfaces import IRepositoryBase
+    from ormlambda.statements.interfaces import IStatements_two_generic
+    from ormlambda.repository.interfaces.IRepositoryBase import TypeExists
+    from ormlambda.sql.clause_info import IAggregate
+    from ormlambda.statements.types import WhereTypes
 
-from ormlambda.utils.foreign_key import ForeignKey
 
-from ormlambda import AbstractSQLStatements
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.statements import BaseStatement
 from .clauses import DeleteQuery
 from .clauses import InsertQuery
-from .clauses import JoinSelector
-from .clauses import LimitQuery
-from .clauses import OffsetQuery
-from .clauses import OrderQuery
+from .clauses import Limit
+from .clauses import Offset
+from .clauses import Order
 from .clauses.select import Select
 
 from .clauses import UpsertQuery
 from .clauses import UpdateQuery
-from .clauses import WhereCondition
+from .clauses import Where
 from .clauses import Count
 from .clauses import GroupBy
 from .clauses import Alias
 
 
-from ormlambda.utils import Table
+from ormlambda import Table, Column
 from ormlambda.common.enums import JoinType
 from . import functions as func
+from .join_context import JoinContext, TupleJoinType
+from ormlambda.common.global_checker import GlobalChecker
 
 
 # COMMENT: It's so important to prevent information generated by other tests from being retained in the class.
-def clear_list(f: Callable[..., Any]):
-    @functools.wraps(f)
-    def wrapper(self: MySQLStatements, *args, **kwargs):
+@staticmethod
+def clear_list[T, **P](f: Callable[Concatenate[MySQLStatements, P], T]) -> Callable[P, T]:
+    def wrapper(self: MySQLStatements, *args: P.args, **kwargs: P.kwargs) -> T:
         try:
             return f(self, *args, **kwargs)
+        except Exception as err:
+            raise err
         finally:
-            self._query_list.clear()
+            ForeignKey.stored_calls.clear()
+            self._query_builder.clear()
 
     return wrapper
 
 
-class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnection]):
-    def __init__(self, model: tuple[T, *Ts], repository: IRepositoryBase[MySQLConnection]) -> None:
+class QueryBuilder(IQuery):
+    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "Order", "GroupBy", "Limit", "Offset")
+
+    def __init__(self, by: JoinType = JoinType.INNER_JOIN):
+        self._context = ClauseInfoContext()
+        self._query_list: dict[str, IQuery] = {}
+        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 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.ORDER.query if self.ORDER else None,
+            self.GROUP_BY.query if self.GROUP_BY 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 _ in range(len(ForeignKey.stored_calls)):
+            fk = ForeignKey.stored_calls.pop()
+            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
+
+
+class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
+    def __init__(self, model: tuple[T, *Ts], repository: IRepositoryBase) -> None:
         super().__init__(model, repository=repository)
+        self._query_builder = QueryBuilder()
 
     @property
     @override
-    def repository(self) -> IRepositoryBase[MySQLConnection]:
+    def repository(self) -> IRepositoryBase:
         return self._repository
 
     @override
@@ -107,7 +233,7 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
         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
+        # not necessary to call self._query_builder.clear() because select() method already call it
         return None
 
     @override
@@ -121,7 +247,7 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
     @override
     @clear_list
     def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
-        update = UpdateQuery(self._model, self._repository, self._query_list["where"])
+        update = UpdateQuery(self._model, self._repository, self._query_builder.WHERE)
         update.update(dicc)
         update.execute()
 
@@ -129,131 +255,138 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
 
     @override
     def limit(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
-        limit = LimitQuery(number)
+        limit = Limit(number)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
-        self._query_list["limit"] = [limit]
+        self._query_builder.add_statement(limit)
         return self
 
     @override
     def offset(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
-        offset = OffsetQuery(number)
-        self._query_list["offset"] = [offset]
+        offset = Offset(number)
+        self._query_builder.add_statement(offset)
         return self
 
     @override
     def count(
         self,
-        selection: Callable[[T], tuple] = lambda x: "*",
-        alias=True,
-        alias_name="count",
-    ) -> IQuery:
-        return Count[T](self._model, selection, alias=alias, alias_name=alias_name)
+        selection: None | Iterable[Table] | Callable[[T], tuple] = lambda x: "*",
+        alias_clause="count",
+        execute: bool = False,
+    ) -> Optional[int]:
+        if execute is True:
+            return self.select_one(self.count(selection, alias_clause, False), flavour=dict)[alias_clause]
+
+        if GlobalChecker.is_lambda_function(selection):
+            selection = selection(*self.models)
+        return Count[T](element=selection, alias_clause=alias_clause, context=self._query_builder._context)
 
     @override
-    def where(self, conditions: WhereTypes = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
+    def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
 
-        if isinstance(conditions, Iterable):
-            for x in conditions:
-                self._query_list["where"].append(WhereCondition[T](function=x, instances=self._models, **kwargs))
-            return self
-
-        where_query = WhereCondition[T](function=conditions, instances=self._models, **kwargs)
-        self._query_list["where"].append(where_query)
+        if GlobalChecker.is_lambda_function(conditions):
+            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        if not isinstance(conditions, Iterable):
+            conditions = (conditions,)
+        self._query_builder.add_statement(Where(*conditions))
         return self
 
     @override
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
-        order = OrderQuery[T](self._model, _lambda_col, order_type)
-        self._query_list["order"].append(order)
+    def order[TValue](self, columns: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
+        query = GlobalChecker.resolved_callback_object(columns, self._models) if GlobalChecker.is_lambda_function(columns) else columns
+        order = Order(query, order_type)
+        self._query_builder.add_statement(order)
         return self
 
     @override
-    def concat[*Ts](self, selector: Callable[[T], tuple[*Ts]], alias: bool = True, alias_name: str = "CONCAT") -> IAggregate[T]:
-        return func.Concat[T](self._model, selector, alias=alias, alias_name=alias_name)
+    def concat[*Ts](self, selector: Callable[[T], tuple[*Ts]], alias: bool = True, alias_name: str = "CONCAT") -> IAggregate:
+        return func.Concat[T](self._model, selector, alias=alias, alias_name=alias_name, context=self._query_builder._context)
 
     @override
-    def max[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "max") -> TProp:
-        return func.Max[T](self._model, column=column, alias=alias, alias_name=alias_name)
+    def max[TProp](self, column: Callable[[T], TProp], alias: str = "max", execute: bool = False) -> TProp:
+        if execute is True:
+            return self.select_one(self.max(column, alias, execute=False), flavour=dict)[alias]
+        return func.Max(elements=column, alias_clause=alias, context=self._query_builder._context)
 
     @override
-    def min[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "min") -> TProp:
-        return func.Min[T](self._model, column=column, alias=alias, alias_name=alias_name)
+    def min[TProp](self, column: Callable[[T], TProp], alias: str = "min", execute: bool = False) -> TProp:
+        if execute is True:
+            return self.select_one(self.min(column, alias, execute=False), flavour=dict)[alias]
+        return func.Min(elements=column, alias_clause=alias, context=self._query_builder._context)
 
     @override
-    def sum[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "sum") -> TProp:
-        return func.Sum[T](self._model, column=column, alias=alias, alias_name=alias_name)
+    def sum[TProp](self, column: Callable[[T], TProp], alias: str = "sum", execute: bool = False) -> TProp:
+        if execute is True:
+            return self.select_one(self.sum(column, alias, execute=False), flavour=dict)[alias]
+        return func.Sum(elements=column, alias_clause=alias, context=self._query_builder._context)
 
     @override
-    def join[*FKTables](
-        self,
-        table: Optional[T] = None,
-        relation: Optional[WhereCondition[T, *FKTables]] = None,
-        join_type: Optional[JoinType] = None,
-    ) -> IStatements_two_generic[T, *FKTables, MySQLConnection]:
-        if isinstance(table, type) and issubclass(table, Table):
-            joins = ((table, relation, join_type),)
-        else:
-            if any(len(x) != 3 for x in table):
-                raise ValueError("Each tuple inside of 'join' method must contain the referenced table, relation between columns and join type")
-            joins = table
-
-        new_tables: list[Type[Table]] = [self._model]
-
-        for table, where, by in joins:
-            new_tables.append(table)
-            join_query = JoinSelector[T, type(table)](self._model, table, by=by, where=where)
-            self._query_list["join"].append(join_query)
-        self._models = new_tables
-        return self
+    def join[LTable: Table, LProp, RTable: Table, RProp](self, joins: tuple[TupleJoinType[LTable, LProp, RTable, RProp]]) -> JoinContext[tuple[*TupleJoinType[LTable, LProp, RTable, RProp]]]:
+        return JoinContext(self, joins, self._query_builder._context)
 
     @override
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN, **kwargs):
-        if len(inspect.signature(selector).parameters) == 0:
+    @clear_list
+    def select[TValue, TFlavour, *Ts](
+        self,
+        selector: Optional[tuple[TValue, *Ts]] = None,
+        *,
+        flavour: Optional[Type[TFlavour]] = None,
+        by: JoinType = JoinType.INNER_JOIN,
+        **kwargs,
+    ):
+        select_clause = GlobalChecker.resolved_callback_object(selector, self._models) if GlobalChecker.is_lambda_function(selector) else selector
+
+        if selector is None:
             # 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)
+            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]
 
-        joins = self._query_list.pop("join", None)
         select = Select[T, *Ts](
             self._models,
-            lambda_query=selector,
-            by=by,
-            alias=False,
-            joins=joins,
+            columns=select_clause,
         )
-        self._query_list["select"].append(select)
+        self._query_builder.add_statement(select)
 
-        self._query: str = self._build()
+        self._query_builder.by = by
+        self._query: str = self._query_builder.query
 
+        self._query_builder.clear()
         if flavour:
             result = self._return_flavour(self.query, flavour, select, **kwargs)
-            if issubclass(flavour, tuple) and isinstance(selector(*self._models), property):
+            if issubclass(flavour, tuple) and isinstance(select_clause, Column | ClauseInfo):
                 return tuple([x[0] for x in result])
             return result
         return self._return_model(select, self.query)
 
     @override
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[tuple[TValue, *Ts]] = 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)
 
+        response = self.select(selector=selector, flavour=flavour, by=by)
+
+        if not isinstance(response, Iterable):
+            return response
         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]
+        # FIXME [x]: before it was if len(response) == 1 and len(response[0]) == 1: return response[0][0]
+        if len(response) == 1:
+            if isinstance(response[0], Iterable) and len(response[0]) == 1:
+                return response[0][0]
+            else:
+                return response[0]
         return tuple([res[0] for res in response])
 
+    @override
+    def first[TValue, *Ts](self, selector: Optional[tuple[TValue, *Ts]] = None):
+        return self.select_one(selector)
+
     @override
     def group_by(self, column: str | Callable[[T, *Ts], Any]):
         if isinstance(column, str):
@@ -261,65 +394,10 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
         else:
             groupby = GroupBy[T, tuple[*Ts]](self._models, column)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
-        self._query_list["group by"].append(groupby)
+        self._query_builder.add_statement(groupby)
         return self
 
     @override
-    def alias(self, column: Callable[[T, *Ts], Any], alias: str) -> IStatements_two_generic[T, *Ts, MySQLConnection]:
-        return Alias[T, *Ts](self.models, column, alias_name=alias)
-
-    @override
-    @clear_list
-    def _build(self) -> str:
-        query_list: list[str] = []
-        for x in self.__order__:
-            if len(self._query_list) == 0:
-                break
-
-            sub_query: Optional[list[IQuery]] = self._query_list.pop(x, None)
-            if sub_query is None:
-                continue
-
-            if isinstance(sub_query[0], WhereCondition):
-                query_ = self.__build_where_clause(sub_query)
-
-            elif isinstance((select := sub_query[0]), Select):
-                query_: str = ""
-                where_joins = self.__create_necessary_inner_join()
-                if where_joins:
-                    select._joins.update(where_joins)
-                query_ = select.query
-
-            else:
-                query_ = "\n".join([x.query for x in sub_query])
-
-            query_list.append(query_)
-        return "\n".join(query_list)
-
-    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) -> Optional[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 "where" not in self._query_list:
-            return None
-
-        for where in self._query_list["where"]:
-            where: AbstractWhere
-
-            tables = where.get_involved_tables()
-
-            if tables:
-                # FIXME [ ]: Refactor to avoid copy and paste the same code of the '_add_fk_relationship' method
-                joins = []
-                for ltable, rtable in tables:
-                    lambda_relationship = ForeignKey.MAPPED[ltable.__table_name__].referenced_tables[rtable.__table_name__].relationship
-                    joins.append(JoinSelector(ltable, rtable, JoinType.INNER_JOIN, where=lambda_relationship))
-                return set(joins)
-        return None
+    def alias[TProp](self, column: ColumnType[TProp], alias: str) -> Alias[T, TProp]:
+        ci = ClauseInfo(table=column.table, column=column, alias_clause=alias, context=self._query_builder._context)
+        return Alias(ci, alias_clause=alias)

ormlambda/engine/template.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Type
+
+if TYPE_CHECKING:
+    from ormlambda.repository import IRepositoryBase
+    from ormlambda.statements.interfaces import IStatements
+    from ormlambda.caster import ICaster
+
+
+class Template[TCnx]:
+    repository: Type[IRepositoryBase]
+    caster: Type[ICaster]
+    statement: Type[IStatements]
+
+
+class RepositoryTemplateDict[TRepo]:
+    _instance: Optional[RepositoryTemplateDict[TRepo]] = None
+
+    def __new__[T: Template](cls):
+        if cls._instance is not None:
+            return cls._instance
+
+        cls._instance = super().__new__(cls)
+
+        from ..databases.my_sql import (
+            MySQLCaster,
+            MySQLRepository,
+            MySQLStatements,
+        )
+
+        class MySQLTemplate[TCnx](Template[TCnx]):
+            repository = MySQLRepository
+            caster = MySQLCaster
+            statement = MySQLStatements
+
+        # FIXME [ ]: should return T instead of Template
+        cls._data: dict[IRepositoryBase, Template] = {
+            MySQLRepository: MySQLTemplate,
+        }
+
+        return cls._instance
+
+    # FIXME [ ]: should return T instead of Template
+    def get[T: Template](self, key: IRepositoryBase) -> Template:
+        key = key if isinstance(key, type) else type(key)
+        return self._instance._data[key]

ormlambda/model/base_model.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+
+from typing import TYPE_CHECKING, Type
+
+from ormlambda.engine.template import RepositoryTemplateDict
+
+if TYPE_CHECKING:
+    from ormlambda.statements.interfaces import IStatements_two_generic
+    from ormlambda.repository import BaseRepository
+
+
+# endregion
+
+
+class BaseModel[T]:
+    """
+    Class to select the correct BaseStatement class depends on the repository.
+
+    Contiene los metodos necesarios para hacer consultas a una tabla
+    """
+
+    # region Constructor
+
+    def __new__[TPool](cls, model: Type[T], repository: BaseRepository[TPool]) -> IStatements_two_generic[T, TPool]:
+        if repository is None:
+            raise ValueError("`None` cannot be passed to the `repository` attribute when calling the `BaseModel` class")
+
+        new_cls = RepositoryTemplateDict().get(repository).statement
+
+        if not new_cls:
+            raise Exception(f"The selected repository '{repository}' does not exist.")
+
+        return new_cls(model, repository)
+
+
+ORM = BaseModel

ormlambda/repository/__init__.py

@@ -0,0 +1,2 @@
+from .interfaces import IRepositoryBase  # noqa: F401
+from .base_repository import BaseRepository  # noqa: F401

ormlambda/repository/base_repository.py

@@ -0,0 +1,14 @@
+import contextlib
+from typing import Generator, Type
+from ormlambda.repository import IRepositoryBase
+import abc
+
+
+class BaseRepository[TPool](IRepositoryBase):
+    def __init__(self, pool: Type[TPool], **kwargs: str) -> None:
+        self._data_config: dict[str, str] = kwargs
+        self._pool: TPool = pool(**kwargs)
+
+    @contextlib.contextmanager
+    @abc.abstractmethod
+    def get_connection[TCnx](self) -> Generator[TCnx, None, None]: ...

ormlambda/repository/interfaces/IDatabaseConnection.py

@@ -0,0 +1,12 @@
+import abc
+
+
+class IDatabaseConnection[TCnx](abc.ABC):
+    @abc.abstractmethod
+    def cursor(self, **kwargs): ...
+    @abc.abstractmethod
+    def commit(self): ...
+    @abc.abstractmethod
+    def rollback(self): ...
+    @abc.abstractmethod
+    def get_connection(self) -> TCnx: ...

ormlambda/{common → repository}/interfaces/IRepositoryBase.py

@@ -1,15 +1,16 @@
+from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Literal, Optional, Type
+from typing import Optional, Type, Iterable, TYPE_CHECKING
 
-TypeExists = Literal["fail", "replace", "append"]
+if TYPE_CHECKING:
+    from ormlambda.statements.types import TypeExists
 
-
-class IRepositoryBase[T](ABC):
+class IRepositoryBase(ABC):
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"
 
     @abstractmethod
-    def read_sql[TFlavour](self, cnx: T, query: str, flavour: Optional[Type[TFlavour]], **kwargs) -> tuple[TFlavour]: ...
+    def read_sql[TFlavour: Iterable](self, query: str, flavour: Optional[Type[TFlavour]], **kwargs) -> tuple[TFlavour]: ...
 
     @abstractmethod
     def executemany_with_values(self, query: str, values) -> None: ...

ormlambda/repository/interfaces/__init__.py

@@ -0,0 +1,2 @@
+from .IRepositoryBase import IRepositoryBase  # noqa: F401
+from .IDatabaseConnection import IDatabaseConnection  # noqa: F401

ormlambda/sql/__init__.py

@@ -0,0 +1,3 @@
+from .column import Column as Column
+from .foreign_key import ForeignKey as ForeignKey
+from .table import Table as Table

ormlambda/sql/clause_info/__init__.py

@@ -0,0 +1,3 @@
+from .interface import IAggregate  # noqa: F401
+from .clause_info import ClauseInfo, AggregateFunctionBase  # noqa: F401
+from .clause_info_context import ClauseContextType, ClauseInfoContext  # noqa: F401