iceaxe 0.7.1__tar.gz → 0.8.0__tar.gz

{iceaxe-0.7.1/iceaxe.egg-info → iceaxe-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iceaxe
-Version: 0.7.1
+Version: 0.8.0
 Summary: A modern, fast ORM for Python.
 Author-email: Pierce Freeman <pierce@freeman.vc>
 Requires-Python: >=3.11

{iceaxe-0.7.1 → iceaxe-0.8.0}/iceaxe/__tests__/schemas/test_actions.py

@@ -262,6 +262,7 @@ async def test_add_column_any_type(
         (ColumnType.DECIMAL, ColumnType.NUMERIC),
         (ColumnType.SERIAL, ColumnType.INTEGER),
         (ColumnType.BIGSERIAL, ColumnType.BIGINT),
+        (ColumnType.SMALLSERIAL, ColumnType.SMALLINT),
         (ColumnType.CHAR, "character"),
         (ColumnType.TIME_WITHOUT_TIME_ZONE, "time without time zone"),
         (ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE, "timestamp without time zone"),

{iceaxe-0.7.1 → iceaxe-0.8.0}/iceaxe/__tests__/schemas/test_db_memory_serializer.py

@@ -1523,3 +1523,49 @@ def test_multiple_primary_keys_warning():
         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
+
+
+def test_explicit_type_override(clear_all_database_objects):
+    """
+    Test that explicit_type parameter overrides automatic type inference.
+    """
+
+    class TestModel(TableBase):
+        id: int = Field(primary_key=True)
+        # This should be BIGINT instead of INTEGER due to explicit_type
+        big_number: int = Field(explicit_type=ColumnType.BIGINT)
+        # This should be TEXT instead of VARCHAR due to explicit_type
+        long_text: str = Field(explicit_type=ColumnType.TEXT)
+        # This should be JSONB instead of JSON due to explicit_type
+        data: dict = Field(is_json=True, explicit_type=ColumnType.JSONB)
+        # Normal field without explicit_type for comparison
+        normal_field: str = Field()
+
+    migrator = DatabaseMemorySerializer()
+    db_objects = list(migrator.delegate([TestModel]))
+
+    # Extract column definitions
+    columns = [obj for obj, _ in db_objects if isinstance(obj, DBColumn)]
+
+    # Find each column and verify the type
+    big_number_column = next(c for c in columns if c.column_name == "big_number")
+    assert big_number_column.column_type == ColumnType.BIGINT
+    assert not big_number_column.nullable
+
+    long_text_column = next(c for c in columns if c.column_name == "long_text")
+    assert long_text_column.column_type == ColumnType.TEXT
+    assert not long_text_column.nullable
+
+    data_column = next(c for c in columns if c.column_name == "data")
+    assert data_column.column_type == ColumnType.JSONB
+    assert not data_column.nullable
+
+    # Verify normal field still uses automatic inference
+    normal_field_column = next(c for c in columns if c.column_name == "normal_field")
+    assert normal_field_column.column_type == ColumnType.VARCHAR
+    assert not normal_field_column.nullable
+
+    # Verify the id field uses automatic inference (INTEGER)
+    id_column = next(c for c in columns if c.column_name == "id")
+    assert id_column.column_type == ColumnType.INTEGER
+    assert not id_column.nullable

{iceaxe-0.7.1 → iceaxe-0.8.0}/iceaxe/__tests__/test_queries.py

@@ -5,6 +5,7 @@ import pytest
 
 from iceaxe.__tests__.conf_models import (
     ArtifactDemo,
+    ComplexDemo,
     Employee,
     FunctionDemoModel,
     UserDemo,
@@ -316,6 +317,13 @@ def test_function_transformations():
         [],
     )
 
+    # Test unnest function
+    new_query = QueryBuilder().select(func.unnest(ComplexDemo.string_list))
+    assert new_query.build() == (
+        'SELECT unnest("complexdemo"."string_list") AS aggregate_0 FROM "complexdemo"',
+        [],
+    )
+
     # Test type conversion functions
     new_query = QueryBuilder().select(
         (
@@ -337,6 +345,157 @@ def test_function_transformations():
     )
 
 
+def test_array_operators():
+    # Test ANY operator
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(func.any(ComplexDemo.string_list) == "python")
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE \'python\' = ANY("complexdemo"."string_list")',
+        [],
+    )
+
+    # Test ALL operator
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(func.all(ComplexDemo.string_list) == "active")
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE \'active\' = ALL("complexdemo"."string_list")',
+        [],
+    )
+
+    # Test array_contains operator (@>)
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(
+            func.array_contains(ComplexDemo.string_list, ["python", "django"]) == True  # noqa: E712
+        )
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE "complexdemo"."string_list" @> ARRAY[\'python\',\'django\'] = $1',
+        [True],
+    )
+
+    # Test array_contained_by operator (<@)
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(
+            func.array_contained_by(  # noqa: E712
+                ComplexDemo.string_list, ["python", "java", "go", "rust"]
+            )
+            == True
+        )
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE "complexdemo"."string_list" <@ ARRAY[\'python\',\'java\',\'go\',\'rust\'] = $1',
+        [True],
+    )
+
+    # Test array_overlaps operator (&&)
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(
+            func.array_overlaps(  # noqa: E712
+                ComplexDemo.string_list, ["python", "data-science", "ml"]
+            )
+            == True
+        )
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE "complexdemo"."string_list" && ARRAY[\'python\',\'data-science\',\'ml\'] = $1',
+        [True],
+    )
+
+
+def test_array_comparison_operators():
+    # Test ANY with different operators
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(func.any(ComplexDemo.string_list) != "inactive")
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE \'inactive\' != ANY("complexdemo"."string_list")',
+        [],
+    )
+
+    # Test ALL with >= operator
+    new_query = (
+        QueryBuilder()
+        .select(ComplexDemo)
+        .where(func.all(ComplexDemo.string_list) >= "a")
+    )
+    assert new_query.build() == (
+        'SELECT "complexdemo"."id" AS "complexdemo_id", "complexdemo"."string_list" AS "complexdemo_string_list", '
+        '"complexdemo"."json_data" AS "complexdemo_json_data" FROM "complexdemo" WHERE \'a\' >= ALL("complexdemo"."string_list")',
+        [],
+    )
+
+
+def test_array_manipulation_functions():
+    # Test array_append
+    new_query = QueryBuilder().select(
+        func.array_append(ComplexDemo.string_list, "new-tag")
+    )
+    assert new_query.build() == (
+        'SELECT array_append("complexdemo"."string_list", \'new-tag\') AS aggregate_0 FROM "complexdemo"',
+        [],
+    )
+
+    # Test array_prepend
+    new_query = QueryBuilder().select(
+        func.array_prepend("featured", ComplexDemo.string_list)
+    )
+    assert new_query.build() == (
+        'SELECT array_prepend(\'featured\', "complexdemo"."string_list") AS aggregate_0 FROM "complexdemo"',
+        [],
+    )
+
+    # Test array_cat with field - this would require a join in practice
+    # For now, let's test with a simpler case using the same table
+    # or we could test array_cat with a literal array which is more common
+
+    # Test array_cat with literal array
+    new_query = QueryBuilder().select(
+        func.array_cat(ComplexDemo.string_list, ["admin", "superuser"])
+    )
+    assert new_query.build() == (
+        'SELECT array_cat("complexdemo"."string_list", ARRAY[\'admin\',\'superuser\']) AS aggregate_0 FROM "complexdemo"',
+        [],
+    )
+
+    # Test array_position
+    new_query = QueryBuilder().select(
+        func.array_position(ComplexDemo.string_list, "python")
+    )
+    assert new_query.build() == (
+        'SELECT array_position("complexdemo"."string_list", \'python\') AS aggregate_0 FROM "complexdemo"',
+        [],
+    )
+
+    # Test array_remove
+    new_query = QueryBuilder().select(
+        func.array_remove(ComplexDemo.string_list, "deprecated")
+    )
+    assert new_query.build() == (
+        'SELECT array_remove("complexdemo"."string_list", \'deprecated\') AS aggregate_0 FROM "complexdemo"',
+        [],
+    )
+
+
 def test_invalid_where_condition():
     with pytest.raises(ValueError):
         QueryBuilder().select(UserDemo.id).where("invalid condition")  # type: ignore

{iceaxe-0.7.1 → iceaxe-0.8.0}/iceaxe/base.py

@@ -76,6 +76,7 @@ class DBModelMetaclass(_model_construction.ModelMetaclass):
                     index=False,
                     check_expression=None,
                     is_json=False,
+                    explicit_type=None,
                 )
                 for field, info in cls.model_fields.items()
             }

{iceaxe-0.7.1 → iceaxe-0.8.0}/iceaxe/field.py

@@ -19,6 +19,7 @@ from pydantic_core import PydanticUndefined
 from iceaxe.comparison import ComparisonBase
 from iceaxe.postgres import PostgresFieldBase
 from iceaxe.queries_str import QueryIdentifier, QueryLiteral
+from iceaxe.sql_types import ColumnType
 
 if TYPE_CHECKING:
     from iceaxe.base import TableBase
@@ -37,6 +38,7 @@ class DBFieldInputs(_FieldInfoInputs, total=False):
     index: bool
     check_expression: str | None
     is_json: bool
+    explicit_type: ColumnType | None
 
 
 class DBFieldInfo(FieldInfo):
@@ -97,6 +99,12 @@ class DBFieldInfo(FieldInfo):
     When True, the field's value will be JSON serialized before storage.
     """
 
+    explicit_type: ColumnType | None = None
+    """
+    Explicitly specify the SQL column type for this field.
+    When set, this type takes precedence over automatic type inference.
+    """
+
     def __init__(self, **kwargs: Unpack[DBFieldInputs]):
         """
         Initialize a new DBFieldInfo instance with the given field configuration.
@@ -119,6 +127,7 @@ class DBFieldInfo(FieldInfo):
         self.index = kwargs.pop("index", False)
         self.check_expression = kwargs.pop("check_expression", None)
         self.is_json = kwargs.pop("is_json", False)
+        self.explicit_type = kwargs.pop("explicit_type", None)
 
     @classmethod
     def extend_field(
@@ -131,6 +140,7 @@ class DBFieldInfo(FieldInfo):
         index: bool,
         check_expression: str | None,
         is_json: bool,
+        explicit_type: ColumnType | None,
     ):
         """
         Helper function to extend a Pydantic FieldInfo with database-specific attributes.
@@ -144,6 +154,7 @@ class DBFieldInfo(FieldInfo):
             index=index,
             check_expression=check_expression,
             is_json=is_json,
+            explicit_type=explicit_type,
             **field._attributes_set,  # type: ignore
         )
 
@@ -168,6 +179,7 @@ def __get_db_field(_: Callable[Concatenate[Any, P], Any] = PydanticField):  # ty
         index: bool = False,
         check_expression: str | None = None,
         is_json: bool = False,
+        explicit_type: ColumnType | None = None,
         default: Any = _Unset,
         default_factory: (
             Callable[[], Any] | Callable[[dict[str, Any]], Any] | None
@@ -192,6 +204,7 @@ def __get_db_field(_: Callable[Concatenate[Any, P], Any] = PydanticField):  # ty
                 index=index,
                 check_expression=check_expression,
                 is_json=is_json,
+                explicit_type=explicit_type,
             ),
         )