sqlobjects 1.1.0__tar.gz → 1.2.0__tar.gz

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

@@ -1,3 +1,9 @@
+## 1.2.0 (2026-02-25)
+
+### Feat
+
+- **metadata**: improve constraint and index naming conventions
+
 ## 1.1.0 (2026-02-14)
 
 ### Feat

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.1.0
+Version: 1.2.0
 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.1.0 → sqlobjects-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlobjects"
-version = "1.1.0"
+version = "1.2.0"
 description = "Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading"
 readme = "README.md"
 license = "MIT"
@@ -49,22 +49,22 @@ Changelog = "https://github.com/XtraVisionsAI/sqlobjects/blob/main/CHANGELOG.md"
 
 [dependency-groups]
 dev = [
-    "pre-commit>=4.4.0",
-    "pyright>=1.1.407",
-    "ruff>=0.14.5",
-    "setuptools>=80.9.0",
+    "pre-commit>=4.5.1",
+    "pyright>=1.1.408",
+    "ruff>=0.15.2",
+    "setuptools>=82.0.0",
 ]
 test = [
     "aiomysql>=0.3.2",
-    "aiosqlite>=0.20.0",
-    "asyncpg>=0.30.0",
-    "pytest>=9.0.1",
+    "aiosqlite>=0.22.1",
+    "asyncpg>=0.31.0",
+    "pytest>=9.0.2",
     "pytest-asyncio>=1.3.0",
-    "psutil>=7.1.3", # For memory monitoring in performance tests
+    "psutil>=7.2.2", # For memory monitoring in performance tests
 ]
 
 [build-system]
-requires = ["setuptools>=61.0", "wheel"]
+requires = ["setuptools>=82.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]

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

@@ -2,7 +2,7 @@ import re
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Union, cast
 
-from sqlalchemy import CheckConstraint, Index, UniqueConstraint
+from sqlalchemy import CheckConstraint, ForeignKeyConstraint, Index, UniqueConstraint
 from sqlalchemy import MetaData as SqlAlchemyMetaData
 
 from .fields import ColumnAttribute
@@ -24,8 +24,8 @@ __all__ = [
     "unique",
 ]
 
-
 _FIELD_NAME_PATTERN = re.compile(r"\b([a-zA-Z_][a-zA-Z0-9_]*)\b")
+_TEMP_INDEX_PREFIX = "__temp__idx_"
 
 
 @dataclass
@@ -574,7 +574,9 @@ class ModelProcessor(type):
 
     @classmethod
     def _normalize_all_indexes(mcs, indexes: list[Index], table_name: str) -> list[Index]:
-        """Force uniform naming format for all indexes.
+        """Normalize index names that need normalization.
+
+        Only normalizes indexes with temporary names (starting with __temp__idx_).
 
         Args:
             indexes: List of indexes to normalize
@@ -586,6 +588,11 @@ class ModelProcessor(type):
         normalized_indexes = []
 
         for idx in indexes:
+            # Only normalize temporary names
+            if not idx.name or not idx.name.startswith(_TEMP_INDEX_PREFIX):
+                normalized_indexes.append(idx)
+                continue
+
             # Get field name list
             if hasattr(idx, "columns") and idx.columns:
                 field_names = "_".join(col.name for col in idx.columns)  # noqa
@@ -597,10 +604,7 @@ class ModelProcessor(type):
                 continue
 
             # Generate standardized name
-            new_name = f"idx_{table_name}_{field_names}"
-
-            # Directly modify index name (instead of rebuilding)
-            idx.name = new_name  # type: ignore[reportAttributeAccessIssue]
+            idx.name = f"idx_{table_name}_{field_names}"  # type: ignore[reportAttributeAccessIssue]
             normalized_indexes.append(idx)
 
         return normalized_indexes
@@ -683,15 +687,20 @@ class ModelProcessor(type):
     def _post_process_table_indexes(mcs, table, table_name: str) -> None:
         """Normalize index names after table construction.
 
+        Only normalizes indexes with temporary names (starting with __temp__idx_).
+
         Args:
             table: SQLAlchemy Table instance
             table_name: Database table name
         """
         for idx in table.indexes:
+            # Only normalize temporary names
+            if not idx.name or not idx.name.startswith(_TEMP_INDEX_PREFIX):
+                continue
+
             if hasattr(idx, "columns") and idx.columns:
                 field_names = "_".join(col.name for col in idx.columns)
-                new_name = f"idx_{table_name}_{field_names}"
-                idx.name = new_name
+                idx.name = f"idx_{table_name}_{field_names}"
 
     @classmethod
     def _post_process_table_constraints(mcs, table, table_name: str) -> None:
@@ -714,6 +723,20 @@ class ModelProcessor(type):
                 elif isinstance(cst, UniqueConstraint) and hasattr(cst, "columns"):
                     field_names = "_".join(col.name for col in cst.columns)
                     cst.name = f"uq_{table_name}_{field_names}"
+                elif isinstance(cst, ForeignKeyConstraint) and hasattr(cst, "columns"):
+                    # Handle foreign key constraints
+                    field_names = "_".join(col.name for col in cst.columns)
+                    # Get referenced table and column names
+                    if cst.elements:
+                        try:
+                            ref_table = cst.elements[0].column.table.name
+                            ref_columns = "_".join(elem.column.name for elem in cst.elements)
+                            cst.name = f"fk_{table_name}_{field_names}_{ref_table}_{ref_columns}"
+                        except Exception:
+                            # Fallback if reference cannot be resolved yet
+                            cst.name = f"fk_{table_name}_{field_names}"
+                    else:
+                        cst.name = f"fk_{table_name}_{field_names}"
 
     @classmethod
     def _apply_dataclass_functionality(mcs, cls: Any) -> Any:
@@ -1114,11 +1137,9 @@ def index(
         >>> index("idx_users_status", "status", postgresql_where="status = 'active'")
         >>> index("idx_users_tags", "tags", postgresql_using="gin")
     """
-    # Note: Don't auto-generate name here because table_name is needed
-    # Actual name normalization is handled in _merge_indexes
     if name is None:
         field_part = "_".join(fields)
-        name = f"idx_{field_part}"  # Temporary name, will be replaced later
+        name = f"{_TEMP_INDEX_PREFIX}{field_part}"
 
     # Build dialect-specific kwargs
     dialect_kwargs = {}

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

@@ -3,7 +3,7 @@ from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from typing import Any
 
-from sqlalchemy import CursorResult
+from sqlalchemy import CursorResult, text
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncConnection, AsyncResult
 
@@ -13,7 +13,6 @@ from .exceptions import convert_sqlalchemy_error
 
 __all__ = ["AsyncSession", "ctx_session", "ctx_sessions", "get_session", "has_session"]
 
-
 # Explicit session management (highest priority)
 _explicit_sessions: contextvars.ContextVar[dict[str, "AsyncSession"]] = contextvars.ContextVar("explicit_sessions")
 
@@ -64,9 +63,17 @@ class AsyncSession:
         return get_database(self._db_name).engine
 
     async def execute(self, statement: Any, parameters: Any = None) -> CursorResult[Any]:
-        """Execute statement with automatic transaction management."""
+        """Execute statement with automatic transaction management.
+
+        Supports both SQLAlchemy statement objects and raw SQL strings.
+        Raw SQL strings are automatically wrapped with text().
+        """
         await self._ensure_connection()
 
+        # Auto-wrap string SQL with text()
+        if isinstance(statement, str):
+            statement = text(statement)
+
         # Auto-begin transaction for non-readonly sessions
         if not self.readonly and self._trans is None:
             self._trans = await self._conn.begin()  # type: ignore
@@ -89,6 +96,9 @@ class AsyncSession:
     async def stream(self, statement: Any, parameters: Any = None) -> AsyncResult[Any]:
         """Execute statement and return streaming result.
 
+        Supports both SQLAlchemy statement objects and raw SQL strings.
+        Raw SQL strings are automatically wrapped with text().
+
         Note: stream() is not supported with auto_commit=True sessions.
         Use explicit sessions (ctx_session) for streaming operations.
         """
@@ -99,6 +109,10 @@ class AsyncSession:
 
         await self._ensure_connection()
 
+        # Auto-wrap string SQL with text()
+        if isinstance(statement, str):
+            statement = text(statement)
+
         # Auto-begin transaction for non-readonly sessions
         if not self.readonly and self._trans is None:
             self._trans = await self._conn.begin()  # type: ignore

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.1.0
+Version: 1.2.0
 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>