iceaxe 0.7.0.dev1__cp312-cp312-macosx_11_0_arm64.whl → 0.7.0.dev2__cp312-cp312-macosx_11_0_arm64.whl

iceaxe/__tests__/schemas/test_db_memory_serializer.py

@@ -1,3 +1,4 @@
+import warnings
 from datetime import date, datetime, time, timedelta
 from enum import Enum, IntEnum, StrEnum
 from typing import Generic, Sequence, TypeVar
@@ -20,6 +21,7 @@ from iceaxe.schemas.actions import (
     DryRunComment,
 )
 from iceaxe.schemas.db_memory_serializer import (
+    CompositePrimaryKeyConstraintError,
     DatabaseHandler,
     DatabaseMemorySerializer,
 )
@@ -1462,3 +1464,62 @@ def test_foreign_key_actions():
     assert fk_constraint.foreign_key_constraint.target_columns == frozenset({"id"})
     assert fk_constraint.foreign_key_constraint.on_delete == "CASCADE"
     assert fk_constraint.foreign_key_constraint.on_update == "CASCADE"
+
+
+def test_multiple_primary_keys_foreign_key_error():
+    """
+    Test that when a model has multiple primary keys and foreign key constraints,
+    we get a helpful error message explaining the issue.
+    """
+
+    class User(TableBase):
+        id: int = Field(primary_key=True)
+        tenant_id: int = Field(primary_key=True)  # Composite primary key
+        name: str
+
+    class Topic(TableBase):
+        id: str = Field(primary_key=True)
+        tenant_id: int = Field(primary_key=True)  # Composite primary key
+        title: str
+
+    class Rec(TableBase):
+        id: int = Field(primary_key=True, default=None)
+        creator_id: int = Field(
+            foreign_key="user.id"
+        )  # This will fail because user is leveraging our synthetic primary key
+        topic_id: str = Field(
+            foreign_key="topic.id"
+        )  # This will fail because topic is leveraging our synthetic primary key
+
+    migrator = DatabaseMemorySerializer()
+
+    with pytest.raises(CompositePrimaryKeyConstraintError) as exc_info:
+        db_objects = list(migrator.delegate([User, Topic, Rec]))
+        migrator.order_db_objects(db_objects)
+
+    # Check that the exception has the expected attributes
+    assert exc_info.value.missing_constraints == [("user", "id")]
+
+
+def test_multiple_primary_keys_warning():
+    """
+    Test that when a model has multiple primary keys, we get a warning.
+    """
+
+    class ExampleModel(TableBase):
+        value_a: int = Field(primary_key=True)
+        value_b: int = Field(primary_key=True)
+
+    migrator = DatabaseMemorySerializer()
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        list(migrator.delegate([ExampleModel]))
+
+        # Check that a warning was issued
+        assert len(w) == 1
+        assert issubclass(w[0].category, UserWarning)
+        warning_message = str(w[0].message)
+        assert "multiple fields marked as primary_key=True" in warning_message
+        assert "composite primary key constraint" in warning_message
+        assert "Consider using only one primary key field" in warning_message

iceaxe/__tests__/schemas/test_db_stubs.py

@@ -1,4 +1,168 @@
-from iceaxe.schemas.db_stubs import DBType
+import pytest
+
+from iceaxe.schemas.db_stubs import ConstraintPointerInfo, DBObjectPointer, DBType
+
+
+class MockDBObjectPointer(DBObjectPointer):
+    """Mock implementation of DBObjectPointer for testing parser methods."""
+
+    representation_str: str
+
+    def representation(self) -> str:
+        return self.representation_str
+
+
+@pytest.mark.parametrize(
+    "representation_str,expected_result",
+    [
+        # Valid constraint pointer formats
+        (
+            "users.['id'].PRIMARY KEY",
+            ConstraintPointerInfo("users", ["id"], "PRIMARY KEY"),
+        ),
+        (
+            "orders.['user_id', 'product_id'].UNIQUE",
+            ConstraintPointerInfo("orders", ["user_id", "product_id"], "UNIQUE"),
+        ),
+        (
+            "products.['name'].INDEX",
+            ConstraintPointerInfo("products", ["name"], "INDEX"),
+        ),
+        (
+            "table_name.['col1', 'col2', 'col3'].FOREIGN KEY",
+            ConstraintPointerInfo(
+                "table_name", ["col1", "col2", "col3"], "FOREIGN KEY"
+            ),
+        ),
+        # Single quotes
+        ("users.['email'].UNIQUE", ConstraintPointerInfo("users", ["email"], "UNIQUE")),
+        # Double quotes
+        ('users.["email"].UNIQUE', ConstraintPointerInfo("users", ["email"], "UNIQUE")),
+        # Mixed quotes
+        (
+            "users.[\"col1\", 'col2'].UNIQUE",
+            ConstraintPointerInfo("users", ["col1", "col2"], "UNIQUE"),
+        ),
+        # Extra whitespace
+        (
+            "users.[ 'col1' , 'col2' ].UNIQUE",
+            ConstraintPointerInfo("users", ["col1", "col2"], "UNIQUE"),
+        ),
+        # Empty column list
+        ("users.[].CHECK", ConstraintPointerInfo("users", [], "CHECK")),
+        # Schema-qualified table names (dots in table names are valid when representing schema.table)
+        (
+            "public.users.['column'].PRIMARY KEY",
+            ConstraintPointerInfo("public.users", ["column"], "PRIMARY KEY"),
+        ),
+        # Complex constraint types
+        (
+            "users.['id'].PRIMARY KEY AUTOINCREMENT",
+            ConstraintPointerInfo("users", ["id"], "PRIMARY KEY AUTOINCREMENT"),
+        ),
+        # Table names with underscores and numbers (valid PostgreSQL identifiers)
+        (
+            "user_table_2.['id'].PRIMARY KEY",
+            ConstraintPointerInfo("user_table_2", ["id"], "PRIMARY KEY"),
+        ),
+        # Column names with underscores and numbers
+        (
+            "users.['user_id_2', 'created_at'].UNIQUE",
+            ConstraintPointerInfo("users", ["user_id_2", "created_at"], "UNIQUE"),
+        ),
+        # Invalid formats that should return None
+        ("users.column.UNIQUE", None),  # Missing brackets
+        ("users.['column']", None),  # Missing constraint type
+        ("['column'].UNIQUE", None),  # Missing table name
+        ("users", None),  # Just table name
+        ("", None),  # Empty string
+        ("users.column", None),  # Simple table.column format
+        ("invalid_format", None),  # Random string
+        # Malformed bracket syntax
+        ("users.[column].UNIQUE", None),  # Missing quotes in brackets
+        ("users.['column.UNIQUE", None),  # Unclosed bracket
+        ("users.column'].UNIQUE", None),  # Missing opening bracket
+    ],
+)
+def test_parse_constraint_pointer(
+    representation_str: str, expected_result: ConstraintPointerInfo | None
+):
+    """Test parsing of constraint pointer representations."""
+    pointer = MockDBObjectPointer(representation_str=representation_str)
+    result = pointer.parse_constraint_pointer()
+
+    if expected_result is None:
+        assert result is None
+    else:
+        assert result is not None
+        assert result.table_name == expected_result.table_name
+        assert result.column_names == expected_result.column_names
+        assert result.constraint_type == expected_result.constraint_type
+
+
+@pytest.mark.parametrize(
+    "representation_str,expected_table_name",
+    [
+        # Constraint pointer formats
+        ("users.['id'].PRIMARY KEY", "users"),
+        ("orders.['user_id', 'product_id'].UNIQUE", "orders"),
+        ("public.users.['column'].INDEX", "public.users"),
+        # Simple table.column formats
+        ("users.email", "users"),
+        ("products.name", "products"),
+        ("public.users.column", "public.users"),  # Schema.table.column format
+        # Edge cases
+        ("table_only", "table_only"),
+        ("", None),  # Empty string should return None
+        ("users.['id'].PRIMARY KEY", "users"),  # Constraint format takes precedence
+        # Complex table names with underscores and numbers
+        ("user_table_123.column", "user_table_123"),
+        ("schema_1.table_2.column", "schema_1.table_2"),
+        # Multiple dots in representation (should extract the table part correctly)
+        ("very.long.schema.table.['col'].UNIQUE", "very.long.schema.table"),
+    ],
+)
+def test_get_table_name(representation_str: str, expected_table_name: str | None):
+    """Test extraction of table names from pointer representations."""
+    pointer = MockDBObjectPointer(representation_str=representation_str)
+    result = pointer.get_table_name()
+    assert result == expected_table_name
+
+
+@pytest.mark.parametrize(
+    "representation_str,expected_column_names",
+    [
+        # Constraint pointer formats
+        ("users.['id'].PRIMARY KEY", ["id"]),
+        ("orders.['user_id', 'product_id'].UNIQUE", ["user_id", "product_id"]),
+        ("products.['name', 'category', 'price'].INDEX", ["name", "category", "price"]),
+        ("users.[].CHECK", []),  # Empty column list
+        # Simple table.column formats
+        ("users.email", ["email"]),
+        ("products.name", ["name"]),
+        ("public.users.column", ["column"]),  # Schema.table.column format
+        # Edge cases
+        ("table_only", []),  # No columns
+        ("", []),  # Empty string
+        # Whitespace handling
+        ("users.[ 'col1' , 'col2' ].UNIQUE", ["col1", "col2"]),
+        # Quote handling
+        ("users.[\"col1\", 'col2'].UNIQUE", ["col1", "col2"]),
+        # Column names with underscores and numbers
+        (
+            "users.['user_id_2', 'created_at_timestamp'].UNIQUE",
+            ["user_id_2", "created_at_timestamp"],
+        ),
+        # Complex schema.table.column cases
+        ("schema.table.column_name", ["column_name"]),
+        ("very.long.schema.table.column", ["column"]),
+    ],
+)
+def test_get_column_names(representation_str: str, expected_column_names: list[str]):
+    """Test extraction of column names from pointer representations."""
+    pointer = MockDBObjectPointer(representation_str=representation_str)
+    result = pointer.get_column_names()
+    assert result == expected_column_names
 
 
 def test_merge_type_columns():

iceaxe/base.py

@@ -273,7 +273,7 @@ class TableBase(BaseModel, metaclass=DBModelMetaclass):
         :param name: Attribute name
         :param value: New value
         """
-        if name in self.model_fields:
+        if name in self.__class__.model_fields:
             self.modified_attrs[name] = value
             for callback in self.modified_attrs_callbacks:
                 callback(self)

iceaxe/schemas/actions.py

@@ -299,7 +299,7 @@ class DatabaseActions:
                         - Scalar to array types (INTEGER → INTEGER[])
                         - Custom enum conversions (VARCHAR/TEXT → custom enum)
                         - Compatible numeric conversions (INTEGER → BIGINT)
-                        
+
                         When autocast=False, PostgreSQL will only allow the type change if it's
                         compatible without explicit casting, which may fail for many conversions.
 
@@ -308,7 +308,7 @@ class DatabaseActions:
             await actor.modify_column_type(
                 "products", "price", ColumnType.INTEGER, autocast=True
             )
-            
+
             # Manual migration with custom control
             await actor.modify_column_type(
                 "products", "price", ColumnType.INTEGER, autocast=False

iceaxe/schemas/db_memory_serializer.py

@@ -1,3 +1,4 @@
+import warnings
 from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
 from inspect import isgenerator
@@ -54,6 +55,47 @@ from iceaxe.typing import (
 NodeYieldType = Union[DBObject, DBObjectPointer, "NodeDefinition"]
 
 
+class CompositePrimaryKeyConstraintError(ValueError):
+    """
+    Raised when foreign key constraints cannot be resolved due to composite primary keys.
+
+    This occurs when a table has multiple fields marked as primary_key=True, creating
+    a composite primary key constraint, but foreign key constraints expect individual
+    primary key constraints on the target columns.
+
+    """
+
+    def __init__(self, missing_constraints: list[tuple[str, str]], base_message: str):
+        self.missing_constraints = missing_constraints
+        self.base_message = base_message
+
+        # Construct the detailed error message
+        error_msg = base_message
+
+        if missing_constraints:
+            error_msg += "\n\nThis error commonly occurs when you have multiple fields marked as primary_key=True in your model."
+            error_msg += "\nIceaxe creates a single composite primary key constraint, but foreign key constraints"
+            error_msg += (
+                "\nexpect individual primary key constraints on the target columns."
+            )
+            error_msg += "\n\nFor a detailed explanation of why this happens and how to fix it, see:"
+            error_msg += "\nhttps://mountaineer.sh/iceaxe/guides/relationships#composite-primary-keys-and-foreign-key-constraints"
+            error_msg += "\n\nTo fix this issue, choose one of these approaches:"
+            error_msg += "\n\nRecommended: Modify the current table"
+            error_msg += (
+                "\n   - Keep only one field as primary_key=True (e.g., just 'id')"
+            )
+            error_msg += "\n   - Add a UniqueConstraint if you need uniqueness across multiple fields"
+            error_msg += "\n   - This is usually the better design pattern"
+
+            # Show specific table/column combinations that are missing
+            error_msg += "\n\nCurrently missing individual primary key constraints:"
+            for table_name, column_name in missing_constraints:
+                error_msg += f"\n  - Table '{table_name}' needs a primary key on column '{column_name}'"
+
+        super().__init__(error_msg)
+
+
 @dataclass
 class NodeDefinition:
     node: DBObject
@@ -125,9 +167,37 @@ class DatabaseMemorySerializer:
                             pointer.representation() in db_objects_by_name
                             for pointer in dep.pointers
                         ):
-                            raise ValueError(
-                                f"None of the OR pointers {[p.representation() for p in dep.pointers]} found in the defined database objects"
-                            )
+                            # Create a more helpful error message for common cases
+                            missing_pointers = [
+                                p.representation() for p in dep.pointers
+                            ]
+                            error_msg = f"None of the OR pointers {missing_pointers} found in the defined database objects"
+
+                            # Check if this is the common case of multiple primary keys causing foreign key issues
+                            primary_key_pointers = []
+                            for p in dep.pointers:
+                                parsed = p.parse_constraint_pointer()
+                                if parsed and parsed.constraint_type == "PRIMARY KEY":
+                                    primary_key_pointers.append(p)
+
+                            if primary_key_pointers:
+                                # Extract table and column info from the primary key pointers
+                                primary_key_info: list[tuple[str, str]] = []
+                                for pointer in primary_key_pointers:
+                                    table_name = pointer.get_table_name()
+                                    column_names = pointer.get_column_names()
+
+                                    if table_name and column_names:
+                                        for column_name in column_names:
+                                            primary_key_info.append(
+                                                (table_name, column_name)
+                                            )
+
+                                if primary_key_info:
+                                    raise CompositePrimaryKeyConstraintError(
+                                        primary_key_info, error_msg
+                                    )
+                            raise ValueError(error_msg)
                     elif dep.representation() not in db_objects_by_name:
                         raise ValueError(
                             f"Pointer {dep.representation()} not found in the defined database objects"
@@ -544,6 +614,18 @@ class DatabaseHandler:
         if not keys:
             return
 
+        # Warn users about potential issues with multiple primary keys
+        if len(keys) > 1:
+            column_names = [key for key, _ in keys]
+            warnings.warn(
+                f"Table '{table.get_table_name()}' has multiple fields marked as primary_key=True: {column_names}. "
+                f"This creates a composite primary key constraint, which may cause issues with foreign key "
+                f"constraints that expect individual primary keys on target columns. "
+                f"Consider using only one primary key field and adding UniqueConstraint for uniqueness instead.",
+                UserWarning,
+                stacklevel=3,
+            )
+
         columns = [key for key, _ in keys]
         yield from self._yield_nodes(
             DBConstraint(

iceaxe/schemas/db_stubs.py

@@ -1,4 +1,6 @@
+import re
 from abc import abstractmethod
+from dataclasses import dataclass
 from typing import Self, Union
 
 from pydantic import BaseModel, Field, model_validator
@@ -12,6 +14,15 @@ from iceaxe.schemas.actions import (
 )
 
 
+@dataclass
+class ConstraintPointerInfo:
+    """Information parsed from a constraint pointer representation."""
+
+    table_name: str
+    column_names: list[str]
+    constraint_type: str
+
+
 class DBObject(BaseModel):
     """
     A subclass for all models that are intended to store
@@ -86,6 +97,108 @@ class DBObjectPointer(BaseModel):
     def representation(self) -> str:
         pass
 
+    def parse_constraint_pointer(self) -> ConstraintPointerInfo | None:
+        """
+        Parse a constraint pointer representation into its components.
+
+        Returns:
+            ConstraintPointerInfo | None: Parsed constraint information or None if not a constraint pointer
+
+        Examples:
+            "table.['column'].PRIMARY KEY" -> ConstraintPointerInfo("table", ["column"], "PRIMARY KEY")
+            "table.['col1', 'col2'].UNIQUE" -> ConstraintPointerInfo("table", ["col1", "col2"], "UNIQUE")
+        """
+        representation = self.representation()
+
+        # Pattern to match: table_name.[column_list].constraint_type
+        # where column_list can be ['col'] or ['col1', 'col2', ...]
+        # The table_name can contain dots (for schema.table), so we need to be more careful
+        # We look for the pattern .[...]. to identify where the column list starts
+        pattern = r"^(.+)\.(\[.*?\])\.(.+)$"
+        match = re.match(pattern, representation)
+
+        if not match:
+            return None
+
+        table_name, columns_part, constraint_type = match.groups()
+
+        # Validate that the column list contains properly quoted column names or is empty
+        # Remove brackets and check the content
+        columns_str = columns_part.strip("[]")
+        if not columns_str:
+            # Empty column list is valid
+            return ConstraintPointerInfo(table_name, [], constraint_type)
+
+        # Split by comma and validate each column name is properly quoted
+        columns = []
+        for col in columns_str.split(","):
+            col = col.strip()
+            # Check if the column is properly quoted (single or double quotes)
+            if (col.startswith("'") and col.endswith("'")) or (
+                col.startswith('"') and col.endswith('"')
+            ):
+                # Remove quotes and add to list
+                col_name = col[1:-1]
+                if col_name:  # Don't add empty column names
+                    columns.append(col_name)
+            else:
+                # Column is not properly quoted, this is not a valid constraint pointer
+                return None
+
+        return ConstraintPointerInfo(table_name, columns, constraint_type)
+
+    def get_table_name(self) -> str | None:
+        """
+        Extract the table name from the pointer representation.
+
+        Returns:
+            str | None: The table name if it can be parsed, None otherwise
+        """
+        # Try constraint pointer format first
+        parsed = self.parse_constraint_pointer()
+        if parsed is not None:
+            return parsed.table_name
+
+        # Try simple table.column format
+        representation = self.representation()
+        if not representation:
+            return None
+
+        parts = representation.split(".")
+        if len(parts) >= 2:
+            # For schema.table.column format, take all parts except the last one
+            return ".".join(parts[:-1])
+        elif len(parts) == 1:
+            # Just a table name
+            return parts[0]
+        else:
+            return None
+
+    def get_column_names(self) -> list[str]:
+        """
+        Extract column names from the pointer representation.
+
+        Returns:
+            list[str]: List of column names if they can be parsed, empty list otherwise
+        """
+        # Try constraint pointer format first
+        parsed = self.parse_constraint_pointer()
+        if parsed is not None:
+            return parsed.column_names
+
+        # Try simple table.column format
+        representation = self.representation()
+        if not representation:
+            return []
+
+        parts = representation.split(".")
+        if len(parts) >= 2:
+            # For schema.table.column format, take the last part as the column name
+            return [parts[-1]]
+        else:
+            # Just a table name, no columns
+            return []
+
 
 class DBTable(DBObject):
     table_name: str

iceaxe/session.py

@@ -593,7 +593,7 @@ class DBConnection:
                     modified_attrs = frozenset(
                         k
                         for k, v in obj.get_modified_attributes().items()
-                        if not obj.model_fields[k].exclude
+                        if not obj.__class__.model_fields[k].exclude
                     )
                     if modified_attrs:
                         updates_by_fields[modified_attrs].append(obj)

{iceaxe-0.7.0.dev1.dist-info → iceaxe-0.7.0.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iceaxe
-Version: 0.7.0.dev1
+Version: 0.7.0.dev2
 Summary: A modern, fast ORM for Python.
 Author-email: Pierce Freeman <pierce@freeman.vc>
 Requires-Python: >=3.11
@@ -15,8 +15,7 @@ Dynamic: license-file
 
 ![Iceaxe Logo](https://raw.githubusercontent.com/piercefreeman/iceaxe/main/media/header.png)
 
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/iceaxe)
-[![Test status](https://github.com/piercefreeman/iceaxe/actions/workflows/test.yml/badge.svg)](https://github.com/piercefreeman/iceaxe/actions)
+![Python Version](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fpiercefreeman%2Ficeaxe%2Frefs%2Fheads%2Fmain%2Fpyproject.toml) [![Test status](https://github.com/piercefreeman/iceaxe/actions/workflows/test.yml/badge.svg)](https://github.com/piercefreeman/iceaxe/actions)
 
 A modern, fast ORM for Python. We have the following goals:
 

{iceaxe-0.7.0.dev1.dist-info → iceaxe-0.7.0.dev2.dist-info}/RECORD

@@ -5,7 +5,7 @@ iceaxe/sql_types.py,sha256=fEdDPeb7QctFfdWEn1rLqY1b2EccM61UEAaqXdyz3jo,2607
 iceaxe/alias_values.py,sha256=gvtaYJLdMkSUBS99GlFGDMul4jlOs_lxnmgRae7OrKI,1978
 iceaxe/session_optimized.pyx,sha256=5sPvWKuEZKzwaOFLE4knU8kRVWt0JCVTugfQCTpRPmo,8375
 iceaxe/io.py,sha256=af-ZJKiP0yOtLCe2dG0jMOBffbAvZ1BMSHG6lVjQ1Bc,3889
-iceaxe/session.py,sha256=clEyfi-Wa0GIzZgXdKbwwzEeTzGvDRKTiQ4-oFFCj0g,32606
+iceaxe/session.py,sha256=0EFbCHA2XBiMS7IT6Cb0-HLE0Q-t2nsWXbe9DdvKyQQ,32616
 iceaxe/__init__.py,sha256=zIq6C5rZY3ERBeOfZBIInM78RvR35ub5oKVw_jj1VO0,614
 iceaxe/modifications.py,sha256=xTs3pdOpeVm_lwKL0DkHVm9a3Kn-HIJtUTTNEwpcUrs,6588
 iceaxe/comparison.py,sha256=fpXZHQrVirTiSox6vpYvTnWJjGJyuZGoEu-98YmuK2g,17005
@@ -16,7 +16,7 @@ iceaxe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iceaxe/queries.py,sha256=ZPiJYG_hyRWSUjaC7-gfscr2h4GbGaNT67uyjaScr4A,44461
 iceaxe/typing.py,sha256=s1rCCE2Pcs5Fxt1zY76UppTc9LiXyydzksTm_k2BUmw,1917
 iceaxe/generics.py,sha256=TGI4EIshzwwRoVi1eoux0Dn64xcWvbErSyxd_wK-iHc,4891
-iceaxe/base.py,sha256=_nmpyyoSU1qQb62vZIkws_Pum0XvEfsocIVO8_-NnHA,11377
+iceaxe/base.py,sha256=o2c3RIqUnoK1SKB7mkEetcKKdPMtTHBvOawGYCm8usM,11387
 iceaxe/session_optimized.cpython-312-darwin.so,sha256=pm_UfdLXczkxclLYL1B5ATTNOaGBbLe0Xxa6UfQ76Xg,171320
 iceaxe/mountaineer/config.py,sha256=sdzNbrXkLPw1W3RUE2Gsq1m076lvjhw9wGxX1AHEWbw,1404
 iceaxe/mountaineer/__init__.py,sha256=psc2Tj25KHoqmL9kCatZ31Y96ilamERI2Rn0dqQX0zM,298
@@ -30,12 +30,12 @@ iceaxe/migrations/cli.py,sha256=FzejSzE1n5FOkhtyGXLuRKWOTR4DlP6xTPxdqqzTCC0,8802
 iceaxe/migrations/client_io.py,sha256=f-yJJaaB4yfNlyHk2ou9eKrWIiSzB11rIoSlhDXwQLo,2314
 iceaxe/migrations/migrator.py,sha256=Z1-baX2qAvFaAVYC2oFv0VkFHO6XZRYYqKz9wRke8yo,3038
 iceaxe/migrations/migration.py,sha256=HYtFx_AlmUQF1RJFulAFKaM2XLS1NmynufvjUbTJBec,2370
-iceaxe/schemas/actions.py,sha256=PfEjfSAUiiNf4LjGHSLoLJxFT5IDYtPwqTNxJKOcaIE,30082
+iceaxe/schemas/actions.py,sha256=70aHXmWkJx2E4emH1na5OET-m8rPIdEvCUkL1mvB3Ps,30046
 iceaxe/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iceaxe/schemas/db_serializer.py,sha256=SpMxo_f66R3rKl7uEiRIwS5ZoBCe9ETIz4R__KBT5fA,13070
 iceaxe/schemas/cli.py,sha256=G-ySDV1sIvqDLln23Xc6eKlEQw5-ZydVAzFPgGQGeo4,1019
-iceaxe/schemas/db_stubs.py,sha256=cOzRmFVBl70DVO9IQ7iL2d-mefkXjy1c0lNDCtiKcAA,13746
-iceaxe/schemas/db_memory_serializer.py,sha256=FvBvxgJB3diWafsd5832Tmm7CekJK9AEAQa06vn_TDc,24623
+iceaxe/schemas/db_stubs.py,sha256=B2JdnrChqKUMZwNPAtzVkC2bHQfoN_bFczL-mZZy4_A,17849
+iceaxe/schemas/db_memory_serializer.py,sha256=44jf2eI2YMuQpS3XB1UxIl43u1pv8EOZXbjZ1M-O5GY,29079
 iceaxe/__tests__/conftest.py,sha256=S_leF61hosjmXjYnvammgKckdl8w70LiwHJQzU7i2Us,4010
 iceaxe/__tests__/test_session.py,sha256=ZuUe7B_H-aW4Ym3Wx7WhBDhcyIlE7jMcpeD1jOkYyJs,49199
 iceaxe/__tests__/test_modifications.py,sha256=beljqGGTc-Mg4sogyvUSNCOYp57AjNRi41e-vdMqMOM,5061
@@ -59,16 +59,16 @@ iceaxe/__tests__/migrations/test_generator.py,sha256=Z9GlZCCWwbysUO-y3S6R76PodY_
 iceaxe/__tests__/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iceaxe/__tests__/migrations/test_generics.py,sha256=JuaniWOsfQasGF-pPx7pyyXEuNO9sfFtQaIfGntqNCQ,2654
 iceaxe/__tests__/schemas/test_actions.py,sha256=-lM3Kz1R0_hJsQNd3A0NGe83cFPuSpcgMS5Z9yIRGmU,38340
-iceaxe/__tests__/schemas/test_db_memory_serializer.py,sha256=jU1FWH3DUL_hnTo_yOgVzVi9N_xuMPsMYov6jY88aCg,44940
+iceaxe/__tests__/schemas/test_db_memory_serializer.py,sha256=6zAIuY-K4XKzLSHaCUq_UE3sa3h66hPzl3BPlF-nMVE,47103
 iceaxe/__tests__/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iceaxe/__tests__/schemas/test_db_stubs.py,sha256=-8Pkcy8QUSJFl0nZdg_uuyJTRPeZWdWAdrlLwt4nFxE,787
+iceaxe/__tests__/schemas/test_db_stubs.py,sha256=Bh_bPeKvz9bQGM6-03iqs2PXS2Ik_klzO508fHzm-wE,7456
 iceaxe/__tests__/schemas/test_db_serializer.py,sha256=InW5x51f73Zgdw8KDK6G0hUbi64FYzVbu8TmFa0VH8g,10752
 iceaxe/__tests__/schemas/test_cli.py,sha256=mQe0GKGPwwJ3foJCEDy4N-uERfjI_eU1QLDk0AaT588,738
 iceaxe/__tests__/benchmarks/test_bulk_insert.py,sha256=XsMsmGD0y4BQGXKvciPZ_cW1WzYjqW7rKyo2XfgfDjA,1284
 iceaxe/__tests__/benchmarks/test_select.py,sha256=ZyIDvuJA0j4g3kMnoF4eaxO4D-f0BAxznpZMfkETQU0,3984
 iceaxe/__tests__/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iceaxe-0.7.0.dev1.dist-info/RECORD,,
-iceaxe-0.7.0.dev1.dist-info/WHEEL,sha256=CltXN3lQvXbHxKDtiDwW0RNzF8s2WyBuPbOAX_ZeQlA,109
-iceaxe-0.7.0.dev1.dist-info/top_level.txt,sha256=pTQaTX1areyLx9BHkSfYqSEU0r6dHJMxjxMme0CK9xw,7
-iceaxe-0.7.0.dev1.dist-info/METADATA,sha256=bpHO4E7z0tGeeKD5WQGP7guvtGYRrQKAquCeowEFncI,9032
-iceaxe-0.7.0.dev1.dist-info/licenses/LICENSE,sha256=DgU6htH6BJg7h_6609WHBMKEUN_Y04BDN_vTTrmp5Pg,1071
+iceaxe-0.7.0.dev2.dist-info/RECORD,,
+iceaxe-0.7.0.dev2.dist-info/WHEEL,sha256=CltXN3lQvXbHxKDtiDwW0RNzF8s2WyBuPbOAX_ZeQlA,109
+iceaxe-0.7.0.dev2.dist-info/top_level.txt,sha256=pTQaTX1areyLx9BHkSfYqSEU0r6dHJMxjxMme0CK9xw,7
+iceaxe-0.7.0.dev2.dist-info/METADATA,sha256=IFs9P6ZHyIdws_g7gHNs28I3DH1d2OrGAfCeqId20KQ,9148
+iceaxe-0.7.0.dev2.dist-info/licenses/LICENSE,sha256=DgU6htH6BJg7h_6609WHBMKEUN_Y04BDN_vTTrmp5Pg,1071