ormlambda 3.35.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

ormlambda/sql/context/__init__.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+import threading
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Generator, Literal, Optional, Any, TypedDict, Protocol
+
+
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda.sql import ForeignKey
+    from ormlambda.sql.context import FKChain
+    from ormlambda.sql.clauses import JoinSelector
+
+type CurrentPathType = FKChain
+type ForeignKeyRegistryType = dict[str, ForeignKey]
+type QueryMetadataType = dict[str, Any]
+type TableAliasType = dict[str, str]  # table_name -> alias
+type ClauseAliasType = dict[str, str]  # clause_key -> alias
+type JoinSelectorType = dict[str, str]  # clause_key -> alias
+
+# Separate persistent and transient data types
+type PersistentDataKeys = Literal["foreign_key_registry"]
+type ContextDictKeys = Literal[
+    "current_path",
+    "foreign_key_registry",
+    "query_metadata",
+    "table_aliases",
+    "join_selector",
+]
+
+
+class ContextDict(TypedDict):
+    current_path: CurrentPathType
+    foreign_key_registry: ForeignKeyRegistryType  # PERSISTENT: Survives across queries
+    query_metadata: QueryMetadataType  # TRANSIENT: Reset per query
+    table_aliases: TableAliasType  # TRANSIENT: Reset per query
+    join_selector: JoinSelectorType  # TRANSIENT: Reset per query
+
+
+class LocalContext(Protocol):
+    context: ContextDict
+
+
+class PathContext:
+    _local: LocalContext
+
+    def __init__(self):
+        self._local = threading.local()
+
+    def __repr__(self):
+        return f"{PathContext.__name__}"
+
+    @staticmethod
+    def _initialize_context() -> ContextDict:
+        return {
+            "current_path": NO_CURRENT_PATH,
+            "foreign_key_registry": {},
+            "query_metadata": {},
+            "table_aliases": {},
+            "join_selector": {},
+        }
+
+    def _get_context(self, key: Optional[ContextDictKeys] = None) -> ContextDict:
+        """
+        we Always need to return the context variable itself to has a references to the context variable.
+        An approach like return self._initialize_context() won't work as expected
+        """
+        if not self.has_context():
+            self._set_context(self._initialize_context())
+
+        return self._local.context if not key else self._local.context.get(key, None)
+
+    def _set_context(self, context: ContextDict) -> None:
+        self._local.context = context
+        return None
+
+    def get_current_path(self) -> Optional[FKChain]:
+        return self._get_context("current_path")
+
+    def set_current_path(self, path: FKChain) -> None:
+        context = self._get_context()
+        context["current_path"] = path
+        return None
+
+    def add_foreign_key_access(self, fk: ForeignKey, path: FKChain) -> None:
+        context = self._get_context()
+
+        # Store in registry
+        if fk not in context["foreign_key_registry"]:
+            context["foreign_key_registry"][f"{fk.tleft.__table_name__}.{fk.clause_name}"] = fk
+
+        return None
+
+    def get_all_foreign_key_accesses(self) -> ForeignKeyRegistryType:
+        return self._get_context("foreign_key_registry").copy()
+
+    def get_foreign_key_from_registry(self, key: str) -> Optional[ForeignKey]:
+        """Get a specific ForeignKey from the registry by key"""
+        return self._get_context("foreign_key_registry").get(key, None)
+
+    def remove_foreign_key_from_registry(self, key: str) -> bool:
+        """Remove a ForeignKey from the registry. Returns True if removed, False if not found"""
+        context = self._get_context()
+        if key in context["foreign_key_registry"]:
+            del context["foreign_key_registry"][key]
+            return True
+        return False
+
+    def clear_foreign_key_registry(self) -> None:
+        """Clear only the ForeignKey registry while preserving other context"""
+        context = self._get_context()
+        context["foreign_key_registry"].clear()
+        return None
+
+    def get_foreign_key_registry_size(self) -> int:
+        """Get the number of ForeignKeys in the registry"""
+        return len(self._get_context("foreign_key_registry"))
+
+    def clear_context(self):
+        """Clear all context data (legacy method - use clear_all_context for clarity)"""
+        self.clear_all_context()
+
+    def clear_all_context(self) -> None:
+        """Clear all context data including persistent ForeignKey registry"""
+        if self.has_context():
+            delattr(self._local, "context")
+
+    def clear_transient_context(self) -> None:
+        """Clear only transient context data, preserving ForeignKey registry"""
+        if not self.has_context():
+            return None
+
+        context = self._get_context()
+        # Preserve foreign_key_registry, clear everything else
+        preserved_registry = context["foreign_key_registry"].copy()
+
+        context["current_path"] = NO_CURRENT_PATH
+        context["query_metadata"].clear()
+        context["table_aliases"].clear()
+        context["join_selector"].clear()
+        # Restore preserved registry
+        context["foreign_key_registry"] = preserved_registry
+
+        return None
+
+    def reset_query_context(self) -> None:
+        """Reset context for new query while preserving persistent data"""
+        self.clear_transient_context()
+
+    def has_context(self) -> bool:
+        return hasattr(self._local, "context")
+
+    @contextmanager
+    def query_context(self, table: Optional[Table] = None) -> Generator[PathContext, None, None]:
+        """Context manager for query execution with proper cleanup"""
+        # Store the old context if it exists
+        old_context = None
+        if self.has_context():
+            old_context = self._get_context()
+
+        try:
+            self.initialize_context_with_table(table)
+            yield self
+
+        finally:
+            # Restore old context or use selective clearing to preserve FK registry
+            if old_context is not None:
+                self._set_context(old_context)
+            else:
+                # Use selective clearing to preserve foreign_key_registry
+                self.reset_query_context()
+
+    def initialize_context_with_table(self, table: Optional[Table] = None) -> None:
+        # Preserve foreign_key_registry if context already exists
+        preserved_registry = {}
+        if self.has_context():
+            preserved_registry = self._get_context("foreign_key_registry").copy()
+
+        self._set_context(self._initialize_context())
+
+        # Restore preserved registry
+        if preserved_registry:
+            context = self._get_context()
+            context["foreign_key_registry"] = preserved_registry
+
+        if not table:
+            return None
+
+        initial_path = FKChain(table, [])
+        self.set_current_path(initial_path)
+        return None
+
+    def reset_current_path(self, table):
+        initial_path = FKChain(table, [])
+        self.set_current_path(initial_path)
+        return None
+
+    #  FIXME [x]: Alias Management Methods (replacing ClauseInfoContext functionality)
+    def add_table_alias(self, table: Table, alias: str) -> None:
+        """Add a table alias to the context"""
+        if not table or not alias:
+            return None
+
+        context = self._get_context()
+        table_key = table.__table_name__ if hasattr(table, "__table_name__") else str(table)
+        context["table_aliases"][table_key] = alias
+        return None
+
+    def get_table_alias(self, table: Table) -> Optional[str]:
+        """Get a table alias from the context"""
+        if not table:
+            return None
+
+        context = self._get_context()
+        table_key = table.__table_name__ if hasattr(table, "__table_name__") else str(table)
+        return context["table_aliases"].get(table_key, None)
+
+    def add_join(self, join: JoinSelector, alias: str) -> None:
+        """Add a table alias to the context"""
+        if not join or not alias:
+            return None
+
+        context = self._get_context()
+        context["join_selector"][alias] = join
+        return None
+
+    def get_join(self, alias: str) -> Optional[str]:
+        """Get a table alias from the context"""
+        if not alias:
+            return None
+
+        context = self._get_context("join_selector")
+        return context.get(alias, None)
+
+
+class FKChain:
+    base: Optional[Table]
+    steps: list[ForeignKey]
+
+    def __init__(
+        self,
+        base: Optional[Table] = None,
+        steps: Optional[list[Table]] = None,
+    ):
+        self.base = base if base else None
+        self.steps = steps if steps else []
+
+    def __repr__(self):
+        return f"{FKChain.__name__}: {self.get_path_key()}"
+
+    @property
+    def parent(self) -> FKChain:
+        # FIXME [ ]: what if we reach the top parent? we need to return None in some point
+        if len(self.steps) <= 1:
+            steps = []
+        else:
+            steps = self.steps[:-1].copy()
+
+        return FKChain(self.base, steps)
+
+    def add_step(self, step: Table | ForeignKey):
+        """Add a step to the path"""
+        if not self.base:
+            self.base = step
+            return None
+
+        self.steps.append(step)
+        return None
+
+    def copy(self) -> FKChain:
+        return FKChain(base=self.base, steps=self.steps.copy())
+
+    def get_path_key(self) -> str:
+        return self._generate_chain(".")
+
+    def get_alias(self) -> str:
+        """Generate table alias from the path"""
+        if not self.base:
+            return ""
+        return self._generate_chain("_") if self.steps else self.base.__table_name__
+
+    def _generate_chain(self, char: str) -> str:
+        if not self.base:
+            return ""
+        result: list[Table] = [self.base.__table_name__]
+        for step in self.steps:
+            # For foreign keys, use their clause name or a descriptive name
+            data = getattr(step, "clause_name", f"fk_{step.__class__.__name__}")
+            result.append(data)
+        return char.join(result)
+
+    def get_depth(self) -> int:
+        """Get the depth of this path (number of foreign key steps)"""
+        return len(self.steps)
+
+    def clear(self) -> None:
+        self.steps.clear()
+
+    def __getitem__(self, number: int):
+        return FKChain(self.base, self.steps[number])
+
+
+NO_CURRENT_PATH = FKChain(None, [])
+
+PATH_CONTEXT = PathContext()

ormlambda/sql/ddl.py

@@ -3,7 +3,8 @@ from typing import TYPE_CHECKING
 from .elements import ClauseElement
 
 if TYPE_CHECKING:
-    from ormlambda.dialects.interface.dialect import Dialect
+    from ormlambda import URL
+    from ormlambda.dialects import Dialect
     from ormlambda import Column
     from ormlambda import Table
 
@@ -22,16 +23,22 @@ class BaseDDLElement(ClauseElement):
         return dialect.ddl_compiler(dialect, self, **kw)
 
 
-class CreateTable(BaseDDLElement):
+class CreateDropTable:
+    def __init__(self, element: Table):
+        self.element = element
+        self.columns = [CreateColumn(c) for c in element.get_columns()]
+
+
+class CreateTable(CreateDropTable, BaseDDLElement):
     """
     Class representing a CREATE TABLE statement.
     """
 
     __visit_name__ = "create_table"
 
-    def __init__(self, element: Table):
-        self.element = element
-        self.columns = [CreateColumn(c) for c in element.get_columns()]
+
+class DropTable(CreateDropTable, BaseDDLElement):
+    __visit_name__ = "drop_table"
 
 
 class CreateColumn[T](BaseDDLElement):
@@ -66,3 +73,10 @@ class SchemaExists(BaseDDLElement):
 
     def __init__(self, schema: str):
         self.schema = schema
+
+
+class CreateBackup(BaseDDLElement):
+    __visit_name__ = "create_backup"
+
+    def __init__(self, url: URL):
+        self.url = url

ormlambda/sql/elements.py

@@ -34,3 +34,6 @@ class ClauseElement(CompilerElement):
     """
 
     __visit_name__ = "clause_element"
+
+    def __repr__(self):
+        return f"{ClauseElement.__name__}: {type(self).__name__}"

ormlambda/sql/foreign_key.py

@@ -1,42 +1,28 @@
 from __future__ import annotations
-from typing import Callable, TYPE_CHECKING, Optional, Any, Type, cast, overload, ClassVar
+import logging
+from typing import Callable, TYPE_CHECKING, Optional, Any, Type, overload
 
-from ormlambda.common.interfaces.IQueryCommand import IQuery
-from ormlambda.sql.elements import Element
+from ormlambda.sql.ddl import BaseDDLElement
 
 if TYPE_CHECKING:
     from ormlambda.sql.comparer import Comparer
     from ormlambda import Table
-    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
     from ormlambda.dialects import Dialect
 
+from ormlambda.util import preloaded as _preloaded
 
-class ForeignKeyContext(set["ForeignKey"]):
-    def clear(self):
-        to_remove = {x for x in self if not cast(ForeignKey, x)._keep_alive}
-        for el in to_remove:
-            self.remove(el)
+log = logging.getLogger(__name__)
 
-    def remove(self, element):
-        return super().remove(element)
 
-    def pop(self, item):
-        for el in self:
-            if el != item:
-                continue
-
-            if not cast(ForeignKey, el)._keep_alive:
-                super().remove(el)
-            return el
-
-    def add(self, element):
-        return super().add(element)
-
-
-class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
+class ForeignKey[TLeft: Table, TRight: Table](BaseDDLElement):
     __visit_name__ = "foreign_key"
 
-    stored_calls: ClassVar[ForeignKeyContext] = ForeignKeyContext()
+    __slots__ = (
+        "_tright",
+        "_relationship",
+        "_comparer",
+        "_clause_name",
+    )
 
     @overload
     def __new__(self, comparer: Comparer, clause_name: str) -> None: ...
@@ -59,11 +45,9 @@ class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
         *,
         comparer: Optional[Comparer] = None,
         clause_name: Optional[str] = None,
-        keep_alive: bool = False,
         **kwargs: Any,
     ) -> None:
         self.kwargs = kwargs
-        self._keep_alive = keep_alive
         if comparer is not None and clause_name is not None:
             self.__init__with_comparer(comparer, clause_name, **kwargs)
         else:
@@ -71,8 +55,8 @@ class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
 
     def __init__with_comparer(self, comparer: Comparer, clause_name: str, **kwargs) -> None:
         self._relationship = None
-        self._tleft: TLeft = comparer.left_condition(**kwargs).table
-        self._tright: TRight = comparer.right_condition(**kwargs).table
+        self._tleft: TLeft = comparer.left_condition.table
+        self._tright: TRight = comparer.right_condition.table
         self._clause_name: str = clause_name
         self._comparer: Comparer = comparer
 
@@ -88,10 +72,9 @@ class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
         self._clause_name: str = name
 
     def __get__(self, obj: Optional[TRight], objtype=None) -> ForeignKey[TLeft, TRight] | TRight:
-        if not obj:
-            ForeignKey.stored_calls.add(self)
-            return self
-        return self._tright
+        if obj:
+            return self.tright
+        return self
 
     def __set__(self, obj, value):
         raise AttributeError(f"The {ForeignKey.__name__} '{self._clause_name}' in the '{self._tleft.__table_name__}' table cannot be overwritten.")
@@ -102,50 +85,45 @@ class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
         return getattr(self._tright, name)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(" f"left={self._tleft.__name__ if self._tleft else 'None'}, " f"right={self._tright.__name__ if self._tright else 'None'}, " f"name={self._clause_name})"
+        return f"{self.__class__.__name__}(left={self._tleft.__name__ if self._tleft else 'None'}, right={self._tright.__name__ if self._tright else 'None'}, name={self._clause_name})"
 
     @property
-    def tleft(self) -> TLeft:
+    def tleft(self) -> Table:
         return self._tleft
 
     @property
-    def tright(self) -> TRight:
+    def tright(self) -> Table:
         return self._tright
 
     @property
     def clause_name(self) -> str:
         return self._clause_name
 
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        compare = self.resolved_function(dialect)
-        left_col = compare.left_condition(dialect).column
-        rcon = alias if (alias := compare.right_condition(dialect).alias_table) else compare.right_condition(dialect).table.__table_name__
-        return f"FOREIGN KEY ({left_col}) REFERENCES {rcon}({compare.right_condition(dialect).column})"
-
     def get_alias(self, dialect: Dialect) -> str:
-        self._comparer = self.resolved_function(dialect)
-        self._comparer._dialect = dialect
-        lcol = self._comparer.left_condition(dialect)._column.column_name
-        rcol = self._comparer.right_condition(dialect)._column.column_name
-        return f"{self.tleft.__table_name__}_{lcol}_{rcol}"
-
-    @classmethod
-    def create_query(cls, orig_table: Table, dialect: Dialect) -> list[str]:
-        clauses: list[str] = []
-
-        for attr in orig_table.__dict__.values():
-            if isinstance(attr, ForeignKey):
-                clauses.append(attr.query(dialect))
-        return clauses
-
-    def resolved_function[LProp: Any, RProp: Any](self, dialect: Dialect, context: Optional[ClauseContextType] = None) -> Comparer:
-        """ """
+        self._comparer = self.resolved_function()
+        # TODOH []: look into why i dropped 'lcol' variable
+        return f"{self.tleft.__table_name__}_{self.clause_name}"
+
+    @_preloaded.preload_module("ormlambda.sql.table")
+    def resolved_function(self) -> Comparer:
+        util = _preloaded.sql_table
+
         if self._comparer is not None:
             return self._comparer
 
-        left = self._tleft
-        right = self._tright
+        left = util.TableProxy(self._tleft)
+        right = util.TableProxy(self._tright)
         comparer = self._relationship(left, right)
-        comparer.set_context(context)
-        comparer._dialect = dialect
         return comparer
+
+    def __hash__(self):
+        return hash(
+            (
+                self._tleft,
+                self._tright,
+                self._clause_name,
+            )
+        )
+
+    def __eq__(self, other: ForeignKey):
+        return hash(other) == hash(self)

ormlambda/sql/functions/__init__.py

@@ -1,5 +1,4 @@
 from .max import Max as Max
 from .min import Min as Min
 from .concat import Concat as Concat
-from ..clauses.group_by import GroupBy as GroupBy
 from .sum import Sum as Sum

ormlambda/sql/functions/concat.py

@@ -1,48 +1,45 @@
 from __future__ import annotations
-import typing as tp
+from typing import Any, Iterable
 
-from ormlambda.sql.clause_info import AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import ClauseInfo
-
-
-type ConcatResponse[TProp] = tuple[str | ColumnType[TProp]]
 
+from ormlambda.sql.clause_info import IAggregate
+from ormlambda.sql.elements import ClauseElement
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda import ColumnProxy, TableProxy
+from ormlambda.common import GlobalChecker
 
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
+VALID_CONCAT_TYPES = ColumnProxy | str | TableProxy
 
 
-class Concat[T](AggregateFunctionBase[T]):
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "CONCAT"
+class Concat[T](ClauseElement, IAggregate):
+    __visit_name__ = "concat"
 
     def __init__[TProp](
         self,
-        values: ConcatResponse[TProp],
-        alias_clause: AliasType[ColumnType[TProp]] = "concat",
-        context: ClauseContextType = None,
-        *,
-        dialect: Dialect,
+        values: tuple[str | ColumnType[TProp] | TableProxy[T], ...],
+        alias: AliasType[ColumnType[TProp]] = "concat",
     ) -> None:
-        super().__init__(
-            table=None,
-            column=values,
-            alias_clause=alias_clause,
-            context=context,
-            dtype=str,
-            dialect=dialect,
-        )
-
-    @tp.override
-    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, 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,dialect=self._dialect)})", self._alias_aggregate)
+        if isinstance(values, TableProxy):
+            values = GlobalChecker.parser_object(values, values._table_class)
+        if not self.is_valid(values):
+            raise ValueError(values)
+
+        self.values = values
+        self.alias = alias
+
+    def used_columns(self):
+        return [x for x in self.values if not isinstance(x, str)]
+
+    @property
+    def dtype(self) -> str:
+        return str
+
+    @staticmethod
+    def is_valid(values: Any) -> bool:
+        if not isinstance(values, Iterable):
+            return False
+        for val in values:
+            if not isinstance(val, VALID_CONCAT_TYPES):
+                return False
+
+        return True

ormlambda/sql/functions/max.py

@@ -1,48 +1,24 @@
 from __future__ import annotations
-import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.elements import ClauseElement
 from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info import IAggregate
 
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
 
-
-class Max(AggregateFunctionBase[None]):
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "MAX"
+class Max(ClauseElement, IAggregate):
+    __visit_name__ = "max"
 
     def __init__[TProp](
         self,
         elements: ColumnType[TProp],
-        alias_clause: AliasType[ColumnType[TProp]] = "max",
-        context: ClauseContextType = None,
-        *,
-        dialect: Dialect,
+        alias: AliasType[ColumnType[TProp]] = "max",
     ):
-        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
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        columns: list[str] = []
+        self.column = elements
+        self.alias = alias
 
-        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, dialect=self._dialect):
-            new_clause = clause
-            new_clause.alias_clause = None
-            columns.append(new_clause)
+    def used_columns(self):
+        return [self.column]
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
-        return self._concat_alias_and_column(method_string, self._alias_aggregate)
+    @property
+    def dtype(self) -> int:
+        return int