iceaxe 0.8.3__cp313-cp313-macosx_11_0_arm64.whl

iceaxe/__tests__/schemas/test_db_serializer.py

@@ -0,0 +1,435 @@
+from enum import Enum, IntEnum, StrEnum
+
+import pytest
+
+from iceaxe.schemas.actions import (
+    ColumnType,
+    ConstraintType,
+    ForeignKeyConstraint,
+)
+from iceaxe.schemas.db_serializer import DatabaseSerializer
+from iceaxe.schemas.db_stubs import (
+    DBColumn,
+    DBColumnPointer,
+    DBConstraint,
+    DBObject,
+    DBObjectPointer,
+    DBTable,
+    DBType,
+    DBTypePointer,
+)
+from iceaxe.session import DBConnection
+
+
+def compare_db_objects(
+    calculated: list[tuple[DBObject, list[DBObject | DBObjectPointer]]],
+    expected: list[tuple[DBObject, list[DBObject | DBObjectPointer]]],
+):
+    """
+    Helper function to compare lists of DBObjects. The order doesn't actually matter
+    for downstream uses, but we can't do a simple equality check with a set because the
+    dependencies list is un-hashable.
+
+    """
+    assert sorted(calculated, key=lambda x: x[0].representation()) == sorted(
+        expected, key=lambda x: x[0].representation()
+    )
+
+
+class ValueEnumStandard(Enum):
+    A = "A"
+
+
+class ValueEnumStr(StrEnum):
+    A = "A"
+
+
+class ValueEnumInt(IntEnum):
+    A = 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "sql_text, expected_db_objects",
+    [
+        # Enum
+        (
+            """
+            CREATE TYPE valueenumstandard AS ENUM ('A');
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                standard_enum valueenumstandard NOT NULL
+            );
+            """,
+            [
+                (
+                    DBType(
+                        name="valueenumstandard",
+                        values=frozenset({"A"}),
+                        reference_columns=frozenset(
+                            {("exampledbmodel", "standard_enum")}
+                        ),
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                ),
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="standard_enum",
+                        column_type=DBTypePointer(
+                            name="valueenumstandard",
+                        ),
+                        column_is_list=False,
+                        nullable=False,
+                    ),
+                    [
+                        DBType(
+                            name="valueenumstandard",
+                            values=frozenset({"A"}),
+                            reference_columns=frozenset(
+                                {("exampledbmodel", "standard_enum")}
+                            ),
+                        ),
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                ),
+            ],
+        ),
+        # Nullable type
+        (
+            """
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                was_nullable VARCHAR
+            );
+            """,
+            [
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="was_nullable",
+                        column_type=ColumnType.VARCHAR,
+                        column_is_list=False,
+                        nullable=True,
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                ),
+            ],
+        ),
+        # List types
+        (
+            """
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                array_list VARCHAR[] NOT NULL
+            );
+            """,
+            [
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="array_list",
+                        column_type=ColumnType.VARCHAR,
+                        column_is_list=True,
+                        nullable=False,
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                )
+            ],
+        ),
+        # 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(
+    sql_text: str,
+    expected_db_objects: list[tuple[DBObject, list[DBObject | DBObjectPointer]]],
+    db_connection: DBConnection,
+    clear_all_database_objects,
+):
+    # Create this new database
+    await db_connection.conn.execute(sql_text)
+
+    db_serializer = DatabaseSerializer()
+    db_objects = []
+    async for values in db_serializer.get_objects(db_connection):
+        db_objects.append(values)
+
+    # Table and primary key are created for each model
+    base_db_objects: list[tuple[DBObject, list[DBObject | DBObjectPointer]]] = [
+        (
+            DBTable(table_name="exampledbmodel"),
+            [],
+        ),
+        (
+            DBColumn(
+                table_name="exampledbmodel",
+                column_name="id",
+                column_type=ColumnType.INTEGER,
+                column_is_list=False,
+                nullable=False,
+            ),
+            [
+                DBTable(table_name="exampledbmodel"),
+            ],
+        ),
+        (
+            DBConstraint(
+                table_name="exampledbmodel",
+                constraint_name="exampledbmodel_pkey",
+                columns=frozenset({"id"}),
+                constraint_type=ConstraintType.PRIMARY_KEY,
+                foreign_key_constraint=None,
+            ),
+            [
+                DBColumnPointer(table_name="exampledbmodel", column_name="id"),
+                DBTable(table_name="exampledbmodel"),
+            ],
+        ),
+    ]
+
+    compare_db_objects(db_objects, base_db_objects + expected_db_objects)
+
+
+@pytest.mark.asyncio
+async def test_db_serializer_foreign_key(
+    db_connection: DBConnection,
+    clear_all_database_objects,
+):
+    await db_connection.conn.execute(
+        """
+        CREATE TABLE foreignmodel (
+            id SERIAL PRIMARY KEY
+        );
+        CREATE TABLE exampledbmodel (
+            id SERIAL PRIMARY KEY,
+            foreign_key_id INTEGER REFERENCES foreignmodel(id) NOT NULL
+        );
+        """
+    )
+
+    db_serializer = DatabaseSerializer()
+    db_objects = []
+    async for values in db_serializer.get_objects(db_connection):
+        db_objects.append(values)
+
+    expected_db_objects: list[tuple[DBObject, list[DBObject | DBObjectPointer]]] = [
+        # Basic ExampleDBModel table
+        (
+            DBTable(table_name="exampledbmodel"),
+            [],
+        ),
+        (
+            DBColumn(
+                table_name="exampledbmodel",
+                column_name="foreign_key_id",
+                column_type=ColumnType.INTEGER,
+                column_is_list=False,
+                nullable=False,
+            ),
+            [
+                DBTable(table_name="exampledbmodel"),
+            ],
+        ),
+        (
+            DBColumn(
+                table_name="exampledbmodel",
+                column_name="id",
+                column_type=ColumnType.INTEGER,
+                column_is_list=False,
+                nullable=False,
+            ),
+            [
+                DBTable(table_name="exampledbmodel"),
+            ],
+        ),
+        # ForeignModel table
+        (
+            DBTable(table_name="foreignmodel"),
+            [],
+        ),
+        (
+            DBConstraint(
+                table_name="foreignmodel",
+                constraint_name="foreignmodel_pkey",
+                columns=frozenset({"id"}),
+                constraint_type=ConstraintType.PRIMARY_KEY,
+                foreign_key_constraint=None,
+            ),
+            [
+                DBColumnPointer(table_name="foreignmodel", column_name="id"),
+                DBTable(table_name="foreignmodel"),
+            ],
+        ),
+        (
+            DBColumn(
+                table_name="foreignmodel",
+                column_name="id",
+                column_type=ColumnType.INTEGER,
+                column_is_list=False,
+                nullable=False,
+            ),
+            [
+                DBTable(table_name="foreignmodel"),
+            ],
+        ),
+        # Foreign key constraint to link ExampleDBModel to ForeignModel
+        (
+            DBConstraint(
+                table_name="exampledbmodel",
+                constraint_name="exampledbmodel_foreign_key_id_fkey",
+                columns=frozenset({"foreign_key_id"}),
+                constraint_type=ConstraintType.FOREIGN_KEY,
+                foreign_key_constraint=ForeignKeyConstraint(
+                    target_table="foreignmodel", target_columns=frozenset({"id"})
+                ),
+            ),
+            [
+                DBColumnPointer(
+                    table_name="exampledbmodel", column_name="foreign_key_id"
+                ),
+                DBTable(table_name="exampledbmodel"),
+            ],
+        ),
+        (
+            DBConstraint(
+                table_name="exampledbmodel",
+                constraint_name="exampledbmodel_pkey",
+                columns=frozenset({"id"}),
+                constraint_type=ConstraintType.PRIMARY_KEY,
+                foreign_key_constraint=None,
+            ),
+            [
+                DBColumnPointer(table_name="exampledbmodel", column_name="id"),
+                DBTable(table_name="exampledbmodel"),
+            ],
+        ),
+    ]
+
+    compare_db_objects(db_objects, expected_db_objects)
+
+
+@pytest.mark.asyncio
+async def test_db_serializer_foreign_key_actions(
+    db_connection: DBConnection,
+    clear_all_database_objects,
+):
+    """
+    Test that foreign key ON UPDATE/ON DELETE actions are correctly deserialized from the database.
+    """
+    await db_connection.conn.execute(
+        """
+        CREATE TABLE foreignmodel (
+            id SERIAL PRIMARY KEY
+        );
+        CREATE TABLE exampledbmodel (
+            id SERIAL PRIMARY KEY,
+            foreign_key_id INTEGER REFERENCES foreignmodel(id) ON DELETE CASCADE ON UPDATE CASCADE NOT NULL
+        );
+        """
+    )
+
+    db_serializer = DatabaseSerializer()
+    db_objects = []
+    async for values in db_serializer.get_objects(db_connection):
+        db_objects.append(values)
+
+    # Find the foreign key constraint
+    fk_constraint = next(
+        obj
+        for obj, _ in db_objects
+        if isinstance(obj, DBConstraint)
+        and obj.constraint_type == ConstraintType.FOREIGN_KEY
+    )
+    assert fk_constraint.foreign_key_constraint is not None
+    assert fk_constraint.foreign_key_constraint.target_table == "foreignmodel"
+    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"
+
+
+@pytest.mark.asyncio
+async def test_db_serializer_check_constraint(
+    db_connection: DBConnection,
+    clear_all_database_objects,
+):
+    """
+    Test that CHECK constraints are correctly deserialized from the database.
+    This tests the fix for the KeyError: 'oid' bug where pg_constraint.oid
+    was not selected in the query.
+    """
+    await db_connection.conn.execute(
+        """
+        CREATE TABLE exampledbmodel (
+            id SERIAL PRIMARY KEY,
+            age INTEGER NOT NULL,
+            CONSTRAINT age_positive CHECK (age > 0)
+        );
+        """
+    )
+
+    db_serializer = DatabaseSerializer()
+    db_objects = []
+    async for values in db_serializer.get_objects(db_connection):
+        db_objects.append(values)
+
+    # Find the check constraint
+    check_constraint_obj = next(
+        obj
+        for obj, _ in db_objects
+        if isinstance(obj, DBConstraint) and obj.constraint_type == ConstraintType.CHECK
+    )
+    assert check_constraint_obj.check_constraint is not None
+    assert check_constraint_obj.constraint_name == "age_positive"
+    # PostgreSQL returns the check condition in a normalized format
+    assert "age > 0" in check_constraint_obj.check_constraint.check_condition

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/__tests__/test_alias.py

@@ -0,0 +1,83 @@
+import pytest
+
+from iceaxe import alias, func, select, sql
+from iceaxe.__tests__.conf_models import UserDemo
+from iceaxe.queries import QueryBuilder
+from iceaxe.session import (
+    DBConnection,
+)
+
+
+@pytest.mark.asyncio
+async def test_alias_with_function(db_connection: DBConnection):
+    """Test using alias with a function value."""
+    demo = UserDemo(id=1, name="Test Title", email="john@example.com")
+    await db_connection.insert([demo])
+
+    # Test using string length function with alias
+    results = await db_connection.exec(
+        select((UserDemo, alias("name_length", func.length(UserDemo.name))))
+    )
+
+    assert len(results) == 1
+    assert results[0][0].id == 1
+    assert isinstance(results[0][1], int)  # length result
+
+
+@pytest.mark.asyncio
+async def test_alias_with_raw_sql(db_connection: DBConnection):
+    """
+    Test that we can use a text query alongside an alias to map raw SQL results
+    to typed values.
+    """
+    user = UserDemo(name="John Doe", email="john@example.com")
+    await db_connection.insert([user])
+
+    # Create a query that uses text() alongside an alias
+    query = (
+        QueryBuilder()
+        .select((UserDemo, alias("rollup_value", int)))
+        .text(
+            f"""
+            SELECT {sql.select(UserDemo)}, COUNT(*) AS rollup_value
+            FROM userdemo
+            GROUP BY id
+            """
+        )
+    )
+    result = await db_connection.exec(query)
+    assert len(result) == 1
+    assert isinstance(result[0], tuple)
+    assert isinstance(result[0][0], UserDemo)
+    assert result[0][0].name == "John Doe"
+    assert result[0][0].email == "john@example.com"
+    assert result[0][1] == 1  # The count should be 1
+
+
+@pytest.mark.asyncio
+async def test_multiple_aliases(db_connection: DBConnection):
+    """Test using multiple aliases in a single query."""
+    demo1 = UserDemo(id=1, name="First Item", email="john@example.com")
+    demo2 = UserDemo(id=2, name="Second Item", email="jane@example.com")
+    await db_connection.insert([demo1, demo2])
+
+    # Test multiple aliases with different SQL functions
+    results = await db_connection.exec(
+        select(
+            (
+                UserDemo,
+                alias("upper_name", func.upper(UserDemo.name)),
+                alias("item_count", func.count(UserDemo.id)),
+            )
+        )
+        .group_by(UserDemo.id, UserDemo.name)
+        .order_by(UserDemo.id)
+    )
+
+    assert len(results) == 2
+    assert results[0][0].id == 1
+    assert results[0][1] == "FIRST ITEM"  # uppercase name
+    assert results[0][2] == 1  # count result
+    assert results[1][0].id == 2
+    assert results[1][1] == "SECOND ITEM"  # uppercase name
+    assert results[1][2] == 1  # count result