iceaxe 0.7.0.dev1__tar.gz → 0.7.0.dev3__tar.gz

{iceaxe-0.7.0.dev1/iceaxe.egg-info → iceaxe-0.7.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iceaxe
-Version: 0.7.0.dev1
+Version: 0.7.0.dev3
 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 → iceaxe-0.7.0.dev3}/README.md

@@ -2,8 +2,7 @@
 
 ![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 → iceaxe-0.7.0.dev3}/iceaxe/__tests__/schemas/test_actions.py

@@ -263,8 +263,8 @@ async def test_add_column_any_type(
         (ColumnType.SERIAL, ColumnType.INTEGER),
         (ColumnType.BIGSERIAL, ColumnType.BIGINT),
         (ColumnType.CHAR, "character"),
-        (ColumnType.TIME, "time without time zone"),
-        (ColumnType.TIMESTAMP, "timestamp without time zone"),
+        (ColumnType.TIME_WITHOUT_TIME_ZONE, "time without time zone"),
+        (ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE, "timestamp without time zone"),
     )
 
     allowed_values = {enum_value.value}
@@ -365,7 +365,7 @@ async def test_modify_column_type(
         (ColumnType.VARCHAR, ColumnType.DATE, "2023-01-01", "2023-01-01", True),
         (
             ColumnType.TEXT,
-            ColumnType.TIMESTAMP,
+            ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
             "2023-01-01 12:00:00",
             "2023-01-01 12:00:00",
             True,
@@ -443,7 +443,7 @@ async def test_modify_column_type_with_autocast(
     actual_value = row[column_name]
     if isinstance(expected_value, str) and to_type in [
         ColumnType.DATE,
-        ColumnType.TIMESTAMP,
+        ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
     ]:
         # For date/timestamp, convert to string for comparison
         actual_value = str(actual_value)
@@ -1158,7 +1158,7 @@ async def test_modify_column_type_date_to_timestamp(
     await db_backed_actions.modify_column_type(
         table_name,
         column_name,
-        explicit_data_type=ColumnType.TIMESTAMP,
+        explicit_data_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
         autocast=False,
     )
 

{iceaxe-0.7.0.dev1 → iceaxe-0.7.0.dev3}/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,
 )
@@ -748,7 +750,7 @@ def test_enum_column_assignment(clear_all_database_objects):
                     DBColumn(
                         table_name="exampledbmodel",
                         column_name="standard_datetime",
-                        column_type=ColumnType.TIMESTAMP,
+                        column_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
                         column_is_list=False,
                         nullable=False,
                     ),
@@ -808,7 +810,7 @@ def test_enum_column_assignment(clear_all_database_objects):
                     DBColumn(
                         table_name="exampledbmodel",
                         column_name="standard_time",
-                        column_type=ColumnType.TIME,
+                        column_type=ColumnType.TIME_WITHOUT_TIME_ZONE,
                         column_is_list=False,
                         nullable=False,
                     ),
@@ -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-0.7.0.dev1 → iceaxe-0.7.0.dev3}/iceaxe/__tests__/schemas/test_db_serializer.py

@@ -143,6 +143,52 @@ class ValueEnumInt(IntEnum):
                 )
             ],
         ),
+        # Test PostgreSQL's storage format for timestamp without timezone
+        (
+            """
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                created_at TIMESTAMP NOT NULL
+            );
+            """,
+            [
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="created_at",
+                        column_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
+                        column_is_list=False,
+                        nullable=False,
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                )
+            ],
+        ),
+        # Test PostgreSQL's storage format for timestamp with timezone
+        (
+            """
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                created_at TIMESTAMPTZ NOT NULL
+            );
+            """,
+            [
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="created_at",
+                        column_type=ColumnType.TIMESTAMP_WITH_TIME_ZONE,
+                        column_is_list=False,
+                        nullable=False,
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                )
+            ],
+        ),
     ],
 )
 async def test_simple_db_serializer(

iceaxe-0.7.0.dev3/iceaxe/__tests__/schemas/test_db_stubs.py

@@ -0,0 +1,190 @@
+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():
+    """
+    Allow separately yielded type definitions to collect their reference columns. If an
+    enum is referenced in one place, this should build up to the full definition.
+
+    """
+    type_a = DBType(
+        name="type_a",
+        values=frozenset({"A"}),
+        reference_columns=frozenset({("table_a", "column_a")}),
+    )
+    type_b = DBType(
+        name="type_a",
+        values=frozenset({"A"}),
+        reference_columns=frozenset({("table_b", "column_b")}),
+    )
+
+    merged = type_a.merge(type_b)
+    assert merged.name == "type_a"
+    assert merged.values == frozenset({"A"})
+    assert merged.reference_columns == frozenset(
+        {("table_a", "column_a"), ("table_b", "column_b")}
+    )

{iceaxe-0.7.0.dev1 → iceaxe-0.7.0.dev3}/iceaxe/__tests__/test_comparison.py

@@ -10,6 +10,7 @@ from iceaxe.base import TableBase
 from iceaxe.comparison import ComparisonType, FieldComparison
 from iceaxe.field import DBFieldClassDefinition, DBFieldInfo
 from iceaxe.queries_str import QueryLiteral
+from iceaxe.sql_types import ColumnType
 from iceaxe.typing import column
 
 
@@ -354,3 +355,29 @@ def test_force_join_constraints(
     )
     forced = comparison.force_join_constraints()
     assert forced.comparison == expected_comparison
+
+
+@pytest.mark.parametrize(
+    "sql_type_string, expected_column_type",
+    [
+        ("timestamp", ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE),  # Tests aliasing
+        ("timestamp without time zone", ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE),
+        ("timestamp with time zone", ColumnType.TIMESTAMP_WITH_TIME_ZONE),
+        ("time", ColumnType.TIME_WITHOUT_TIME_ZONE),  # Tests aliasing
+        ("time without time zone", ColumnType.TIME_WITHOUT_TIME_ZONE),
+        ("time with time zone", ColumnType.TIME_WITH_TIME_ZONE),
+    ],
+)
+def test_postgres_datetime_timezone_casting(
+    sql_type_string: str, expected_column_type: ColumnType
+):
+    """
+    Test that PostgresDateTime fields with different timezone configurations
+    are properly handled by the ColumnType enum, specifically testing that
+    PostgreSQL's storage format ('timestamp without time zone') can be parsed.
+    This also tests that SQL standard aliases like "timestamp" correctly map
+    to "timestamp without time zone".
+    """
+
+    # Test that ColumnType enum can handle PostgreSQL's storage formats and aliases
+    assert ColumnType(sql_type_string) == expected_column_type

{iceaxe-0.7.0.dev1 → iceaxe-0.7.0.dev3}/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-0.7.0.dev1 → iceaxe-0.7.0.dev3}/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
@@ -408,8 +408,8 @@ class DatabaseActions:
                 return f"{column_name}::boolean"
             elif explicit_data_type in [
                 ColumnType.DATE,
-                ColumnType.TIMESTAMP,
-                ColumnType.TIME,
+                ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
+                ColumnType.TIME_WITHOUT_TIME_ZONE,
             ]:
                 # Date/time conversions
                 return f"{column_name}::{explicit_data_type.value}"

{iceaxe-0.7.0.dev1 → iceaxe-0.7.0.dev3}/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"
@@ -384,12 +454,12 @@ class DatabaseHandler:
                         primitive_type=(
                             ColumnType.TIMESTAMP_WITH_TIME_ZONE
                             if info.postgres_config.timezone
-                            else ColumnType.TIMESTAMP
+                            else ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE
                         )
                     )
                 # Assume no timezone if not specified
                 return TypeDeclarationResponse(
-                    primitive_type=ColumnType.TIMESTAMP,
+                    primitive_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
                 )
             elif is_type_compatible(annotation, date):  # type: ignore
                 return TypeDeclarationResponse(
@@ -401,11 +471,11 @@ class DatabaseHandler:
                         primitive_type=(
                             ColumnType.TIME_WITH_TIME_ZONE
                             if info.postgres_config.timezone
-                            else ColumnType.TIME
+                            else ColumnType.TIME_WITHOUT_TIME_ZONE
                         ),
                     )
                 return TypeDeclarationResponse(
-                    primitive_type=ColumnType.TIME,
+                    primitive_type=ColumnType.TIME_WITHOUT_TIME_ZONE,
                 )
             elif is_type_compatible(annotation, timedelta):  # type: ignore
                 return TypeDeclarationResponse(
@@ -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-0.7.0.dev1 → iceaxe-0.7.0.dev3}/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-0.7.0.dev1 → iceaxe-0.7.0.dev3}/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 → iceaxe-0.7.0.dev3}/iceaxe/sql_types.py

@@ -8,6 +8,10 @@ class ColumnType(StrEnum):
     # the column they can be case-insensitive, but when we're casting from
     # the database to memory they must align with the on-disk representation
     # which is lowercase.
+    #
+    # Note: The SQL standard requires that writing just "timestamp" be equivalent
+    # to "timestamp without time zone", and PostgreSQL honors that behavior.
+    # Similarly, "time" is equivalent to "time without time zone".
 
     # Numeric Types
     SMALLINT = "smallint"
@@ -33,9 +37,9 @@ class ColumnType(StrEnum):
 
     # Date/Time Types
     DATE = "date"
-    TIME = "time"
+    TIME_WITHOUT_TIME_ZONE = "time without time zone"
     TIME_WITH_TIME_ZONE = "time with time zone"
-    TIMESTAMP = "timestamp"
+    TIMESTAMP_WITHOUT_TIME_ZONE = "timestamp without time zone"
     TIMESTAMP_WITH_TIME_ZONE = "timestamp with time zone"
     INTERVAL = "interval"
 
@@ -85,6 +89,31 @@ class ColumnType(StrEnum):
     # Object Identifier Type
     OID = "oid"
 
+    @classmethod
+    def _missing_(cls, value: object):
+        """
+        Handle SQL standard aliases when the exact enum value is not found.
+
+        The SQL standard requires that "timestamp" be equivalent to "timestamp without time zone"
+        and "time" be equivalent to "time without time zone".
+        """
+        # Only handle string values for SQL type aliases
+        if not isinstance(value, str):
+            return None
+
+        aliases = {
+            "timestamp": "timestamp without time zone",
+            "time": "time without time zone",
+        }
+
+        # Check if this is an alias we can resolve
+        if value in aliases:
+            # Return the actual enum member for the aliased value
+            return cls(aliases[value])
+
+        # If not an alias, let the default enum behavior handle it
+        return None
+
 
 class ConstraintType(StrEnum):
     PRIMARY_KEY = "PRIMARY KEY"
@@ -105,9 +134,9 @@ def get_python_to_sql_mapping():
         bool: ColumnType.BOOLEAN,
         bytes: ColumnType.BYTEA,
         UUID: ColumnType.UUID,
-        datetime: ColumnType.TIMESTAMP,
+        datetime: ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
         date: ColumnType.DATE,
-        time: ColumnType.TIME,
+        time: ColumnType.TIME_WITHOUT_TIME_ZONE,
         timedelta: ColumnType.INTERVAL,
     }
 

{iceaxe-0.7.0.dev1 → iceaxe-0.7.0.dev3/iceaxe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iceaxe
-Version: 0.7.0.dev1
+Version: 0.7.0.dev3
 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 → iceaxe-0.7.0.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iceaxe"
-version = "0.7.0.dev1"
+version = "0.7.0.dev3"
 description = "A modern, fast ORM for Python."
 readme = "README.md"
 requires-python = ">=3.11"

iceaxe-0.7.0.dev1/iceaxe/__tests__/schemas/test_db_stubs.py

@@ -1,26 +0,0 @@
-from iceaxe.schemas.db_stubs import DBType
-
-
-def test_merge_type_columns():
-    """
-    Allow separately yielded type definitions to collect their reference columns. If an
-    enum is referenced in one place, this should build up to the full definition.
-
-    """
-    type_a = DBType(
-        name="type_a",
-        values=frozenset({"A"}),
-        reference_columns=frozenset({("table_a", "column_a")}),
-    )
-    type_b = DBType(
-        name="type_a",
-        values=frozenset({"A"}),
-        reference_columns=frozenset({("table_b", "column_b")}),
-    )
-
-    merged = type_a.merge(type_b)
-    assert merged.name == "type_a"
-    assert merged.values == frozenset({"A"})
-    assert merged.reference_columns == frozenset(
-        {("table_a", "column_a"), ("table_b", "column_b")}
-    )