sqlobjects 1.0.2__tar.gz → 1.0.4__tar.gz

{sqlobjects-1.0.2/sqlobjects.egg-info → sqlobjects-1.0.4}/PKG-INFO

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

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

{sqlobjects-1.0.2 → sqlobjects-1.0.4}/sqlobjects/mixins.py

@@ -392,19 +392,7 @@ class DataConversionMixin(DeferredLoadingMixin):
         all_fields = set(cls._get_field_names())
         filtered_data = {k: v for k, v in data.items() if k in all_fields}
 
-        table = cls.get_table()
-        for col in table.columns:  # noqa
-            if col.name not in filtered_data:
-                field_attr = getattr(cls, col.name, None)
-                if field_attr is not None and hasattr(field_attr, "get_default_factory"):
-                    factory = field_attr.get_default_factory()
-                    if factory and callable(factory):
-                        filtered_data[col.name] = factory()
-                        continue
-
-                if col.default is not None:
-                    if hasattr(col.default, "is_scalar") and col.default.is_scalar:
-                        filtered_data[col.name] = getattr(col.default, "arg", None)
+        # Default values will be handled by __init__ method
 
         init_data = {}
         non_init_data = {}
@@ -427,6 +415,11 @@ class DataConversionMixin(DeferredLoadingMixin):
         instance = cls(**init_data)  # noqa
 
         for field_name, value in non_init_data.items():
+            # Apply default value if value is None
+            if value is None:
+                default_value = instance._get_field_default_value(field_name)  # noqa
+                if default_value is not None:
+                    value = default_value
             setattr(instance, field_name, value)
 
         # Clear dirty fields since this is initial creation from dict
@@ -439,6 +432,46 @@ class DataConversionMixin(DeferredLoadingMixin):
 
         return instance
 
+    def _apply_default_values(self, kwargs: dict):
+        """Apply default values for fields not provided in kwargs.
+
+        Args:
+            kwargs: Dictionary of provided field values (will be modified)
+        """
+        for field_name in self._get_field_names():
+            if field_name not in kwargs or kwargs[field_name] is None:
+                default_value = self._get_field_default_value(field_name)
+                if default_value is not None:
+                    kwargs[field_name] = default_value
+
+    def _get_field_default_value(self, field_name: str):
+        """Get default value for a field.
+
+        Args:
+            field_name: Name of the field
+
+        Returns:
+            Default value or None if no default
+        """
+        field_attr = getattr(self.__class__, field_name, None)
+        if field_attr is None:
+            return None
+
+        # Priority: default_factory > SQLAlchemy default
+        if hasattr(field_attr, "get_default_factory"):
+            factory = field_attr.get_default_factory()
+            if factory and callable(factory):
+                return factory()
+
+        if hasattr(field_attr, "default") and field_attr.default is not None:
+            default_value = field_attr.default
+            if callable(default_value):
+                return default_value()
+            else:
+                return default_value
+
+        return None
+
 
 class FieldCacheMixin(DataConversionMixin):
     """Field caching and attribute access optimization - Layer 6."""
@@ -599,6 +632,13 @@ class FieldCacheMixin(DataConversionMixin):
 
         relationship_fields = field_cache.get("relationship_fields", set())
         if isinstance(relationship_fields, set) and name in relationship_fields:
+            # Check cascade_relationships first (manually assigned values)
+            if hasattr(self, "_state_manager"):
+                cascade_relationships: dict = self._state_manager.get("cascade_relationships", {})  # type: ignore[reportAssignmentType]
+                if name in cascade_relationships:
+                    return cascade_relationships[name]
+
+            # Check preloaded cache
             cache_name = f"_{name}_cache"
             try:
                 if hasattr(self, cache_name):
@@ -608,6 +648,7 @@ class FieldCacheMixin(DataConversionMixin):
             except AttributeError:
                 pass
 
+            # Only create proxy if relationship is not loaded
             proxy_cache = self._state_manager.get("proxy_cache", {})
             if isinstance(proxy_cache, dict) and name not in proxy_cache:
                 proxy_cache[name] = RelationFieldProxy(self, name)

{sqlobjects-1.0.2 → sqlobjects-1.0.4}/sqlobjects/model.py

@@ -56,6 +56,9 @@ class ModelMixin(FieldCacheMixin, SignalMixin):
         if hasattr(self, "_history_initialized"):
             self._history_initialized = False
 
+        # Generate default values for fields not provided in kwargs
+        self._apply_default_values(kwargs)
+
         # Set field values
         for key, value in kwargs.items():
             setattr(self, key, value)
@@ -107,8 +110,36 @@ class ModelMixin(FieldCacheMixin, SignalMixin):
             if i < len(pk_values):
                 setattr(self, col.name, pk_values[i])
 
+    def _get_upsert_statement(self, table, data):
+        """Construct UPSERT statement based on database dialect."""
+        dialect = self.get_session().bind.dialect.name
+
+        pk_columns = list(table.primary_key.columns)
+
+        if dialect == "postgresql":
+            from sqlalchemy.dialects.postgresql import insert
+
+            stmt = insert(table).values(**data)
+            return stmt.on_conflict_do_update(index_elements=pk_columns, set_=data)
+
+        elif dialect == "mysql":
+            from sqlalchemy.dialects.mysql import insert
+
+            stmt = insert(table).values(**data)
+            return stmt.on_duplicate_key_update(**data)
+
+        elif dialect == "sqlite":
+            from sqlalchemy.dialects.sqlite import insert
+
+            stmt = insert(table).values(**data)
+            return stmt.on_conflict_do_update(index_elements=pk_columns, set_=data)
+
+        else:
+            # Return None for unsupported dialects to trigger fallback
+            return None
+
     async def _save_internal(self, validate: bool = True, session=None):
-        """Internal save operation without cascade or signal emission.
+        """Internal save operation using UPSERT with fallback to query-then-save.
 
         This method contains the core save logic that can be reused by both
         the public save() method and the cascade executor without triggering
@@ -132,17 +163,37 @@ class ModelMixin(FieldCacheMixin, SignalMixin):
         if validate:
             self.validate_all_fields()
 
+        data = self._get_all_data()
+
+        # Try UPSERT for supported databases
+        upsert_stmt = self._get_upsert_statement(table, data)
+        if upsert_stmt is not None:
+            try:
+                result = await session.execute(upsert_stmt)
+                if result.inserted_primary_key:
+                    self._set_primary_key_values(result.inserted_primary_key)
+                # Clear dirty fields after successful save
+                dirty_fields = self._state_manager.get("dirty_fields", set())
+                if isinstance(dirty_fields, set):
+                    dirty_fields.clear()
+                return self
+            except Exception as e:
+                raise PrimaryKeyError(f"Upsert operation failed: {e}") from e
+
+        # Fallback: query database to determine INSERT or UPDATE
         try:
-            if self._has_primary_key_values():
-                # UPDATE operation
-                pk_conditions = self._build_pk_conditions()
+            pk_conditions = self._build_pk_conditions()
+            existing = await session.execute(select(table).where(and_(*pk_conditions)))
+
+            if existing.first():
+                # Record exists, perform UPDATE
                 update_data = self._get_dirty_data()
                 if update_data:
                     stmt = update(table).where(and_(*pk_conditions)).values(**update_data)
                     await session.execute(stmt)
             else:
-                # INSERT operation
-                stmt = insert(table).values(**self._get_all_data())
+                # Record does not exist, perform INSERT
+                stmt = insert(table).values(**data)
                 result = await session.execute(stmt)
                 if result.inserted_primary_key:
                     self._set_primary_key_values(result.inserted_primary_key)
@@ -216,8 +267,8 @@ class ModelMixin(FieldCacheMixin, SignalMixin):
         for rel_name, new_related_objects in cascade_relationships.items():
             await self._process_relationship_update(rel_name, new_related_objects, session)
 
-        # Clear cascade state
-        self._state_manager.set("cascade_relationships", {})
+        # keep cascade_relationships
+        # self._state_manager.set("cascade_relationships", {})
         self._state_manager.set("needs_cascade_save", False)
 
     async def _process_relationship_update(self, rel_name: str, new_related_objects, session):
@@ -258,32 +309,30 @@ class ModelMixin(FieldCacheMixin, SignalMixin):
 
     async def _fetch_current_related_objects(self, rel_name: str, session) -> list:
         """Fetch current related objects from database."""
-        # Simple implementation for common patterns
-        relationship_mappings = {
-            "posts": ("CascadePost", "author_id"),
-            "profile": ("CascadeProfile", "user_id"),
-        }
+        relationships = getattr(self.__class__, "_relationships", {})
+        if rel_name not in relationships:
+            return []
 
-        if rel_name not in relationship_mappings:
+        rel_descriptor = relationships[rel_name]
+        if not hasattr(rel_descriptor.property, "resolved_model") or not rel_descriptor.property.resolved_model:
             return []
 
-        related_model_name, fk_field = relationship_mappings[rel_name]
+        related_model = rel_descriptor.property.resolved_model
+        foreign_keys = rel_descriptor.property.foreign_keys
 
-        # Import model class
-        if related_model_name == "CascadePost":
-            from tests.integration.test_cascade_integration import CascadePost as RelatedModel
-        elif related_model_name == "CascadeProfile":
-            from tests.integration.test_cascade_integration import CascadeProfile as RelatedModel
-        else:
+        if not foreign_keys:
             return []
 
-        # Query current objects
+        # fetch foreign keys
+        fk_field = foreign_keys if isinstance(foreign_keys, str) else foreign_keys[0]
+
+        # get pk
         pk_value = getattr(self, self._get_primary_key_field())
         if pk_value is None:
             return []
 
         current_objects = (
-            await RelatedModel.objects.using(session).filter(getattr(RelatedModel, fk_field) == pk_value).all()
+            await related_model.objects.using(session).filter(getattr(related_model, fk_field) == pk_value).all()
         )
 
         return current_objects
@@ -428,23 +477,18 @@ class ModelMixin(FieldCacheMixin, SignalMixin):
         from .cascade import OnDelete
 
         relationships = getattr(self.__class__, "_relationships", {})
-        print(f"DEBUG: _has_on_delete_relations checking {len(relationships)} relationships")
-        for rel_name, rel_descriptor in relationships.items():
-            print(f"DEBUG: Checking relationship {rel_name}")
+
+        for _, rel_descriptor in relationships.items():
             if hasattr(rel_descriptor, "property") and hasattr(rel_descriptor.property, "cascade"):
                 cascade_str = rel_descriptor.property.cascade
-                print(f"DEBUG: Cascade string: {cascade_str}")
                 if cascade_str and ("delete" in cascade_str or "all" in cascade_str):
-                    print(f"DEBUG: Found delete cascade relationship: {rel_name}")
                     return True
             if (
                 hasattr(rel_descriptor, "property")
                 and hasattr(rel_descriptor.property, "on_delete")
                 and rel_descriptor.property.on_delete != OnDelete.NO_ACTION
             ):
-                print(f"DEBUG: Found on_delete relationship: {rel_name}")
                 return True
-        print("DEBUG: No on_delete relations found")
         return False
 
     def _get_primary_key_field(self) -> str:

{sqlobjects-1.0.2 → sqlobjects-1.0.4}/sqlobjects/objects/bulk.py

@@ -323,19 +323,16 @@ class BulkOperationHandler:
         exec_session = session or self.session
 
         if return_columns and self.supports_returning(operation):
-            try:
-                stmt_with_returning = stmt.returning(*return_columns)
-                # For INSERT operations, use the data directly as parameters
-                if operation == "insert" and isinstance(parameters, list):
-                    result = await exec_session.execute(stmt_with_returning, parameters)
-                elif parameters:
-                    result = await exec_session.execute(stmt_with_returning, parameters)
-                else:
-                    result = await exec_session.execute(stmt_with_returning)
-                objects = self.create_objects_from_rows(result.fetchall(), return_fields)
-                return objects, result.rowcount or 0, True
-            except Exception:  # noqa
-                pass  # Fall through to regular execution
+            stmt_with_returning = stmt.returning(*return_columns)
+            # For INSERT operations, use the data directly as parameters
+            if operation == "insert" and isinstance(parameters, list):
+                result = await exec_session.execute(stmt_with_returning, parameters)
+            elif parameters:
+                result = await exec_session.execute(stmt_with_returning, parameters)
+            else:
+                result = await exec_session.execute(stmt_with_returning)
+            objects = self.create_objects_from_rows(result.fetchall(), return_fields)
+            return objects, result.rowcount or 0, True
 
         # Regular execution without RETURNING
         if parameters is not None and isinstance(parameters, list) and len(parameters) > 1:

{sqlobjects-1.0.2 → sqlobjects-1.0.4/sqlobjects.egg-info}/PKG-INFO

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