ormlambda 3.35.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

ormlambda/common/abstract_classes/decomposition_query.py

@@ -1,141 +0,0 @@
-from __future__ import annotations
-import typing as tp
-from ormlambda import Table, Column
-
-from ormlambda.common.interfaces import IDecompositionQuery, ICustomAlias
-from ormlambda.sql.clause_info import IAggregate
-from ormlambda.sql.clause_info import ClauseInfo, AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda import ForeignKey
-from ormlambda.common.global_checker import GlobalChecker
-
-from ormlambda.sql.types import TableType, ColumnType
-from .clause_info_converter import (
-    ClauseInfoConverter,
-    ConvertFromAnyType,
-    ConvertFromForeignKey,
-    ConvertFromColumn,
-    ConvertFromIAggregate,
-    ConvertFromTable,
-)
-
-type TableTupleType[T, *Ts] = tuple[T:TableType, *Ts]
-type ValueType = tp.Union[
-    tp.Type[IAggregate],
-    tp.Type[Table],
-    tp.Type[str],
-    tp.Type[ICustomAlias],
-]
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
-    @tp.overload
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType]) -> None: ...
-    @tp.overload
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], context: ClauseContextType = ...) -> None: ...
-    @tp.overload
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str, context: ClauseContextType = ...) -> None: ...
-
-    def __init__(
-        self,
-        tables: tuple[TableType[T]],
-        columns: tuple[ColumnType],
-        alias_table: str = "{table}",
-        *,
-        context: ClauseContextType = ClauseInfoContext(),
-        dialect: Dialect,
-        **kwargs,
-    ) -> None:
-        self.kwargs = kwargs
-        self._tables: tuple[TableType[T]] = tables if isinstance(tables, tp.Iterable) else (tables,)
-
-        self._dialect = dialect
-        self._columns: tp.Callable[[T], tuple] = columns
-        self._all_clauses: list[ClauseInfo | AggregateFunctionBase] = []
-        self._context: ClauseContextType = context if context else ClauseInfoContext()
-        self._alias_table: str = alias_table
-        self.__clauses_list_generetor()
-
-    def __getitem__(self, key: str) -> ClauseInfo | AggregateFunctionBase:
-        for clause in self._all_clauses:
-            is_agg_function = isinstance(clause, AggregateFunctionBase)
-            is_clause_info = isinstance(clause, ClauseInfo)
-            if (is_agg_function and clause._alias_aggregate == key) or (is_clause_info and clause.alias_clause == key):
-                return clause
-
-    def __clauses_list_generetor(self) -> None:
-        # Clean self._all_clauses if we update the context
-        self._all_clauses.clear() if self._all_clauses else None
-
-        resolved_function = GlobalChecker.resolved_callback_object(self._columns, self.tables)
-
-        # Python treats string objects as iterable, so we need to prevent this behavior
-        if isinstance(resolved_function, str) or not isinstance(resolved_function, tp.Iterable):
-            resolved_function = (self.table,) if ClauseInfo.is_asterisk(resolved_function) else (resolved_function,)
-
-        for data in resolved_function:
-            if not isinstance(data, ClauseInfo):
-                values = self.__convert_into_ClauseInfo(data)
-            else:
-                values = [data]
-            self.__add_clause(values)
-
-        return None
-
-    def __convert_into_ClauseInfo[TProp](self, data: TProp) -> list[ClauseInfo[T]]:
-        """
-        A method that behaves based on the variable's type
-        """
-
-        def validation(data: TProp, type_: ValueType) -> bool:
-            is_valid_type: bool = isinstance(data, type) and issubclass(data, type_)
-            return isinstance(data, type_) or is_valid_type
-
-        VALUE_TYPE_MAPPED: dict[tp.Type[ValueType], ClauseInfoConverter[T, TProp]] = {
-            ForeignKey: ConvertFromForeignKey[T, Table],
-            Column: ConvertFromColumn[TProp],
-            IAggregate: ConvertFromIAggregate,
-            Table: ConvertFromTable[T],
-        }
-        classConverter = next((converter for obj, converter in VALUE_TYPE_MAPPED.items() if validation(data, obj)), ConvertFromAnyType)
-        self.kwargs.setdefault("dialect", self._dialect)
-        if "dialect" not in self.kwargs:
-            raise ValueError("You must specified 'dialect' variable")
-        return classConverter.convert(data, alias_table=self._alias_table, context=self._context, **self.kwargs)
-
-    def __add_clause[TTable: TableType](self, clauses: list[ClauseInfo[TTable]] | ClauseInfo[TTable]) -> None:
-        if not isinstance(clauses, tp.Iterable):
-            raise ValueError(f"Iterable expected. '{type(clauses)}' got instead.")
-
-        for clause in clauses:
-            self._all_clauses.append(clause)
-        return None
-
-    @property
-    def table(self) -> T:
-        return self.tables[0] if isinstance(self.tables, tp.Iterable) else self.tables
-
-    @property
-    def tables(self) -> T:
-        return self._tables
-
-    @property
-    def columns[*Ts](self) -> tp.Callable[[T], tuple[*Ts]]:
-        return self._columns
-
-    @property
-    def all_clauses(self) -> list[ClauseInfo[T]]:
-        return self._all_clauses
-
-    @property
-    def context(self) -> tp.Optional[ClauseInfoContext]:
-        return self._context
-
-    @context.setter
-    def context(self, value: ClauseInfoContext) -> None:
-        self._context = value
-        self.__clauses_list_generetor()
-        return None

ormlambda/common/abstract_classes/query_base.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-from abc import abstractmethod
-from typing import TYPE_CHECKING
-
-from ormlambda.common.interfaces import IQuery
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-    from ormlambda.dialects import Dialect
-
-
-class QueryBase[T: Table](IQuery):
-    @property
-    @abstractmethod
-    def query(self, dialect: Dialect, **kwargs) -> str: ...

ormlambda/common/interfaces/ICustomAlias.py

@@ -1,7 +0,0 @@
-# from ormlambda.common.interfaces import IDecompositionQuery
-
-
-class ICustomAlias[T, *Ts]: ...
-
-
-# class ICustomAlias[T, *Ts](IDecompositionQuery[T, *Ts]): ...

ormlambda/common/interfaces/IDecompositionQuery.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-import abc
-import typing as tp
-
-
-if tp.TYPE_CHECKING:
-    # TODOH: Changed to avoid mysql dependency
-    from ormlambda.sql.clause_info import ClauseInfo, TableType
-    from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
-
-
-class IDecompositionQuery_one_arg[T: TableType]:
-    @property
-    @abc.abstractmethod
-    def table(self) -> T: ...
-
-    @property
-    @abc.abstractmethod
-    def context(self) -> tp.Optional[ClauseInfoContext]: ...
-
-    @context.setter
-    @abc.abstractmethod
-    def context(self) -> tp.Optional[ClauseInfoContext]: ...
-
-
-class IDecompositionQuery[T: TableType, *Ts](IDecompositionQuery_one_arg[T]):
-    @property
-    @abc.abstractmethod
-    def tables(self) -> tuple[*Ts]: ...
-
-    @property
-    @abc.abstractmethod
-    def all_clauses(self) -> list[ClauseInfo]: ...

ormlambda/databases/__init__.py

@@ -1,4 +0,0 @@
-from .my_sql import (
-    MySQLCaster as MySQLCaster,
-    MySQLRepository as MySQLRepository,
-)

ormlambda/databases/my_sql/__init__.py

@@ -1,3 +0,0 @@
-from mysql.connector import MySQLConnection  # noqa: F401
-from .repository import MySQLRepository  # noqa: F401
-from .caster import MySQLCaster  # noqa: F401

ormlambda/databases/my_sql/clauses/ST_AsText.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-from ormlambda.sql.clause_info import AggregateFunctionBase
-from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-
-if TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class ST_AsText[T, TProp](AggregateFunctionBase[None]):
-    """
-    https://dev.mysql.com/doc/refman/8.4/en/fetching-spatial-data.html
-
-    The ST_AsText() function converts a geometry from internal format to a WKT string.
-    """
-
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "ST_AsText"
-
-    def __init__(
-        self,
-        point: ColumnType[TProp],
-        alias_table: AliasType[ColumnType[TProp]] = None,
-        alias_clause: AliasType[ColumnType[TProp]] = None,
-        context: ClauseContextType = None,
-        *,
-        dialect: Dialect,
-    ) -> None:
-        default_alias_clause = self.create_alias_from(point) if not alias_clause else alias_clause
-
-        super().__init__(table=point.table, column=point, alias_table=alias_table, alias_clause=default_alias_clause, context=context, dialect=dialect)
-
-    @staticmethod
-    def create_alias_from(element: ColumnType[TProp]) -> str:
-        return element.column_name

ormlambda/databases/my_sql/clauses/ST_Contains.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-import typing as tp
-
-from shapely import Point
-
-from ormlambda import Column
-from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import ClauseInfo, IAggregate
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-class ST_Contains(IAggregate):
-    FUNCTION_NAME: str = "ST_Contains"
-
-    def __init__[TProp: Column](
-        self,
-        column: ColumnType[TProp],
-        point: Point,
-        alias_table: tp.Optional[AliasType[ColumnType[TProp]]] = None,
-        alias_clause: tp.Optional[AliasType[ColumnType[TProp]]] = None,
-        *,
-        dialect: Dialect,
-    ):
-        self.attr1: ClauseInfo[Point] = ClauseInfo(column.table, column, alias_table, dialect=dialect)
-        self.attr2: ClauseInfo[Point] = ClauseInfo[Point](None, point, dialect=dialect)
-
-        self._alias_clause: AliasType[ColumnType[TProp]] = alias_clause
-
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        return f"{self.FUNCTION_NAME}({self.attr1.query(dialect,**kwargs)}, {self.attr2.query(dialect,**kwargs)})"
-
-    @property
-    def alias_clause(self) -> tp.Optional[str]:
-        return self._alias_clause

ormlambda/databases/my_sql/clauses/__init__.py

@@ -1,14 +0,0 @@
-from .delete import DeleteQuery as Delete
-from .drop_table import DropTable as DropTable
-from .insert import InsertQuery as Insert
-from .joins import JoinSelector as JoinSelector
-from .limit import Limit as Limit
-from .offset import Offset as Offset
-from .order import Order as Order
-from .update import Update as Update
-from .upsert import UpsertQuery as Upsert
-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 .ST_AsText import ST_AsText as ST_AsText

ormlambda/databases/my_sql/clauses/count.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-from ormlambda.sql.clauses import Count
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-
-from ormlambda.sql.types import AliasType, ColumnType
-
-from ormlambda import Table
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-    from ormlambda.sql.types import ColumnType, AliasType, TableType
-
-
-class Count[T: Table](Count[T]):
-    def __init__[TProp: Table](
-        self,
-        element: ColumnType[T] | TableType[TProp],
-        alias_table: AliasType[ColumnType[TProp]] = None,
-        alias_clause: AliasType[ColumnType[TProp]] = "count",
-        context: ClauseContextType = None,
-        keep_asterisk: bool = True,
-        preserve_context: bool = True,
-    ) -> None:
-        super().__init__(
-            element=element,
-            alias_table=alias_table,
-            alias_clause=alias_clause,
-            context=context,
-            keep_asterisk=keep_asterisk,
-            preserve_context=preserve_context,
-        )

ormlambda/databases/my_sql/clauses/delete.py

@@ -1,9 +0,0 @@
-from ormlambda import Table
-from ormlambda.repository import IRepositoryBase
-from ormlambda.sql.clauses import Delete
-from mysql.connector import MySQLConnection
-
-
-class DeleteQuery[T: Table](Delete[T, MySQLConnection]):
-    def __init__(self, model: T, repository: IRepositoryBase) -> None:
-        super().__init__(model, repository)

ormlambda/databases/my_sql/clauses/drop_table.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-from typing import Literal, override, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from mysql.connector import MySQLConnection
-
-from ormlambda.repository import BaseRepository
-
-
-TypeExists = Literal["fail", "replace", "append"]
-
-
-class DropTable:
-    def __init__(self, repository: BaseRepository[MySQLConnection]) -> None:
-        self._repository: BaseRepository[MySQLConnection] = repository
-
-    @override
-    def execute(self, name: str = None) -> None:
-        query = rf"{self.CLAUSE} {name}"
-        self._repository.execute(query)
-        return None
-
-    @property
-    @override
-    def CLAUSE(self) -> str:
-        return "DROP TABLE"

ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,17 +0,0 @@
-from ormlambda.sql.clause_info import ClauseInfoContext
-from ormlambda.sql.clauses import GroupBy
-from ormlambda.sql.types import ColumnType
-
-
-class GroupBy(GroupBy):
-    def __init__(
-        self,
-        column: ColumnType,
-        context: ClauseInfoContext,
-        **kwargs,
-    ):
-        super().__init__(
-            column=column,
-            context=context,
-            **kwargs,
-        )

ormlambda/databases/my_sql/clauses/having.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from ormlambda.sql.clauses import Having
-
-
-class Having(Having):
-    """
-    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)

ormlambda/databases/my_sql/clauses/insert.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-from ormlambda import Table
-from ormlambda.sql.clauses import Insert
-from mysql.connector import MySQLConnection
-
-
-class InsertQuery[T: Table](Insert[T, MySQLConnection]):
-    def __init__(self, model, repository):
-        super().__init__(model, repository)

ormlambda/databases/my_sql/clauses/joins.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-
-from ormlambda.sql.clauses import JoinSelector
-
-# TODOL [x]: Try to import Table module without circular import Error
-if TYPE_CHECKING:
-    from ormlambda import Table
-
-
-class JoinSelector[TLeft: Table, TRight: Table](JoinSelector[TLeft, TRight]):
-    def __init__(self, where, by, alias="{table}", context=None, **kw):
-        super().__init__(where, by, alias, context, **kw)

ormlambda/databases/my_sql/clauses/limit.py

@@ -1,6 +0,0 @@
-from ormlambda.sql.clauses import Limit
-
-
-class Limit(Limit):
-    def __init__(self, number):
-        super().__init__(number)

ormlambda/databases/my_sql/clauses/offset.py

@@ -1,6 +0,0 @@
-from ormlambda.sql.clauses import Offset
-
-
-class Offset(Offset):
-    def __init__(self, number):
-        super().__init__(number)

ormlambda/databases/my_sql/clauses/order.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-from ormlambda.sql.clauses import Order
-
-
-class Order(Order):
-    def __init__(self, column, order_type, context=None):
-        super().__init__(column, order_type, context)

ormlambda/databases/my_sql/clauses/update.py

@@ -1,8 +0,0 @@
-from mysql.connector import MySQLConnection
-
-from ormlambda.sql.clauses import Update
-
-
-class Update[T](Update[T, MySQLConnection]):
-    def __init__(self, model, repository, where):
-        super().__init__(model, repository, where)

ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-
-from ormlambda import Table
-from ormlambda.sql.clauses.upsert import Upsert
-
-
-class UpsertQuery[T: Table](Upsert):
-    def __init__(self, model, repository):
-        super().__init__(model, repository)

ormlambda/databases/my_sql/clauses/where.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-from ormlambda.sql.clauses import Where
-
-
-class Where(Where):
-    def __init__(self, *comparer, restrictive=True, context=None):
-        super().__init__(*comparer, restrictive=restrictive, context=context)

ormlambda/dialects/interface/__init__.py

@@ -1 +0,0 @@
-from .dialect import Dialect  # noqa: F401

ormlambda/dialects/interface/dialect.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-import abc
-from typing import ClassVar, Optional, Type, TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    from ormlambda.caster.caster import Caster
-    from ormlambda.repository.interfaces.IRepositoryBase import DBAPIConnection
-    from ormlambda.sql.types import DDLCompiler, SQLCompiler, TypeCompiler
-    from ormlambda import BaseRepository
-
-
-class Dialect(abc.ABC):
-    """
-    Abstract base class for all database dialects.
-    """
-
-    dbapi: Optional[DBAPIConnection]
-    """A reference to the DBAPI module object itself.
-
-    Ormlambda dialects import DBAPI modules using the classmethod
-    :meth:`.Dialect.import_dbapi`. The rationale is so that any dialect
-    module can be imported and used to generate SQL statements without the
-    need for the actual DBAPI driver to be installed.  Only when an
-    :class:`.Engine` is constructed using :func:`.create_engine` does the
-    DBAPI get imported; at that point, the creation process will assign
-    the DBAPI module to this attribute.
-
-    Dialects should therefore implement :meth:`.Dialect.import_dbapi`
-    which will import the necessary module and return it, and then refer
-    to ``self.dbapi`` in dialect code in order to refer to the DBAPI module
-    contents.
-
-    .. versionchanged:: The :attr:`.Dialect.dbapi` attribute is exclusively
-       used as the per-:class:`.Dialect`-instance reference to the DBAPI
-       module.   The previous not-fully-documented ``.Dialect.dbapi()``
-       classmethod is deprecated and replaced by :meth:`.Dialect.import_dbapi`.
-
-    """
-
-    name: ClassVar[str]
-    """The name of the dialect, e.g. 'sqlite', 'postgresql', etc."""
-    driver: ClassVar[str]
-    """The driver used by the dialect, e.g. 'sqlite3', 'psycopg2', etc."""
-
-    ddl_compiler: ClassVar[Type[DDLCompiler]]
-    """The DDL compiler class used by the dialect."""
-
-    statement_compiler: ClassVar[Type[SQLCompiler]]
-    """The statement compiler class used by the dialect."""
-
-    type_compiler_cls: ClassVar[Type[TypeCompiler]]
-    """The type compiler class used by the dialect."""
-
-    type_compiler_instance: ClassVar[TypeCompiler]
-    """The instance of the type compiler class used by the dialect."""
-
-    repository_cls: ClassVar[Type[BaseRepository]]
-    """The repository class used by the dialect."""
-
-    caster: ClassVar[Type[Caster]]
-
-    @classmethod
-    def get_dialect_cls(cls) -> Type[Dialect]:
-        return cls
-
-    @classmethod
-    @abc.abstractmethod
-    def import_dbapi(cls) -> DBAPIConnection:
-        """
-        Import the DB API module for the dialect.
-        This method should be implemented by subclasses to import the
-        appropriate DB API module for the dialect.
-        """
-        ...
-
-    def __repr__(self):
-        return f"{Dialect.__name__}: {type(self).__name__}"

ormlambda/sql/clause_info/aggregate_function_base.py

@@ -1,96 +0,0 @@
-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
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-
-
-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,
-        dtype: TProp = None,
-        *,
-        dialect: Dialect,
-        **kw,
-    ):
-        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,
-            dtype=dtype,
-            dialect=dialect,
-            **kw,
-        )
-
-    @staticmethod
-    @abc.abstractmethod
-    def FUNCTION_NAME() -> str: ...
-
-    @classmethod
-    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType, dialect: Dialect) -> 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, dialect=dialect),
-            ClauseInfo: lambda column: column,
-            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context, dialect=dialect),
-            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context, dialect=dialect),
-            "default": lambda column: ClauseInfo(table=None, column=column, context=context, dialect=dialect),
-        }
-        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
-    def query(self, dialect: Dialect, **kwargs) -> 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,
-            dialect=self._dialect,
-        ).query(dialect, **kwargs)
-
-    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(self._dialect)})"