sqlobjects 1.2.0__tar.gz → 1.2.2__tar.gz

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.2.2 (2026-02-26)
+
+### Fix
+
+- clone Column descriptor per subclass to prevent shared ColumnAttribute binding
+
+## 1.2.1 (2026-02-25)
+
+### Refactor
+
+- centralize session resolution in get_session()
+
 ## 1.2.0 (2026-02-25)
 
 ### Feat

{sqlobjects-1.2.0/sqlobjects.egg-info → sqlobjects-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.2.0
+Version: 1.2.2
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlobjects"
-version = "1.2.0"
+version = "1.2.2"
 description = "Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading"
 readme = "README.md"
 license = "MIT"

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/sqlobjects/metadata.py

@@ -938,13 +938,25 @@ class ModelProcessor(type):
             cls: Model class
             table: SQLAlchemy Table instance
         """
-        for name, field_def in mcs._get_fields(cls).items():
-            if is_field_definition(field_def) and not getattr(field_def, "_is_relationship", False):
-                column_attr = get_column_from_field(field_def)
-                if column_attr is not None and hasattr(column_attr, "__column__"):
-                    # Update the ColumnAttribute's internal column to reference the table column
-                    if name in table.columns:
+        for name in table.columns.keys():
+            for klass in cls.__mro__:
+                descriptor = klass.__dict__.get(name)
+                if descriptor is not None and hasattr(descriptor, "_column_attribute"):
+                    column_attr = descriptor._column_attribute
+                    if column_attr is None or not hasattr(column_attr, "__column__"):
+                        break
+                    if klass is cls:
                         column_attr.__column__ = table.columns[name]  # type: ignore[reportAttributeAccessIssue]
+                    else:
+                        new_col_attr = object.__new__(type(column_attr))
+                        new_col_attr.__dict__.update(column_attr.__dict__)
+                        new_col_attr.__column__ = table.columns[name]
+                        new_col_attr.model_class = cls
+                        new_descriptor = object.__new__(type(descriptor))
+                        new_descriptor.__dict__.update(descriptor.__dict__)
+                        new_descriptor._column_attribute = new_col_attr
+                        type.__setattr__(cls, name, new_descriptor)
+                    break
 
     @classmethod
     def _initialize_field_cache(mcs, cls: Any) -> None:

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/sqlobjects/mixins.py

@@ -165,10 +165,7 @@ class SessionMixin(BaseMixin):
         Returns:
             AsyncSession instance for database operations
         """
-        bound_session = self._state_manager.get_bound_session()
-        if isinstance(bound_session, str):
-            return get_session(bound_session)
-        return bound_session or get_session()
+        return get_session(self._state_manager.get_bound_session())
 
     def using(self, db_or_session: str | AsyncSession):
         """Return self bound to specific database/connection.

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/sqlobjects/objects/core.py

@@ -82,12 +82,7 @@ class ObjectsManager(Generic[T]):
         Returns:
             AsyncSession instance
         """
-        if self._db_or_session is None:
-            return get_session(readonly=readonly)
-        elif isinstance(self._db_or_session, str):
-            return get_session(self._db_or_session, readonly=readonly)
-        else:
-            return self._db_or_session
+        return get_session(self._db_or_session, readonly=readonly)
 
     def _validate_field_names(self, **kwargs) -> None:
         """Validate that all field names exist on the model.

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/sqlobjects/queries/dialect.py

@@ -1,6 +1,7 @@
 """Database dialect handlers for database-specific SQL generation."""
 
 from abc import ABC, abstractmethod
+from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any
 
 import sqlalchemy as sa
@@ -46,7 +47,7 @@ class BaseDialect(ABC):
         pass
 
     @abstractmethod
-    def parse_explain_result(self, rows: list) -> str:
+    def parse_explain_result(self, rows: Sequence) -> str:
         """Parse EXPLAIN result for the database."""
         pass
 
@@ -108,7 +109,7 @@ class PostgreSQLDialect(BaseDialect):
             return f"EXPLAIN ({', '.join(options)}) {sql}"
         return f"EXPLAIN {sql}"
 
-    def parse_explain_result(self, rows: list) -> str:
+    def parse_explain_result(self, rows: Sequence) -> str:
         """Parse PostgreSQL EXPLAIN result."""
         return "\n".join(str(row[0]) for row in rows)
 
@@ -151,7 +152,7 @@ class MySQLDialect(BaseDialect):
             return f"EXPLAIN ANALYZE {sql}"
         return f"EXPLAIN {sql}"
 
-    def parse_explain_result(self, rows: list) -> str:
+    def parse_explain_result(self, rows: Sequence) -> str:
         """Parse MySQL EXPLAIN result."""
         return "\n".join(str(row[0]) for row in rows)
 
@@ -199,7 +200,7 @@ class SQLiteDialect(BaseDialect):
         """
         return f"EXPLAIN QUERY PLAN {sql}"
 
-    def parse_explain_result(self, rows: list) -> str:
+    def parse_explain_result(self, rows: Sequence) -> str:
         """Parse SQLite EXPLAIN result.
 
         SQLite EXPLAIN QUERY PLAN returns: (id, parent, notused, detail)

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/sqlobjects/queries/executor.py

@@ -18,13 +18,22 @@ class QueryExecutor:
     aggregations, and memory-efficient iteration for large datasets.
     """
 
+    _WRITE_TYPES = frozenset({"update", "delete"})
+
     def __init__(self, session=None):
         """Initialize executor with optional session.
 
         Args:
-            session: Database session for query execution
+            session: Database session, database name string, or None
         """
-        self.session = session
+        self._db_or_session = session
+
+    def _get_session(self, query_type: str):
+        """Resolve session with appropriate readonly flag."""
+        from ..session import get_session
+
+        readonly = query_type not in self._WRITE_TYPES
+        return get_session(self._db_or_session, readonly=readonly)
 
     async def execute(
         self,
@@ -115,23 +124,24 @@ class QueryExecutor:
         Returns:
             Query execution plan as string
         """
-        if not self.session:
+        session = self._get_session("all")
+        if not session:
             raise RuntimeError("No session available for explain operation")
 
         # Get dialect handler
         from .dialect import DialectHandler
 
-        dialect = DialectHandler.create(self.session)
+        dialect = DialectHandler.create(session)
 
         # Compile query to SQL
-        compiled = query.compile(dialect=self.session.bind.dialect, compile_kwargs={"literal_binds": True})
+        compiled = query.compile(dialect=session.bind.dialect, compile_kwargs={"literal_binds": True})
         sql_str = str(compiled)
 
         # Build EXPLAIN query using dialect handler
         explain_sql = dialect.build_explain_query(sql_str, analyze, verbose)
 
         # Execute query
-        result = await self.session.execute(text(explain_sql))
+        result = await session.execute(text(explain_sql))
         rows = result.fetchall()
 
         # Parse result using dialect handler
@@ -196,7 +206,8 @@ class QueryExecutor:
         relationships=None,
     ):
         """Execute query and return appropriate result."""
-        if not self.session:
+        session = self._get_session(query_type)
+        if not session:
             if query_type == "all":
                 return []
             elif query_type in ("count", "update", "delete"):
@@ -206,7 +217,7 @@ class QueryExecutor:
             else:  # exists
                 return False
 
-        result = await self.session.execute(query)
+        result = await session.execute(query)
 
         if query_type == "all":
             rows = result.fetchall()
@@ -417,7 +428,7 @@ class QueryExecutor:
         if not instances or not prefetch_relationships:
             return instances
 
-        prefetch_handler = PrefetchHandler(self.session)
+        prefetch_handler = PrefetchHandler(self._get_session("all"))
         return await prefetch_handler.handle_prefetch_relationships(instances, prefetch_relationships)
 
     @staticmethod

{sqlobjects-1.2.0 → sqlobjects-1.2.2}/sqlobjects/session.py

@@ -345,11 +345,13 @@ async def ctx_sessions(*db_names: str) -> AsyncGenerator[dict[str, AsyncSession]
             _SessionContextManager.clear_session(db_name)
 
 
-def get_session(db_name: str | None = None, readonly: bool = True, auto_commit: bool = True) -> AsyncSession:
+def get_session(
+    db_or_name: str | AsyncSession | None = None, readonly: bool = True, auto_commit: bool = True
+) -> AsyncSession:
     """Get database session with readonly optimization.
 
     Args:
-        db_name: Database name (uses default database if None)
+        db_or_name: Database name, existing AsyncSession, or None for default database
         readonly: True for readonly (no transaction), False for transactional
         auto_commit: True to auto-commit transactions (ignored if readonly=True)
 
@@ -357,10 +359,13 @@ def get_session(db_name: str | None = None, readonly: bool = True, auto_commit:
         AsyncSession instance
 
     Priority:
+        - If db_or_name is an AsyncSession, return it directly
         - First try use explicitly set session (ctx_session, ctx_sessions)
         - Create a new AsyncSession with specified parameters if no explicit session
     """
-    return _SessionContextManager.get_session(db_name, readonly, auto_commit)
+    if isinstance(db_or_name, AsyncSession):
+        return db_or_name
+    return _SessionContextManager.get_session(db_or_name, readonly, auto_commit)
 
 
 def has_session(db_name: str | None = None) -> bool:

{sqlobjects-1.2.0 → sqlobjects-1.2.2/sqlobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.2.0
+Version: 1.2.2
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>