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

ormlambda/databases/my_sql/statements.py

@@ -1,23 +1,21 @@
 from __future__ import annotations
-from typing import Concatenate, Iterable, TypedDict, override, Type, TYPE_CHECKING, Any, Callable, Optional
+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.sql.types import AliasType
     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.repository import BaseRepository
     from ormlambda.statements.interfaces import IStatements_two_generic
-    from ormlambda.repository.interfaces.IRepositoryBase import TypeExists
+    from ormlambda.statements.types import TypeExists
     from ormlambda.sql.clause_info import IAggregate
     from ormlambda.statements.types import WhereTypes
 
@@ -43,8 +41,10 @@ from .clauses import Alias
 from ormlambda import Table, Column
 from ormlambda.common.enums import JoinType
 from . import functions as func
-from .join_context import JoinContext, TupleJoinType
+from ormlambda.components.join import JoinContext, TupleJoinType
+
 from ormlambda.common.global_checker import GlobalChecker
+from .query_builder import QueryBuilder
 
 
 # COMMENT: It's so important to prevent information generated by other tests from being retained in the class.
@@ -62,152 +62,11 @@ 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", "GroupBy", "Having", "Order", "Limit", "Offset")
-
-    def __init__(self, by: JoinType = JoinType.INNER_JOIN):
-        self._context = ClauseInfoContext()
-        self._query_list: OrderType = {}
-        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 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)
-
-    @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.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,
-        )
-        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 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)
-
-        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:
+    def __init__(self, model: tuple[T, *Ts], repository: BaseRepository) -> None:
         super().__init__(model, repository=repository)
         self._query_builder = QueryBuilder()
 
-    @property
-    @override
-    def repository(self) -> IRepositoryBase:
-        return self._repository
-
     @override
     def create_table(self, if_exists: TypeExists = "fail") -> None:
         name: str = self._model.__table_name__
@@ -231,10 +90,6 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         self._repository.execute(query)
         return None
 
-    @override
-    def table_exists(self) -> bool:
-        return self._repository.table_exists(self._model.__table_name__)
-
     @override
     @clear_list
     def insert(self, instances: T | list[T]) -> None:
@@ -292,7 +147,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def count[TProp](
         self,
-        selection: None | SelectCols[T,TProp] = lambda x: "*",
+        selection: None | SelectCols[T, TProp] = lambda x: "*",
         alias="count",
         execute: bool = False,
     ) -> Optional[int]:
@@ -385,6 +240,9 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         by: JoinType = JoinType.INNER_JOIN,
         **kwargs,
     ):
+        if "alias" in kwargs:
+            alias = kwargs.pop("alias")
+            kwargs["alias_clause"] = alias
         select_clause = GlobalChecker.resolved_callback_object(selector, self._models)
 
         if selector is None:
@@ -399,6 +257,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         select = Select[T, *Ts](
             self._models,
             columns=select_clause,
+            **kwargs,
         )
         self._query_builder.add_statement(select)
 
@@ -457,14 +316,18 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         )
 
     @override
-    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T, *Ts], Any]):
+    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T, *Ts], Any]) -> IStatements_two_generic[T]:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
+
         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) -> ClauseInfo[T, TProp]:
+    def alias[TProp](self, column: SelectCols[T, TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
+
         return Alias(
             table=column.table,
             column=column,

ormlambda/engine/__init__.py

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

ormlambda/engine/url.py

@@ -1,6 +1,7 @@
 """
 URL class extracted from SQLAlchemy
 """
+
 from __future__ import annotations
 
 import re
@@ -27,7 +28,9 @@ from urllib.parse import (
 
 from . import utils
 
-type DrivernameType = Literal['mysql'] | str
+type DrivernameType = Literal["mysql"] | str
+
+
 class URL(NamedTuple):
     """
     Represent the components of a URL used to connect to a database.

ormlambda/sql/clause_info/__init__.py

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

ormlambda/sql/clause_info/aggregate_function_base.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+import abc
+import typing as tp
+
+from ormlambda import Table
+from ormlambda import Column
+from ormlambda.sql.types import (
+    TableType,
+    ColumnType,
+    AliasType,
+)
+from .interface import IAggregate
+from ormlambda.common.errors import NotKeysInIAggregateError
+from ormlambda.sql import ForeignKey
+from ormlambda.sql.table import TableMeta
+from .clause_info import ClauseInfo
+from .clause_info_context import ClauseContextType
+
+
+class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
+    def __init__[TProp: Column](
+        self,
+        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,
+    ):
+        self._alias_aggregate = alias_clause
+        super().__init__(
+            table=table,
+            column=column,
+            alias_table=alias_table,
+            context=context,
+            keep_asterisk=keep_asterisk,
+            preserve_context=preserve_context,
+        )
+
+    @staticmethod
+    @abc.abstractmethod
+    def FUNCTION_NAME() -> str: ...
+
+    @classmethod
+    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType) -> list[ClauseInfo]:
+        type DEFAULT = tp.Literal["default"]
+        type ClusterType = ColumnType | ForeignKey | DEFAULT
+
+        dicc_type: dict[ClusterType, tp.Callable[[ClusterType], ClauseInfo]] = {
+            Column: lambda column: ClauseInfo(column.table, column, context=context),
+            ClauseInfo: lambda column: column,
+            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context),
+            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context),
+            "default": lambda column: ClauseInfo(table=None, column=column, context=context),
+        }
+        all_clauses: list[ClauseInfo] = []
+        if isinstance(columns, str) or not isinstance(columns, tp.Iterable):
+            columns = (columns,)
+        for value in columns:
+            all_clauses.append(dicc_type.get(type(value), dicc_type["default"])(value))
+
+        return all_clauses
+
+    @tp.override
+    @property
+    def query(self) -> str:
+        wrapped_ci = self.wrapped_clause_info(self)
+        if not self._alias_aggregate:
+            return wrapped_ci
+
+        return ClauseInfo(
+            table=None,
+            column=wrapped_ci,
+            alias_clause=self._alias_aggregate,
+            context=self._context,
+            keep_asterisk=self._keep_asterisk,
+            preserve_context=self._preserve_context,
+        ).query
+
+    def wrapped_clause_info(self, ci: ClauseInfo[T]) -> str:
+        # avoid use placeholder when using IAggregate because no make sense.
+        if self._alias_aggregate and (found := self._keyRegex.findall(self._alias_aggregate)):
+            raise NotKeysInIAggregateError(found)
+
+        return f"{self.FUNCTION_NAME()}({ci._create_query()})"

ormlambda/sql/clause_info/clause_info.py

@@ -1,21 +1,17 @@
 from __future__ import annotations
-import abc
 import typing as tp
 import re
 
 from ormlambda import Table
 from ormlambda import Column
-from ormlambda.common.interfaces.IQueryCommand import IQuery
 from ormlambda.sql.types import (
     ASTERISK,
     TableType,
     ColumnType,
     AliasType,
 )
-from .interface import IAggregate
-from ormlambda.common.errors import NotKeysInIAggregateError
+from .interface import IClauseInfo
 from ormlambda.sql import ForeignKey
-from ormlambda.sql.table import TableMeta
 from ormlambda.caster import Caster
 
 
@@ -32,30 +28,6 @@ class ReplacePlaceholderError(ValueError):
         return "You cannot use {" + self.placeholder + "} placeholder without using '" + self.attr + "' attribute"
 
 
-class IClauseInfo[T: Table](IQuery):
-    @property
-    @abc.abstractmethod
-    def table(self) -> TableType[T]: ...
-    @property
-    @abc.abstractmethod
-    def alias_clause(self) -> tp.Optional[str]: ...
-    @property
-    @abc.abstractmethod
-    def alias_table(self) -> tp.Optional[str]: ...
-    @property
-    @abc.abstractmethod
-    def column(self) -> str: ...
-    @property
-    @abc.abstractmethod
-    def unresolved_column(self) -> ColumnType: ...
-    @property
-    @abc.abstractmethod
-    def context(self) -> ClauseContextType: ...
-    @property
-    @abc.abstractmethod
-    def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]: ...
-
-
 class ClauseInfo[T: Table](IClauseInfo[T]):
     _keyRegex: re.Pattern = re.compile(r"{([^{}:]+)}")
 
@@ -363,72 +335,3 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if isinstance(data, Column):
             return True
         return False
-
-
-class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
-    def __init__[TProp: Column](
-        self,
-        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,
-    ):
-        self._alias_aggregate = alias_clause
-        super().__init__(
-            table=table,
-            column=column,
-            alias_table=alias_table,
-            context=context,
-            keep_asterisk=keep_asterisk,
-            preserve_context=preserve_context,
-        )
-
-    @staticmethod
-    @abc.abstractmethod
-    def FUNCTION_NAME() -> str: ...
-
-    @classmethod
-    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType) -> list[ClauseInfo]:
-        type DEFAULT = tp.Literal["default"]
-        type ClusterType = ColumnType | ForeignKey | DEFAULT
-
-        dicc_type: dict[ClusterType, tp.Callable[[ClusterType], ClauseInfo]] = {
-            Column: lambda column: ClauseInfo(column.table, column, context=context),
-            ClauseInfo: lambda column: column,
-            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context),
-            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context),
-            "default": lambda column: ClauseInfo(table=None, column=column, context=context),
-        }
-        all_clauses: list[ClauseInfo] = []
-        if isinstance(columns, str) or not isinstance(columns, tp.Iterable):
-            columns = (columns,)
-        for value in columns:
-            all_clauses.append(dicc_type.get(type(value), dicc_type["default"])(value))
-
-        return all_clauses
-
-    @tp.override
-    @property
-    def query(self) -> str:
-        wrapped_ci = self.wrapped_clause_info(self)
-        if not self._alias_aggregate:
-            return wrapped_ci
-
-        return ClauseInfo(
-            table=None,
-            column=wrapped_ci,
-            alias_clause=self._alias_aggregate,
-            context=self._context,
-            keep_asterisk=self._keep_asterisk,
-            preserve_context=self._preserve_context,
-        ).query
-
-    def wrapped_clause_info(self, ci: ClauseInfo[T]) -> str:
-        # avoid use placeholder when using IAggregate because no make sense.
-        if self._alias_aggregate and (found := self._keyRegex.findall(self._alias_aggregate)):
-            raise NotKeysInIAggregateError(found)
-
-        return f"{self.FUNCTION_NAME()}({ci._create_query()})"

ormlambda/sql/clause_info/interface/IClauseInfo.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+import abc
+import typing as tp
+
+from ormlambda import Table
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.sql.types import (
+    TableType,
+    ColumnType,
+)
+
+
+from ..clause_info_context import ClauseContextType
+
+
+class IClauseInfo[T: Table](IQuery):
+    @property
+    @abc.abstractmethod
+    def table(self) -> TableType[T]: ...
+    @property
+    @abc.abstractmethod
+    def alias_clause(self) -> tp.Optional[str]: ...
+    @property
+    @abc.abstractmethod
+    def alias_table(self) -> tp.Optional[str]: ...
+    @property
+    @abc.abstractmethod
+    def column(self) -> str: ...
+    @property
+    @abc.abstractmethod
+    def unresolved_column(self) -> ColumnType: ...
+    @property
+    @abc.abstractmethod
+    def context(self) -> ClauseContextType: ...
+    @property
+    @abc.abstractmethod
+    def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]: ...

ormlambda/sql/clause_info/interface/__init__.py

@@ -1 +1,2 @@
 from .IAggregate import IAggregate  # noqa: F401
+from .IClauseInfo import IClauseInfo  # noqa: F401

ormlambda/sql/column.py

@@ -128,6 +128,9 @@ class Column[TProp]:
         return self.__comparer_creator(other, ConditionType.GREATER_THAN_OR_EQUAL.value, *args)
 
     def contains[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
+        if not isinstance(other, tuple) and isinstance(other, Iterable):
+            other = tuple(other)
+
         return self.__comparer_creator(other, ConditionType.IN.value, *args)
 
     def not_contains[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:

ormlambda/statements/base_statement.py

@@ -33,6 +33,10 @@ class BaseStatement[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
             raise Exception(f"'{model}' class does not inherit from Table class")
 
+    @override
+    def table_exists(self) -> bool:
+        return self._repository.table_exists(self._model.__table_name__)
+
     @staticmethod
     def __valid_repository(repository: Any) -> bool:
         if not isinstance(repository, BaseRepository):
@@ -67,8 +71,8 @@ class BaseStatement[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         return self._models
 
     @property
-    @override
-    def repository(self) -> BaseRepository: ...
+    def repository(self) -> BaseRepository:
+        return self._repository
 
 
 class ClusterQuery[T]:

ormlambda/statements/interfaces/IStatements.py

@@ -4,14 +4,16 @@ from enum import Enum
 from abc import abstractmethod, ABC
 
 
-from ormlambda.common.enums import JoinType
-
 if TYPE_CHECKING:
     from ormlambda.repository import BaseRepository
     from ormlambda import Table
     from ormlambda.sql.clause_info import IAggregate
     from ormlambda.sql.types import TupleJoinType, ColumnType
-    from ormlambda.databases.my_sql.join_context import JoinContext
+    from ormlambda.components.join import JoinContext
+    from ormlambda.common.enums import JoinType
+    from ormlambda.sql.clause_info import ClauseInfo
+    from ormlambda.sql.types import AliasType
+
 
 from ..types import (
     OrderTypes,
@@ -246,33 +248,33 @@ class IStatements[T: Table](ABC):
     # @overload
     # def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def select[TRes](self, selector: SelectorFlavourType[T, TRes] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
+    def select[TRes](self, selector: SelectorFlavourType[T, TRes] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[TRes, ...]: ...
     @overload
-    def select[*TRes](self, selector: SelectorFlavourType[T, tuple[*TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
+    def select[*TRes](self, selector: SelectorFlavourType[T, tuple[*TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
     @overload
-    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour, ...]: ...
+    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[TFlavour, ...]: ...
 
     @abstractmethod
-    def select[TValue, TFlavour, P](self, selector: SelectorFlavourType[T, tuple[TValue, P]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., **kwargs): ...
+    def select[TValue, TFlavour, P](self, selector: SelectorFlavourType[T, tuple[TValue, P]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs): ...
 
     # endregion
     # region select_one
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
     def select_one[T1](self, selector: SelectorOneType[T, T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
     def select_one[*TRes](self, selector: SelectorOneType[T, tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def select_one[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    def select_one[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> T1: ...
     @overload
-    def select_one[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def select_one[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    def select_one[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[*TRest]: ...
     @overload
-    def select_one[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @abstractmethod
     def select_one[TValue, TFlavour, *TRest](
         self,
@@ -292,15 +294,15 @@ class IStatements[T: Table](ABC):
     @overload
     def first[*TRes](self, selector: SelectorOneType[T, tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def first[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    def first[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> T1: ...
     @overload
-    def first[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def first[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    def first[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[*TRest]: ...
     @overload
-    def first[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @abstractmethod
     def first[TValue, TFlavour, *TRest](
         self,
@@ -313,13 +315,17 @@ class IStatements[T: Table](ABC):
     # endregion
 
     # region groupby
+    @overload
+    def groupby[TRepo](self, column: list[SelectCols[T, TRepo]]) -> IStatements[T]: ...
+    @overload
+    def groupby[TRepo](self, column: SelectCols[T, TRepo]) -> IStatements[T]: ...
     @abstractmethod
-    def groupby[TRepo](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
+    def groupby[TRepo](self, column: list[SelectCols[T, TRepo]] | SelectCols[T, TRepo]) -> IStatements[T]: ...
 
     # endregion
 
     @abstractmethod
-    def alias(self, column: Callable[[T], Any], alias: str) -> IStatements[T]: ...
+    def alias[TProp](self, column: SelectCols[T, TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]: ...
 
 
 class IStatements_two_generic[T, TPool](IStatements[T]):