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

ormlambda/{databases/my_sql → sql}/functions/concat.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing as tp
 
 from ormlambda.sql.clause_info import AggregateFunctionBase
@@ -9,7 +10,11 @@ from ormlambda.sql.clause_info import ClauseInfo
 type ConcatResponse[TProp] = tuple[str | ColumnType[TProp]]
 
 
-class Concat[T](AggregateFunctionBase):
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class Concat[T](AggregateFunctionBase[T]):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "CONCAT"
@@ -19,22 +24,25 @@ class Concat[T](AggregateFunctionBase):
         values: ConcatResponse[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "concat",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ) -> None:
         super().__init__(
             table=None,
             column=values,
             alias_clause=alias_clause,
             context=context,
+            dtype=str,
+            dialect=dialect,
         )
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         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):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context=context, dialect=self._dialect):
             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)
+        return self._concat_alias_and_column(f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})", self._alias_aggregate)

ormlambda/{databases/my_sql → sql}/functions/max.py

@@ -6,6 +6,9 @@ from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class Max(AggregateFunctionBase[None]):
     @staticmethod
@@ -17,6 +20,8 @@ class Max(AggregateFunctionBase[None]):
         elements: ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "max",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ):
         super().__init__(
             table=None,
@@ -26,18 +31,18 @@ class Max(AggregateFunctionBase[None]):
             context=context,
             keep_asterisk=False,
             preserve_context=False,
+            dialect=dialect,
         )
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         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):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, dialect=self._dialect):
             new_clause = clause
             new_clause.alias_clause = None
             columns.append(new_clause)
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
         return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/{databases/my_sql → sql}/functions/min.py

@@ -6,6 +6,9 @@ from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class Min(AggregateFunctionBase):
     @staticmethod
@@ -17,27 +20,20 @@ class Min(AggregateFunctionBase):
         elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "min",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ):
-        super().__init__(
-            table=None,
-            column=elements,
-            alias_table=None,
-            alias_clause=alias_clause,
-            context=context,
-            keep_asterisk=False,
-            preserve_context=False,
-        )
+        super().__init__(table=None, column=elements, alias_table=None, alias_clause=alias_clause, context=context, keep_asterisk=False, preserve_context=False, dialect=dialect)
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         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):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, dialect=self._dialect):
             new_clause = clause
             new_clause.alias_clause = None
             columns.append(new_clause)
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
         return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/{databases/my_sql → sql}/functions/sum.py

@@ -6,18 +6,16 @@ from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class Sum(AggregateFunctionBase):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "SUM"
 
-    def __init__[TProp](
-        self,
-        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
-        alias_clause: AliasType[ColumnType[TProp]] = "sum",
-        context: ClauseContextType = None,
-    ):
+    def __init__[TProp](self, elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp], alias_clause: AliasType[ColumnType[TProp]] = "sum", context: ClauseContextType = None, *, dialect: Dialect):
         super().__init__(
             table=None,
             column=elements,
@@ -26,18 +24,18 @@ class Sum(AggregateFunctionBase):
             context=context,
             keep_asterisk=False,
             preserve_context=False,
+            dialect=dialect,
         )
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         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):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, self._dialect):
             new_clause = clause
             new_clause.alias_clause = None
             columns.append(new_clause)
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
         return self._concat_alias_and_column(method_string, self._alias_aggregate)