ormlambda 4.4.4__tar.gz → 4.4.14__tar.gz

{ormlambda-4.4.4 → ormlambda-4.4.14}/PKG-INFO

@@ -1,12 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ormlambda
-Version: 4.4.4
+Version: 4.4.14
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
+License-File: AUTHORS
+License-File: LICENSE
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown
@@ -76,7 +80,7 @@ db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
 AddressModel = ORM(Address, db)
 
-result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
+result = AddressModel.where(lambda x: x.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
         address,
         address.City,
@@ -104,7 +108,7 @@ result = AddressModel.where(
 Additionally, we can filter by others tables. For example, we can return all addresses for each city where `country_id` = 87 (Spain)
 
 ```python
-result = AddressModel.where(Address.City.Country.country_id  == 87).select()
+result = AddressModel.where(lambda x: x.City.Country.country_id  == 87).select()
 ```
 
 We can also return `Address`, `City` or `Country` if needed.

{ormlambda-4.4.4 → ormlambda-4.4.14}/README.md

@@ -63,7 +63,7 @@ db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
 AddressModel = ORM(Address, db)
 
-result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
+result = AddressModel.where(lambda x: x.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
         address,
         address.City,
@@ -91,7 +91,7 @@ result = AddressModel.where(
 Additionally, we can filter by others tables. For example, we can return all addresses for each city where `country_id` = 87 (Spain)
 
 ```python
-result = AddressModel.where(Address.City.Country.country_id  == 87).select()
+result = AddressModel.where(lambda x: x.City.Country.country_id  == 87).select()
 ```
 
 We can also return `Address`, `City` or `Country` if needed.

{ormlambda-4.4.4 → ormlambda-4.4.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ormlambda"
-version = "4.4.4"
+version = "4.4.14"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"

ormlambda-4.4.14/src/ormlambda/common/constants.py

@@ -0,0 +1 @@
+DOT = "."

{ormlambda-4.4.4 → ormlambda-4.4.14}/src/ormlambda/common/errors/__init__.py

@@ -9,6 +9,16 @@ if tp.TYPE_CHECKING:
     from ormlambda.sql import Column
 
 
+class ReplacePlaceholderError(ValueError):
+    def __init__(self, placeholder: str, attribute: str, *args):
+        super().__init__(*args)
+        self.placeholder: str = placeholder
+        self.attr: str = attribute
+
+    def __str__(self):
+        return "You cannot use {" + self.placeholder + "} placeholder without using '" + self.attr + "' attribute"
+
+
 class UnmatchedLambdaParameterError(Exception):
     def __init__(self, expected_params: int, function: tp.Callable[..., tp.Any], *args: object) -> None:
         super().__init__(*args)

{ormlambda-4.4.4 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/base.py

@@ -11,15 +11,6 @@ from .. import default
 from typing import TYPE_CHECKING, Any, Iterable, Type
 from ormlambda.sql.comparer import Comparer, ComparerCluster
 
-if TYPE_CHECKING:
-    from ormlambda.sql.functions.interface import IFunction
-    from ormlambda.sql.types import ColumnType
-    from test.test_clause_info import ST_Contains
-    from ormlambda import JoinSelector
-    from ormlambda.sql.column.column import Column
-    from mysql import connector
-    from ormlambda.dialects.mysql.clauses import ST_AsText
-
 from .types import (
     _NumericType,
     _NumericCommonType,
@@ -64,6 +55,14 @@ from .repository import MySQLRepository
 
 
 if TYPE_CHECKING:
+    from ormlambda.sql.functions.interface import IFunction
+    from ormlambda.sql.types import ColumnType
+    from test.test_clause_info import ST_Contains
+    from ormlambda import JoinSelector
+    from ormlambda.sql.column.column import Column
+    from mysql import connector
+    from ormlambda.dialects.mysql.clauses import ST_AsText
+
     from ormlambda.sql.clauses import (
         Select,
         Insert,
@@ -101,15 +100,12 @@ class MySQLCompiler(compiler.SQLCompiler):
     render_table_with_column_in_update_from = True
     """Overridden from base SQLCompiler value"""
 
-    def visit_table(self, table: Table):
-        return ClauseInfo(table=table, dialect=self.dialect).query(dialect=self.dialect)
-
     def visit_table_proxy(self, table: TableProxy, **kw) -> str:
         param = {
-            "table": None,
-            "column": table._table_class.__table_name__,
-            "dialect": self.dialect,
+            "table": table._table_class,
+            "column": None,
             "alias_clause": alias if (alias := table.get_table_chain()) else None,
+            "dialect": self.dialect,
             **kw,
         }
         return ClauseInfo(**param).query(dialect=self.dialect)
@@ -132,7 +128,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         params = {
             "table": column.table,
             "column": column,
-            "alias_table": alias_table if alias_table else "{table}",
+            "alias_table": alias_table,
             "alias_clause": column.alias or "{column}",
             "dtype": column._column.dtype,
             "dialect": self.dialect,
@@ -216,9 +212,9 @@ class MySQLCompiler(compiler.SQLCompiler):
         rt = join.rcon.table
         rtable = TableProxy(table_class=rt, path=join.rcon.path)
 
-        from_clause = rtable.compile(self.dialect, alias_clause=join.alias).string
+        from_clause = rtable.compile(self.dialect, alias_table=join.alias, first_apperance=True).string
         left_table_clause = join.lcon.compile(self.dialect, alias_clause=None).string
-        right_table_clause = join.rcon.compile(self.dialect, alias_table=join.alias, alias_clause=None).string
+        right_table_clause = join.rcon.compile(self.dialect, alias_clause=None).string
         list_ = [
             join._by.value,  # inner join
             from_clause,
@@ -242,9 +238,11 @@ class MySQLCompiler(compiler.SQLCompiler):
         columns = ClauseInfo.join_clauses(select.columns, sep, dialect=self.dialect, **params)
 
         from_ = ClauseInfo(
-            select._table,
-            None,
+            table=select._table,
+            column=None,
+            alias_table="{table}",
             dialect=self.dialect,
+            first_apperance=True,
         ).query(self.dialect)
 
         return f"SELECT{sep}{columns}{sep}FROM {from_}"
@@ -467,7 +465,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         else:
             column = count.column
 
-        return ClauseInfo.concat_alias_and_column(f"COUNT({column})", count.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"COUNT({column})", count.alias)
 
     def visit_order(self, order: Order, **kw) -> str:
         ORDER = "ORDER BY"
@@ -514,10 +512,10 @@ class MySQLCompiler(compiler.SQLCompiler):
         clause_info = ClauseInfo(
             table=None,
             column=f"CONCAT({', '.join(columns)})",
-            alias_clause=concat.alias,
             dialect=self.dialect,
+            literal=True
         )
-        return clause_info.query(self.dialect)
+        return f"{clause_info.query(self.dialect)} AS {ClauseInfo.wrapped_with_quotes(concat.alias)}" 
 
     def visit_max(self, obj: Max, **kw) -> str:
         return self._compile_aggregate_method("MAX", obj, **kw)
@@ -546,7 +544,7 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_pow(self, obj: Pow, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = obj.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"POW({column}, {obj._exponent})", obj.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"POW({column}, {obj._exponent})", obj.alias)
 
     def visit_sqrt(self, obj: Sqrt, **kw) -> str:
         return self._compile_aggregate_method("SQRT", obj, **kw)
@@ -554,7 +552,7 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_mod(self, obj: Mod, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = obj.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"MOD({column}, {obj._divisor})", obj.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"MOD({column}, {obj._divisor})", obj.alias)
 
     def visit_rand(self, obj: Rand, **kw) -> str:
         return self._compile_aggregate_method("RAND", obj, **kw)
@@ -562,22 +560,24 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_truncate(self, obj: Truncate, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = obj.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"TRUNCATE({column}, {obj._decimal})", obj.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"TRUNCATE({column}, {obj._decimal})", obj.alias)
 
     def _compile_aggregate_method(self, name: str, function: IFunction, **kw) -> str:
         attr = {**kw, "alias_clause": None}
         column = function.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"{name}({column})", function.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"{name}({column})", function.alias)
 
     def visit_st_astext(self, st_astext: ST_AsText) -> str:
         # avoid use placeholder when using IFunction because no make sense.
         if st_astext.alias and (found := ClauseInfo._keyRegex.findall(st_astext.alias)):
             raise NotKeysInIFunctionError(found)
-        return ClauseInfo.concat_alias_and_column(f"ST_AsText({st_astext.column.compile(self.dialect, alias_clause=None).string})", st_astext.alias)
+        return ClauseInfo.concat_clause_with_his_alias(f"ST_AsText({st_astext.column.compile(self.dialect, alias_clause=None).string})", st_astext.alias)
 
     def visit_st_contains(self, st_contains: ST_Contains) -> str:
+        # FIXME [ ]: It's not working as expected. Should be something like
+        # ST_Contains(`table_type`.points, ST_GeomFromText(%s))
         attr1 = st_contains.column.compile(self.dialect, alias_clause=None).string
-        attr2 = ClauseInfo(None, st_contains.point, dialect=self.dialect).query(self.dialect, alias_clause=None)
+        attr2 = ClauseInfo(None, st_contains.point, dialect=self.dialect).query(self.dialect)
         return f"ST_Contains({attr1}, {attr2})"
 
 
@@ -602,7 +602,8 @@ class MySQLDDLCompiler(compiler.DDLCompiler):
         compare = fk.resolved_function()
         lcon = compare.left_condition
         rcon = compare.right_condition
-        return f"FOREIGN KEY ({lcon.column_name}) REFERENCES {rcon.table.__table_name__}({rcon.column_name})"
+        rdb = f"{ClauseInfo.wrapped_with_quotes(db)}." if (db := compare.right_condition.table.__db_name__) else ""
+        return f"FOREIGN KEY ({lcon.column_name}) REFERENCES {rdb}{rcon.table.__table_name__}({rcon.column_name})"
 
 
 class MySQLTypeCompiler(compiler.GenericTypeCompiler):

{ormlambda-4.4.4 → ormlambda-4.4.14}/src/ormlambda/dialects/mysql/repository/repository.py

@@ -187,8 +187,6 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
     @override
     def table_exists(self, name: str) -> bool:
         with self.get_connection() as cnx:
-            if not cnx.database:
-                raise Exception("No database selected")
             with cnx.cursor(buffered=True) as cursor:
                 cursor.execute(f"SHOW TABLES LIKE {Caster.PLACEHOLDER};", (name,))
             res = cursor.fetchmany(1)

{ormlambda-4.4.4 → ormlambda-4.4.14}/src/ormlambda/sql/clause_info/clause_info.py

@@ -4,7 +4,7 @@ import typing as tp
 import re
 
 from ormlambda.sql.types import ASTERISK
-from ormlambda.common.errors import DuplicatedClauseNameError
+from ormlambda.common.errors import DuplicatedClauseNameError, ReplacePlaceholderError
 from .interface import IClauseInfo
 from ormlambda.common import GlobalChecker, DOT
 from ormlambda import util
@@ -19,16 +19,6 @@ if tp.TYPE_CHECKING:
     from ormlambda.dialects import Dialect
 
 
-class ReplacePlaceholderError(ValueError):
-    def __init__(self, placeholder: str, attribute: str, *args):
-        super().__init__(*args)
-        self.placeholder: str = placeholder
-        self.attr: str = attribute
-
-    def __str__(self):
-        return "You cannot use {" + self.placeholder + "} placeholder without using '" + self.attr + "' attribute"
-
-
 class ClauseInfo[T: Table](IClauseInfo[T]):
     _keyRegex: re.Pattern = re.compile(r"{([^{}:]+)}")
 
@@ -43,11 +33,11 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     @tp.overload
     def __init__(self, table: TableType[T], keep_asterisk: tp.Optional[bool] = ...): ...
     @tp.overload
-    def __init__(self, table: TableType[T], preserve_context: tp.Optional[bool] = ...): ...
-    @tp.overload
     def __init__[TProp](self, table: TableType[T], dtype: tp.Optional[TProp] = ...): ...
     @tp.overload
     def __init__(self, table: TableType[T], literal: bool = ...): ...
+    @tp.overload
+    def __init__(self, table: TableType[T], first_apperance: bool = ...): ...
 
     @tp.overload
     def __init__(self, dialect: Dialect, *args, **kwargs): ...
@@ -59,9 +49,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         alias_table: tp.Optional[AliasType[ColumnProxy]] = None,
         alias_clause: tp.Optional[AliasType[ColumnProxy]] = None,
         keep_asterisk: bool = False,
-        preserve_context: bool = False,
         dtype: tp.Optional[TProp] = None,
         literal: bool = False,
+        first_apperance: bool = False,
         *,
         dialect: Dialect,
         **kw,
@@ -75,21 +65,22 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         self._alias_table: tp.Optional[AliasType[ColumnProxy]] = alias_table
         self._alias_clause: tp.Optional[AliasType[ColumnProxy]] = alias_clause
         self._keep_asterisk: bool = keep_asterisk
-        self._preserve_context: bool = preserve_context
         self._dtype = dtype
         self._literal = literal
+        self._first_apperance = first_apperance
 
         self._dialect: Dialect = dialect
 
         self._placeholderValues: dict[str, tp.Callable[[TProp], str]] = {
             "column": self.replace_column_placeholder,
             "table": self.replace_table_placeholder,
+            "db": self.replace_db_placeholder,
         }
 
         super().__init__(**kw)
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}: query -> {self.query(self._dialect)}"
+        return f"{type(self).__name__}: {self.table}->{self.column}"
 
     def replace_column_placeholder[TProp](self, column: ColumnType[TProp]) -> str:
         if not column:
@@ -97,15 +88,35 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         return self._column_resolver(column)
 
     def replace_table_placeholder[TProp](self, _: ColumnType[TProp]) -> str:
-        if not self.table:
+        if not self._table:
             raise ReplacePlaceholderError("table", "table")
-        return self.table.__table_name__
 
+        # We need to return the name itself without database because we're using it to replace {table} not {db}
+        return self._table.__table_name__
+
+    def replace_db_placeholder[TProp](self, _: ColumnType[TProp]) -> str:
+        if not self._table:
+            raise ReplacePlaceholderError("db", "table")
+
+        # We need to return the name itself without database because we're using it to replace {table} not {db}
+        return self._table.__db_name__
+
+    @util.preload_module("ormlambda.sql")
     @property
-    def table(self) -> TableType[T]:
+    def table(self) -> str:
+        if not self._first_apperance and self.alias_table:
+            return self.wrapped_with_quotes(self.alias_table)
+
+        ForeignKey = util.preloaded.sql_foreign_key.ForeignKey
         if self.is_foreign_key(self._table):
-            return self._table.tright
-        return self._table
+            table = tp.cast(ForeignKey, self._table).tright
+        else:
+            table = self._table
+
+        if not table:
+            return None
+
+        return table.__table_name__ if not table.__db_name__ else self.join_db_and_table(table)
 
     @table.setter
     def table(self, value: TableType[T]) -> None:
@@ -113,26 +124,34 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
     @property
     def alias_clause(self) -> tp.Optional[str]:
-        alias = self._alias_clause
-        return self._alias_resolver(alias)
+        """
+        It must be conditioned by the column. If no columns is set and an alias_clause is specified, the alias will not be applied.
+        """
+        if not self.column:
+            return None
+        return self._alias_resolver(self._alias_clause)
 
-    # TODOL [ ]: if we using this setter, we don't update the _context with the new value. Study if it's necessary
     @alias_clause.setter
     def alias_clause(self, value: str) -> str:
         self._alias_clause = value
 
     @property
     def alias_table(self) -> tp.Optional[str]:
-        alias = self._alias_table
+        return self._alias_resolver(self._alias_table)
 
-        return self._alias_resolver(alias)
-
-
-    # TODOL [ ]: if we using this setter, we don't update the _context with the new value. Study if it's necessary
     @alias_table.setter
     def alias_table(self, value: str) -> str:
         self._alias_table = value
 
+    def _alias_resolver(self, alias: AliasType[ColumnProxy]) -> tp.Optional[str]:
+        if alias is None:
+            return None
+
+        if callable(alias):
+            return self._alias_resolver(alias(self._column))
+
+        return self._replace_placeholder(alias)
+
     def replaced_alias(self, value: str) -> tp.Optional[str]:
         return value
 
@@ -164,7 +183,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._dtype
 
         if isinstance(self._column, Column):
-            return self._column.dbtype
+            return self._column.dtype
 
         if isinstance(self._column, type):
             return self._column
@@ -176,36 +195,40 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def compile(self, dialect: Dialect, **kwargs) -> str:
         return self._create_query(dialect, **kwargs)
 
-    def _create_query(self, dialect: Dialect, **kwargs) -> str:
+    def _create_query(self, dialect: Dialect) -> str:
         # when passing some value that is not a column name
-        if not self.table and not self._alias_clause:
-            return self.column
-
-        if not self.table and self._alias_clause:
-            # it means that we are passing an object with alias. We should delete '' around the object
-            alias_clause = self.alias_clause
-            return self.concat_alias_and_column(self._column, alias_clause)
 
-        # When passing the Table itself without 'column'
-        if self.table and not self._column:
-            if not self._alias_table:
-                return self.join_db_and_table(self.table)
+        table = self.table
+        column = self.column
 
-            alias_table = self.alias_table
-            return self.concat_alias_and_column(self.table.__table_name__, alias_table)
+        if self._first_apperance:
+            return self.concat_clause_with_his_alias(table, self.alias_table)
 
         if self._return_all_columns():
             return self._get_all_columns(dialect)
-        return self._join_table_and_column(self._column, dialect)
 
-    @classmethod
-    def join_db_and_table(cls, table: str| Table, table_name: tp.Optional[str] = None) -> str:
-        table_name = table.__table_name__ if (not table_name and hasattr(table,"__table_name__")) else table_name
+        if not table:
+            return column
+
+        if not column:
+            if self.alias_clause:
+                return self.concat_clause_with_his_alias(table, self.alias_clause)
+            return table
+
+        clause = f"{table}{DOT}{column}"
 
-        db = table.__db_name__ if hasattr(table,"__db_name__") else None
+        caster = dialect.caster()
+
+        dtype = str if self.is_table(self.dtype) else self.dtype
+        wrapped_clause = caster.for_value(clause, dtype).wildcard_to_select(clause)
+        return self.concat_clause_with_his_alias(wrapped_clause, self.alias_clause)
 
-        wrapped_table = cls.wrapped_with_quotes(table_name)
+    @classmethod
+    def join_db_and_table(cls, table: Table) -> str:
+        db = table.__db_name__
+        tbl = table.__table_name__
 
+        wrapped_table = cls.wrapped_with_quotes(tbl)
         if db:
             wrapped_db = cls.wrapped_with_quotes(db)
             return f"{wrapped_db}{DOT}{wrapped_table}"
@@ -216,24 +239,24 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def _join_table_and_column[TProp](self, column: ColumnType[TProp], dialect: Dialect) -> str:
         ColumnProxy = util.preloaded.sql_column.ColumnProxy
 
-        caster = dialect.caster()
+        # Avoid adding 'database name' when we have alias_table
 
-        if self.alias_table:
-            col = column.table if hasattr(column, "table") else column
-            table = self.join_db_and_table(col, self.alias_table)
-        elif isinstance(column, ColumnProxy):
+        if isinstance(column, ColumnProxy):
             table_name: str = column.get_table_chain()
-            table = self.join_db_and_table(column.table, table_name)
+
+            self.alias_table = table_name
         else:
-            table = self.table.__table_name__
+            table = self.table
 
         column: str = self._column_resolver(column)
 
         table_column = f"{table}{DOT}{column}"
 
+        caster = dialect.caster()
+
         dtype = str if self.is_table(self.dtype) else self.dtype
         wrapped_column = caster.for_value(table_column, dtype).wildcard_to_select(table_column)
-        return self.concat_alias_and_column(wrapped_column, self.alias_clause)
+        return self.concat_clause_with_his_alias(wrapped_column, self.alias_clause)
 
     def _return_all_columns(self) -> bool:
         if self._keep_asterisk:
@@ -251,7 +274,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def _get_all_columns(self, dialect: Dialect) -> str:
         def ClauseCreator(column: str) -> ClauseInfo:
             return ClauseInfo(
-                table=self.table,
+                table=self._table,
                 column=column,
                 alias_table=self._alias_table,
                 alias_clause=self._alias_clause,
@@ -262,12 +285,14 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if self._alias_table and self._alias_clause:  # We'll add an "*" when we are certain that we have included 'alias_clause' attr
             return self._join_table_and_column(ASTERISK, dialect)
 
-        columns: list[ClauseInfo] = [ClauseCreator(column).query(dialect) for column in self.table.get_columns()]
+        columns: list[ClauseInfo] = [ClauseCreator(column).query(dialect) for column in self._table.get_columns()]
 
         return ", ".join(columns)
 
-    # FIXME [x]: Study how to deacoplate from mysql database
     def _column_resolver[TProp](self, column: ColumnType[TProp]) -> str:
+        if not column:
+            return None
+
         if isinstance(column, ClauseInfo):
             return column.query(self._dialect)
 
@@ -313,21 +338,12 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         return func(self._column)
 
     @classmethod
-    def concat_alias_and_column(cls, column: str, alias_clause: tp.Optional[str] = None) -> str:
+    def concat_clause_with_his_alias(cls, clause: str, alias_clause: tp.Optional[str] = None) -> str:
         if alias_clause is None:
-            return column
-        alias = f"{column} AS {cls.wrapped_with_quotes(alias_clause)}"
+            return clause
+        alias = f"{clause} AS {cls.wrapped_with_quotes(alias_clause)}"
         return alias
 
-    def _alias_resolver(self, alias: AliasType[ColumnProxy]) -> tp.Optional[str]:
-        if alias is None:
-            return None
-
-        if callable(alias):
-            return self._alias_resolver(alias(self._column))
-
-        return self._replace_placeholder(alias)
-
     @util.preload_module("ormlambda.sql.clauses")
     @staticmethod
     def join_clauses(clauses: list[ColumnProxy], chr: str = " ", *, dialect: Dialect, **kw) -> str:
@@ -340,7 +356,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             if isinstance(c, IComparer):
                 comparer = f"({c.compile(dialect, alias_clause=None).string})"
 
-                query = ClauseInfo(None, comparer, alias_clause=c.alias, dialect=dialect).query(dialect)
+                query = ClauseInfo(None, comparer, dialect=dialect, literal=True).query(dialect) + " AS " + ClauseInfo.wrapped_with_quotes(c.alias)
                 queries.append(query)
                 continue
             # That update control the alias we set by default on select clause

{ormlambda-4.4.4 → ormlambda-4.4.14}/src/ormlambda/sql/column/column.py

@@ -138,6 +138,25 @@ class Column[TProp](ClauseElement):
         """Read the metada when using Annotated typing class, and set the attributes accordingly"""
 
         TypeEngine = util.preloaded.sql_type_api.TypeEngine
+        ANNOTATED_SELECTOR: dict[ObjType, Callable[[Column, ObjType], None]] = {
+            TypeEngine: lambda x, data: setattr(x, "_dtype", data),
+            PrimaryKey: lambda x, _: setattr(x, "is_primary_key", True),
+            AutoGenerated: lambda x, _: setattr(x, "is_auto_generated", True),
+            AutoIncrement: lambda x, _: setattr(x, "is_auto_increment", True),
+            Unique: lambda x, _: setattr(x, "is_unique", True),
+            CheckTypes: lambda x, _: setattr(x, "_check", True),
+            Default: lambda x, meta: (
+                setattr(x, "default_value", cast(Default, meta).value),
+                setattr(x, "is_auto_generated", True),
+            ),
+            NotNull: lambda x, _: setattr(x, "is_not_null", True),
+        }
+
+        def get_handler(obj_type: ObjType) -> Optional[Callable[[Column, ObjType], None]]:
+            for key, handler in ANNOTATED_SELECTOR.items():
+                if issubclass(obj_type, key):
+                    return handler
+            return None
 
         annotations = get_type_hints(obj, include_extras=True)
         if name in annotations:
@@ -149,24 +168,10 @@ class Column[TProp](ClauseElement):
 
             type ObjType = Metadata | TypeEngine
 
-            ANNOTATED_SELECTOR: dict[ObjType, Callable[[Column, ObjType], None]] = {
-                TypeEngine: lambda x, data: setattr(x, "_dtype", data),
-                PrimaryKey: lambda x, _: setattr(x, "is_primary_key", True),
-                AutoGenerated: lambda x, _: setattr(x, "is_auto_generated", True),
-                AutoIncrement: lambda x, _: setattr(x, "is_auto_increment", True),
-                Unique: lambda x, _: setattr(x, "is_unique", True),
-                CheckTypes: lambda x, _: setattr(x, "_check", True),
-                Default: lambda x, meta: (
-                    setattr(x, "default_value", cast(Default, meta).value),
-                    setattr(x, "is_auto_generated", True),
-                ),
-                NotNull: lambda x, _: setattr(x, "is_not_null", True),
-            }
-
             for meta in metadata:
                 if not isinstance(meta, Metadata | TypeEngine):
                     raise ValueError(f"When using 'Annotated' to pass metadata into Column, you must instantiate those metadata. You passed '{meta.__name__}'")
-                func = ANNOTATED_SELECTOR.get(type(meta), None)
+                func = get_handler(type(meta))
 
                 if not func:
                     continue

{ormlambda-4.4.4 → ormlambda-4.4.14}/src/ormlambda/sql/compiler.py

@@ -13,8 +13,10 @@ from ormlambda.sql.sqltypes import resolve_primitive_types
 
 from .visitors import Visitor
 from ormlambda.sql.type_api import TypeEngine
+from ormlambda.sql.clause_info import ClauseInfo
 
 if TYPE_CHECKING:
+    from ormlambda import Table
     from ormlambda import Column
     from .visitors import Element
     from .elements import ClauseElement
@@ -141,6 +143,9 @@ class TypeCompiler(Visitor):
 class SQLCompiler(Compiled):
     is_sql = True
 
+    def visit_table(self, table: Table):
+        return ClauseInfo(table=table, dialect=self.dialect).query(dialect=self.dialect)
+
 
 class DDLCompiler(Compiled):
     is_ddl = True
@@ -210,7 +215,7 @@ class DDLCompiler(Compiled):
             foreign_keys_string.append(fk.compile(self.dialect, orig_table=tablecls).string)
         table_options = " ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci"
 
-        sql = f"CREATE TABLE {tablecls.__table_name__} (\n\t"
+        sql = f"CREATE TABLE {SQLCompiler.visit_table(self,tablecls)} (\n\t"
         sql += ",\n\t".join(column_sql)
         sql += "\n\t" if not foreign_keys else ",\n\t"
         sql += ",\n\t".join(foreign_keys_string)