ormlambda 3.7.2__py3-none-any.whl → 3.11.1__py3-none-any.whl

ormlambda/__init__.py

@@ -20,3 +20,5 @@ from .model.base_model import (
     BaseModel as BaseModel,
     ORM as ORM,
 )  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
+
+from .engine import create_engine, URL  # noqa: F401

ormlambda/databases/my_sql/caster/caster.py

@@ -23,6 +23,7 @@ class MySQLCaster(ICaster):
             NoneType: NoneTypeCaster,
             datetime: DatetimeCaster,
             bytes: BytesCaster,
+            bytearray: BytesCaster,
             tuple: IterableCaster,
             list: IterableCaster,
         }

ormlambda/databases/my_sql/clauses/__init__.py

@@ -12,6 +12,7 @@ from .order import Order as Order
 from .update import UpdateQuery as UpdateQuery
 from .upsert import UpsertQuery as UpsertQuery
 from .where import Where as Where
+from .having import Having as Having
 from .count import Count as Count
 from .group_by import GroupBy as GroupBy
 from .alias import Alias as Alias

ormlambda/databases/my_sql/clauses/alias.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda import Table, Column
+from ormlambda import Table
 from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.common.interfaces.IQueryCommand import IQuery
-from ormlambda.sql.clause_info import ClauseInfoContext, IAggregate
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda.sql.types import TableType
 
 if tp.TYPE_CHECKING:
     from ormlambda.sql.types import ColumnType
@@ -12,23 +12,17 @@ if tp.TYPE_CHECKING:
     from ormlambda.sql.types import AliasType
 
 
-class Alias[T: Table, TProp](ClauseInfo, IQuery):
-    def __init__(
+class Alias[T: Table](ClauseInfo[T]):
+    def __init__[TProp](
         self,
-        element: IAggregate | ClauseInfo[T] | ColumnType[TProp],
-        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]],
+        table: TableType[T],
+        column: tp.Optional[ColumnType[TProp]] = None,
+        alias_table: tp.Optional[AliasType[ClauseInfo[T]]] = None,
+        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]] = None,
+        context: ClauseContextType = None,
+        keep_asterisk: bool = False,
+        preserve_context: bool = False,
     ):
-        if isinstance(element, Column):
-            context = ClauseInfoContext()
-            element = ClauseInfo(table=element.table, column=element, alias_clause=alias_clause)
-        else:
-            context = ClauseInfoContext(table_context=element.context._table_context, clause_context={})
-            element.context = context
-            element._alias_clause = alias_clause
-
-        self._element = element
-
-    @tp.override
-    @property
-    def query(self) -> str:
-        return self._element.query
+        if not alias_clause:
+            raise TypeError
+        super().__init__(table, column, alias_table, alias_clause, context, keep_asterisk, preserve_context)

ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,32 +1,31 @@
 import typing as tp
-from ormlambda.common.enums.join_type import JoinType
-from ormlambda.sql.clause_info import IAggregate
 from ormlambda import Table
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
+from ormlambda.sql.clause_info.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
+from ormlambda.sql.types import ColumnType
 
 
-class GroupBy[T: tp.Type[Table], *Ts, TProp](DecompositionQueryBase[T], IAggregate):
-    CLAUSE: str = "GROUP BY"
+class GroupBy[T: tp.Type[Table], *Ts, TProp](AggregateFunctionBase):
+    @classmethod
+    def FUNCTION_NAME(self) -> str:
+        return "GROUP BY"
 
     def __init__(
         self,
-        table: T,
-        column: tp.Callable[[T, *Ts], TProp],
-        *,
-        alias: bool = True,
-        alias_name: str | None = None,
-        by: JoinType = JoinType.INNER_JOIN,
-    ) -> None:
+        column: ColumnType,
+        context: ClauseInfoContext,
+        **kwargs,
+    ):
         super().__init__(
-            table,
-            columns=column,
-            alias=alias,
-            alias_name=alias_name,
-            by=by,
+            table=column.table,
+            column=column,
+            alias_table=None,
+            alias_clause=None,
+            context=context,
+            **kwargs,
         )
 
     @property
     def query(self) -> str:
-        col: str = ", ".join([x.query for x in self.all_clauses])
-
-        return f"{self.CLAUSE} {col}"
+        column = self._create_query()
+        return f"{self.FUNCTION_NAME()} {column}"

ormlambda/databases/my_sql/clauses/having.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .where import Where
+
+
+class Having(Where):
+    """
+    The purpose of this class is to create 'WHERE' condition queries properly.
+    """
+
+    def __init__(self, *comparer, restrictive=True, context=None):
+        super().__init__(*comparer, restrictive=restrictive, context=context)
+
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "HAVING"

ormlambda/databases/my_sql/clauses/order.py

@@ -48,13 +48,18 @@ class Order(AggregateFunctionBase):
         columns = self.unresolved_column
 
         # if this attr is not iterable means that we only pass one column without wrapped in a list or tuple
+        if isinstance(columns, str):
+            string_columns = f"{columns} {str(self._order_type[0])}"
+            return f"{self.FUNCTION_NAME()} {string_columns}"
+
         if not isinstance(columns, tp.Iterable):
             columns = (columns,)
+
         assert len(columns) == len(self._order_type)
 
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
         for index, clause in enumerate(self._convert_into_clauseInfo(columns, context)):
             clause.alias_clause = None
-            string_columns.append(f"{clause.query} {self._order_type[index].value}")
+            string_columns.append(f"{clause.query} {str(self._order_type[index])}")
 
         return f"{self.FUNCTION_NAME()} {', '.join(string_columns)}"

ormlambda/databases/my_sql/clauses/where.py

@@ -32,8 +32,8 @@ class Where(AggregateFunctionBase):
     def alias_clause(self) -> None:
         return None
 
-    @staticmethod
-    def join_condition(wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
+    @classmethod
+    def join_condition(cls, wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
         if not isinstance(wheres, tp.Iterable):
             wheres = (wheres,)
 
@@ -42,4 +42,4 @@ class Where(AggregateFunctionBase):
             for c in where._comparer:
                 c.set_context(context)
                 comparers.append(c)
-        return Where(*comparers, restrictive=restrictive, context=context).query
+        return cls(*comparers, restrictive=restrictive, context=context).query

ormlambda/databases/my_sql/functions/concat.py

@@ -1,20 +1,22 @@
+import typing as tp
+
 from ormlambda.sql.clause_info import AggregateFunctionBase
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-
-
-import typing as tp
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import ClauseInfo
 
 
-class Concat[*Ts](AggregateFunctionBase):
+type ConcatResponse[TProp] = tuple[str | ColumnType[TProp]]
+
+
+class Concat[T](AggregateFunctionBase):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "CONCAT"
 
     def __init__[TProp](
         self,
-        values: ColumnType[Ts] | tuple[ColumnType[Ts], ...],
+        values: ConcatResponse[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "concat",
         context: ClauseContextType = None,
     ) -> None:
@@ -33,6 +35,6 @@ class Concat[*Ts](AggregateFunctionBase):
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
 
         for clause in self._convert_into_clauseInfo(self.unresolved_column, context=context):
-            clause.alias_clause = None
+            clause.alias_clause = self.alias_clause
             columns.append(clause)
         return self._concat_alias_and_column(f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})", self._alias_aggregate)

ormlambda/databases/my_sql/functions/max.py

@@ -14,7 +14,7 @@ class Max(AggregateFunctionBase[None]):
 
     def __init__[TProp](
         self,
-        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        elements: ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "max",
         context: ClauseContextType = None,
     ):

ormlambda/databases/my_sql/join_context.py

@@ -27,12 +27,12 @@ class JoinContext[TParent: Table, TRepo]:
         for comparer, by in self._joins:
             fk_clause, alias = self.get_fk_clause(comparer)
 
-            foreign_key: ForeignKey = ForeignKey(comparer=comparer, clause_name=alias)
+            foreign_key: ForeignKey = ForeignKey(comparer=comparer, clause_name=alias, keep_alive=True)
             fk_clause.alias_table = foreign_key.alias
             self._context.add_clause_to_context(fk_clause)
             setattr(self._parent, alias, foreign_key)
 
-            # TODOH []: We need to preserve the 'foreign_key' variable while inside the 'with' clause.
+            # TODOH [x]: We need to preserve the 'foreign_key' variable while inside the 'with' clause.
             # Keep in mind that 'ForeignKey.stored_calls' is cleared every time we call methods like
             # .select(), .select_one(), .insert(), .update(), or .count(). This means we only retain
             # the context from the first call of any of these methods.
@@ -49,6 +49,7 @@ class JoinContext[TParent: Table, TRepo]:
             fk: ForeignKey = getattr(self._parent, attribute)
             delattr(self._parent, attribute)
             del self._context._table_context[fk.tright]
+            ForeignKey.stored_calls.remove(fk)
         return None
 
     def __getattr__(self, name: str) -> TParent:

ormlambda/databases/my_sql/repository/repository.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import contextlib
 from pathlib import Path
 from typing import Any, Generator, Iterable, Optional, Type, override, TYPE_CHECKING, Unpack
+import uuid
 import shapely as shp
 
 # from mysql.connector.pooling import MySQLConnectionPool
@@ -16,6 +17,7 @@ from ormlambda.caster import Caster
 from ..clauses import CreateDatabase, TypeExists
 from ..clauses import DropDatabase
 from ..clauses import DropTable
+from ..clauses import Alias
 
 
 if TYPE_CHECKING:
@@ -68,12 +70,15 @@ class Response[TFlavour, *Ts]:
 
     def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
         def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
+            nonlocal data
             return [dict(zip(self._columns, x)) for x in data]
 
         def _tuple(**kwargs) -> list[tuple[*Ts]]:
+            nonlocal data
             return data
 
         def _set(**kwargs) -> list[set]:
+            nonlocal data
             for d in data:
                 n = len(d)
                 for i in range(n):
@@ -84,12 +89,19 @@ class Response[TFlavour, *Ts]:
             return [set(x) for x in data]
 
         def _list(**kwargs) -> list[list]:
+            nonlocal data
             return [list(x) for x in data]
 
         def _default(**kwargs) -> list[TFlavour]:
-            replacer_dicc: dict[str, str] = {x.alias_clause: x.column for x in self._select.all_clauses}
+            nonlocal data
+            replacer_dicc: dict[str, str] = {}
 
-            cleaned_column_names = [replacer_dicc[col] for col in self._columns]
+            for col in self._select.all_clauses:
+                if hasattr(col, "_alias_aggregate") or col.alias_clause is None or isinstance(col, Alias):
+                    continue
+                replacer_dicc[col.alias_clause] = col.column
+
+            cleaned_column_names = [replacer_dicc.get(col, col) for col in self._columns]
 
             result = []
             for attr in data:
@@ -157,7 +169,34 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
     #
 
     def __init__(self, **kwargs: Unpack[MySQLArgs]):
-        super().__init__(MySQLConnectionPool, **kwargs)
+        timeout = self.__add_connection_timeout(kwargs)
+        name = self.__add_pool_name(kwargs)
+        size = self.__add_pool_size(kwargs)
+        attr = kwargs.copy()
+        attr["connection_timeout"] = timeout
+        attr["pool_name"] = name
+        attr["pool_size"] = size
+
+        super().__init__(MySQLConnectionPool, **attr)
+
+    @staticmethod
+    def __add_connection_timeout(kwargs: MySQLArgs) -> int:
+        if "connection_timeout" not in kwargs.keys():
+            return 60
+        return int(kwargs.pop("connection_timeout"))
+
+    @staticmethod
+    def __add_pool_name(kwargs: MySQLArgs) -> str:
+        if "pool_name" not in kwargs.keys():
+            return str(uuid.uuid4())
+
+        return kwargs.pop("pool_name")
+
+    @staticmethod
+    def __add_pool_size(kwargs: MySQLArgs) -> int:
+        if "pool_size" not in kwargs.keys():
+            return 5
+        return int(kwargs.pop("pool_size"))
 
     @contextlib.contextmanager
     def get_connection(self) -> Generator[MySQLConnection, None, None]:
@@ -254,7 +293,6 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     @override
     def database_exists(self, name: str) -> bool:
-        query = "SHOW DATABASES LIKE %s;"
         temp_config = self._pool._cnx_config
 
         config_without_db = temp_config.copy()
@@ -262,10 +300,11 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
         if "database" in config_without_db:
             config_without_db.pop("database")
         self._pool.set_config(**config_without_db)
+
         with self.get_connection() as cnx:
             with cnx.cursor(buffered=True) as cursor:
-                cursor.execute(query, (name,))
-            res = cursor.fetchmany(1)
+                cursor.execute("SHOW DATABASES LIKE %s;", (name,))
+                res = cursor.fetchmany(1)
 
         self._pool.set_config(**temp_config)
         return len(res) > 0
@@ -276,12 +315,11 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     @override
     def table_exists(self, name: str) -> bool:
-        query = "SHOW TABLES LIKE %s;"
         with self.get_connection() as cnx:
             if not cnx.database:
                 raise Exception("No database selected")
             with cnx.cursor(buffered=True) as cursor:
-                cursor.execute(query, (name,))
+                cursor.execute("SHOW TABLES LIKE %s;", (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
 
@@ -297,9 +335,17 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     @property
     def database(self) -> Optional[str]:
-        return self._data_config.get("database", None)
+        return self._pool._cnx_config.get("database", None)
 
     @database.setter
     def database(self, value: str) -> None:
-        self._data_config["database"] = value
-        self._pool.set_config(**self._data_config)
+        """Change the current database using USE statement"""
+
+        if not self.database_exists(value):
+            raise ValueError(f"You cannot set the non-existent '{value}' database.")
+
+        old_config: MySQLArgs = self._pool._cnx_config.copy()
+        old_config["database"] = value
+
+        self._pool._remove_connections()
+        self._pool = type(self)(**old_config)._pool

ormlambda/databases/my_sql/statements.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Concatenate, Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
+from typing import Concatenate, Iterable, TypedDict, override, Type, TYPE_CHECKING, Any, Callable, Optional
 from mysql.connector import errors, errorcode
 
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
@@ -14,6 +14,7 @@ if TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.statements.types import OrderTypes
     from ormlambda.sql.types import ColumnType
+    from ormlambda.statements.types import SelectCols
     from ormlambda.repository.interfaces import IRepositoryBase
     from ormlambda.statements.interfaces import IStatements_two_generic
     from ormlambda.repository.interfaces.IRepositoryBase import TypeExists
@@ -28,11 +29,12 @@ from .clauses import InsertQuery
 from .clauses import Limit
 from .clauses import Offset
 from .clauses import Order
-from .clauses.select import Select
+from .clauses import Select
 
 from .clauses import UpsertQuery
 from .clauses import UpdateQuery
 from .clauses import Where
+from .clauses import Having
 from .clauses import Count
 from .clauses import GroupBy
 from .clauses import Alias
@@ -60,12 +62,23 @@ def clear_list[T, **P](f: Callable[Concatenate[MySQLStatements, P], T]) -> Calla
     return wrapper
 
 
+class OrderType(TypedDict):
+    Select: Select
+    JoinSelector: JoinSelector
+    Where: Where
+    Order: Order
+    GroupBy: GroupBy
+    Having: Having
+    Limit: Limit
+    Offset: Offset
+
+
 class QueryBuilder(IQuery):
-    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "Order", "GroupBy", "Limit", "Offset")
+    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
 
     def __init__(self, by: JoinType = JoinType.INNER_JOIN):
         self._context = ClauseInfoContext()
-        self._query_list: dict[str, IQuery] = {}
+        self._query_list: OrderType = {}
         self._by = by
 
         self._joins: Optional[IQuery] = None
@@ -113,6 +126,15 @@ class QueryBuilder(IQuery):
     def GROUP_BY(self) -> IQuery:
         return self._query_list.get("GroupBy", None)
 
+    @property
+    def HAVING(self) -> IQuery:
+        where = self._query_list.get("Having", None)
+        if not isinstance(where, Iterable):
+            if not where:
+                return ()
+            return (where,)
+        return where
+
     @property
     def LIMIT(self) -> IQuery:
         return self._query_list.get("Limit", None)
@@ -133,8 +155,9 @@ class QueryBuilder(IQuery):
             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,
+            Having.join_condition(self.HAVING, True, self._context) if self.HAVING else None,
+            self.ORDER.query if self.ORDER else None,
             self.LIMIT.query if self.LIMIT else None,
             self.OFFSET.query if self.OFFSET else None,
         )
@@ -154,8 +177,8 @@ class QueryBuilder(IQuery):
         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()
+        for fk in ForeignKey.stored_calls.copy():
+            fk = ForeignKey.stored_calls.pop(fk)
             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)
@@ -267,55 +290,83 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return self
 
     @override
-    def count(
+    def count[TProp](
         self,
-        selection: None | Iterable[Table] | Callable[[T], tuple] = lambda x: "*",
-        alias_clause="count",
+        selection: None | SelectCols[T,TProp] = lambda x: "*",
+        alias="count",
         execute: bool = False,
     ) -> Optional[int]:
         if execute is True:
-            return self.select_one(self.count(selection, alias_clause, False), flavour=dict)[alias_clause]
+            return self.select_one(self.count(selection, alias, False), flavour=dict)[alias]
 
-        if GlobalChecker.is_lambda_function(selection):
-            selection = selection(*self.models)
-        return Count[T](element=selection, alias_clause=alias_clause, context=self._query_builder._context)
+        selection = GlobalChecker.resolved_callback_object(selection, self.models)
+        return Count(element=selection, alias_clause=alias, context=self._query_builder._context)
 
     @override
     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 GlobalChecker.is_lambda_function(conditions):
-            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        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 having(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
+        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        if not isinstance(conditions, Iterable):
+            conditions = (conditions,)
+        self._query_builder.add_statement(Having(*conditions))
+        return self
+
     @override
     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
+        query = GlobalChecker.resolved_callback_object(columns, self._models)
         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:
-        return func.Concat[T](self._model, selector, alias=alias, alias_name=alias_name, context=self._query_builder._context)
+    def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate:
+        return func.Concat[T](
+            values=selector,
+            alias_clause=alias,
+            context=self._query_builder._context,
+        )
 
     @override
-    def max[TProp](self, column: Callable[[T], TProp], alias: str = "max", execute: bool = False) -> TProp:
+    def max[TProp](
+        self,
+        column: SelectCols[T, TProp],
+        alias: str = "max",
+        execute: bool = False,
+    ) -> int:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
         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: str = "min", execute: bool = False) -> TProp:
+    def min[TProp](
+        self,
+        column: SelectCols[T, TProp],
+        alias: str = "min",
+        execute: bool = False,
+    ) -> int:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
         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: str = "sum", execute: bool = False) -> TProp:
+    def sum[TProp](
+        self,
+        column: SelectCols[T, TProp],
+        alias: str = "sum",
+        execute: bool = False,
+    ) -> int:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
         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)
@@ -334,7 +385,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         by: JoinType = JoinType.INNER_JOIN,
         **kwargs,
     ):
-        select_clause = GlobalChecker.resolved_callback_object(selector, self._models) if GlobalChecker.is_lambda_function(selector) else selector
+        select_clause = GlobalChecker.resolved_callback_object(selector, self._models)
 
         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
@@ -406,16 +457,17 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         )
 
     @override
-    def group_by(self, column: str | Callable[[T, *Ts], Any]):
-        if isinstance(column, str):
-            groupby = GroupBy[T, tuple[*Ts]](self._models, lambda x: column)
-        else:
-            groupby = GroupBy[T, tuple[*Ts]](self._models, column)
+    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T, *Ts], Any]):
+        groupby = GroupBy(column=column, context=self._query_builder._context)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
         self._query_builder.add_statement(groupby)
         return self
 
     @override
-    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)
+    def alias[TProp](self, column: ColumnType[TProp], alias: str) -> ClauseInfo[T, TProp]:
+        return Alias(
+            table=column.table,
+            column=column,
+            alias_clause=alias,
+            context=self._query_builder._context,
+        )

ormlambda/engine/__init__.py

@@ -0,0 +1,2 @@
+from .create import create_engine  # noqa: F401
+from .url import URL  # noqa: F401

ormlambda/engine/create.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+from ormlambda.engine.url import URL, make_url
+from ormlambda import BaseRepository
+
+
+def create_engine(url: URL | str, **kwargs: Any) -> BaseRepository:
+    from ormlambda.databases import MySQLRepository
+
+    # create url.URL object
+    u = make_url(url)
+    url, kwargs = u._instantiate_plugins(kwargs)
+
+    repo_selector = {
+        "mysql": MySQLRepository,
+    }
+
+    if url.drivername not in repo_selector:
+        raise ValueError(f"drivername '{url.drivername}' not expected to load Repository class")
+
+    default_config = {
+        "user": url.username,
+        "password": url.password,
+        "host": url.host,
+        "database": url.database,
+        **kwargs,
+    }
+
+    if url.port:
+        try:
+            default_config["port"] = int(url.port)
+        except ValueError:
+            raise ValueError(f"The port must be an int. '{url.port}' passed.")
+
+    return repo_selector[url.drivername](**default_config)