iceaxe 0.6.0.dev2__tar.gz → 0.6.0.dev3__tar.gz

{iceaxe-0.6.0.dev2/iceaxe.egg-info → iceaxe-0.6.0.dev3}/PKG-INFO

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

{iceaxe-0.6.0.dev2 → iceaxe-0.6.0.dev3}/iceaxe/__tests__/test_comparison.py

@@ -294,3 +294,63 @@ def test_default_eq_ne_are_null_safe(db_field: DBFieldClassDefinition):
     ne_col = db_field != other_field
     assert isinstance(ne_col, FieldComparison)
     assert ne_col.comparison == ComparisonType.IS_DISTINCT_FROM
+
+
+@pytest.mark.parametrize(
+    "magic_method,value",
+    [
+        ("__eq__", 5),
+        ("__ne__", 5),
+        ("__lt__", 5),
+        ("__le__", 5),
+        ("__gt__", 5),
+        ("__ge__", 5),
+    ],
+)
+def test_python_magic_methods_set_expression_flag(
+    db_field: DBFieldClassDefinition, magic_method: str, value: Any
+):
+    """
+    Test that all Python magic methods set python_expression to True
+    """
+    comparison = getattr(db_field, magic_method)(value)
+    assert isinstance(comparison, FieldComparison)
+    assert comparison.python_expression is True
+
+
+@pytest.mark.parametrize(
+    "initial_comparison, python_expression, expected_comparison",
+    [
+        (ComparisonType.IS_NOT_DISTINCT_FROM, True, ComparisonType.EQ),
+        (ComparisonType.IS_DISTINCT_FROM, True, ComparisonType.NE),
+        (
+            ComparisonType.IS_NOT_DISTINCT_FROM,
+            False,
+            ComparisonType.IS_NOT_DISTINCT_FROM,
+        ),
+        (ComparisonType.IS_DISTINCT_FROM, False, ComparisonType.IS_DISTINCT_FROM),
+    ],
+)
+def test_force_join_constraints(
+    initial_comparison: ComparisonType,
+    python_expression: bool,
+    expected_comparison: ComparisonType,
+):
+    """
+    Test that force_join_constraints correctly transforms comparison types
+    """
+    db_field = DBFieldClassDefinition(
+        root_model=TableBase, key="test_key", field_definition=DBFieldInfo()
+    )
+    other_field = DBFieldClassDefinition(
+        root_model=TableBase, key="other_key", field_definition=DBFieldInfo()
+    )
+
+    comparison = FieldComparison(
+        left=db_field,
+        comparison=initial_comparison,
+        right=other_field,
+        python_expression=python_expression,
+    )
+    forced = comparison.force_join_constraints()
+    assert forced.comparison == expected_comparison

{iceaxe-0.6.0.dev2 → iceaxe-0.6.0.dev3}/iceaxe/__tests__/test_queries.py

@@ -102,7 +102,7 @@ def test_join():
         .join(ArtifactDemo, UserDemo.id == ArtifactDemo.user_id)
     )
     assert new_query.build() == (
-        'SELECT "userdemo"."id" AS "userdemo_id", "artifactdemo"."title" AS "artifactdemo_title" FROM "userdemo" INNER JOIN "artifactdemo" ON "userdemo"."id" IS NOT DISTINCT FROM "artifactdemo"."user_id"',
+        'SELECT "userdemo"."id" AS "userdemo_id", "artifactdemo"."title" AS "artifactdemo_title" FROM "userdemo" INNER JOIN "artifactdemo" ON "userdemo"."id" = "artifactdemo"."user_id"',
         [],
     )
 
@@ -114,7 +114,7 @@ def test_left_join():
         .join(ArtifactDemo, UserDemo.id == ArtifactDemo.user_id, "LEFT")
     )
     assert new_query.build() == (
-        'SELECT "userdemo"."id" AS "userdemo_id", "artifactdemo"."title" AS "artifactdemo_title" FROM "userdemo" LEFT JOIN "artifactdemo" ON "userdemo"."id" IS NOT DISTINCT FROM "artifactdemo"."user_id"',
+        'SELECT "userdemo"."id" AS "userdemo_id", "artifactdemo"."title" AS "artifactdemo_title" FROM "userdemo" LEFT JOIN "artifactdemo" ON "userdemo"."id" = "artifactdemo"."user_id"',
         [],
     )
 
@@ -525,7 +525,7 @@ def test_for_update_multiple_of():
     assert new_query.build() == (
         'SELECT "userdemo"."id" AS "userdemo_id", "userdemo"."name" AS "userdemo_name", "userdemo"."email" AS "userdemo_email", '
         '"artifactdemo"."id" AS "artifactdemo_id", "artifactdemo"."title" AS "artifactdemo_title", "artifactdemo"."user_id" AS "artifactdemo_user_id" '
-        'FROM "userdemo" INNER JOIN "artifactdemo" ON "userdemo"."id" IS NOT DISTINCT FROM "artifactdemo"."user_id" '
+        'FROM "userdemo" INNER JOIN "artifactdemo" ON "userdemo"."id" = "artifactdemo"."user_id" '
         'FOR UPDATE OF "artifactdemo", "userdemo"',
         [],
     )

{iceaxe-0.6.0.dev2 → iceaxe-0.6.0.dev3}/iceaxe/comparison.py

@@ -181,6 +181,14 @@ class FieldComparison(Generic[T]):
     The right side of the comparison (can be a value or another field)
     """
 
+    python_expression: bool = False
+    """
+    Implicit comparisons are created from Python expressions (like col1 == col2). If this
+    flag is False, it means the user explicitly used one of the column() helper functions like
+    .equals(), .not_equals(), etc.
+
+    """
+
     def to_query(self, start: int = 1) -> tuple[QueryLiteral, list[Any]]:
         """
         Converts the comparison to its SQL representation.
@@ -220,6 +228,24 @@ class FieldComparison(Generic[T]):
 
         return QueryLiteral(f"{field} {comparison.value} {value}"), variables
 
+    def force_join_constraints(self):
+        """
+        Set the context of the comparison to be used in a join. This places certain constraints
+        on the comparison operations that can be applied, like using equals for columns instead
+        of IS DISTINCT FROM.
+
+        """
+        comparison = self.comparison
+
+        # Only if we were created implicitly should we modify the comparison type
+        if self.python_expression:
+            if self.comparison == ComparisonType.IS_DISTINCT_FROM:
+                comparison = ComparisonType.NE
+            elif self.comparison == ComparisonType.IS_NOT_DISTINCT_FROM:
+                comparison = ComparisonType.EQ
+
+        return FieldComparison(left=self.left, comparison=comparison, right=self.right)
+
 
 @dataclass
 class FieldComparisonGroup:
@@ -318,11 +344,17 @@ class ComparisonBase(ABC, Generic[J]):
         :param other: Value to compare against
         :return: A field comparison object
         """
+        raw_comparison: bool | None = None
         if other is None:
-            return self.is_(None)
+            raw_comparison = self.is_(None)
         elif is_column(other):
-            return self.is_not_distinct_from(other)
-        return self.equals(other)
+            raw_comparison = self.is_not_distinct_from(other)
+
+        comparison: FieldComparison[Self] = (
+            raw_comparison if raw_comparison is not None else self.equals(other)
+        )  # type: ignore
+        comparison.python_expression = True
+        return comparison
 
     def __ne__(self, other):  # type: ignore
         """
@@ -333,11 +365,17 @@ class ComparisonBase(ABC, Generic[J]):
         :param other: Value to compare against
         :return: A field comparison object
         """
+        raw_comparison: bool | None = None
         if other is None:
-            return self.is_not(None)
+            raw_comparison = self.is_not(None)
         elif is_column(other):
-            return self.is_distinct_from(other)
-        return self.not_equals(other)
+            raw_comparison = self.is_distinct_from(other)
+
+        comparison: FieldComparison[Self] = (
+            raw_comparison if raw_comparison is not None else self.not_equals(other)
+        )  # type: ignore
+        comparison.python_expression = True
+        return comparison
 
     def __lt__(self, other):
         """
@@ -347,7 +385,9 @@ class ComparisonBase(ABC, Generic[J]):
         :param other: Value to compare against
         :return: A field comparison object
         """
-        return self._compare(ComparisonType.LT, other)
+        comparison = self._compare(ComparisonType.LT, other)
+        comparison.python_expression = True
+        return comparison
 
     def __le__(self, other):
         """
@@ -357,7 +397,9 @@ class ComparisonBase(ABC, Generic[J]):
         :param other: Value to compare against
         :return: A field comparison object
         """
-        return self._compare(ComparisonType.LE, other)
+        comparison = self._compare(ComparisonType.LE, other)
+        comparison.python_expression = True
+        return comparison
 
     def __gt__(self, other):
         """
@@ -367,7 +409,9 @@ class ComparisonBase(ABC, Generic[J]):
         :param other: Value to compare against
         :return: A field comparison object
         """
-        return self._compare(ComparisonType.GT, other)
+        comparison = self._compare(ComparisonType.GT, other)
+        comparison.python_expression = True
+        return comparison
 
     def __ge__(self, other):
         """
@@ -377,7 +421,9 @@ class ComparisonBase(ABC, Generic[J]):
         :param other: Value to compare against
         :return: A field comparison object
         """
-        return self._compare(ComparisonType.GE, other)
+        comparison = self._compare(ComparisonType.GE, other)
+        comparison.python_expression = True
+        return comparison
 
     def equals(self, other: Any) -> bool:
         """

{iceaxe-0.6.0.dev2 → iceaxe-0.6.0.dev3}/iceaxe/queries.py

@@ -677,9 +677,12 @@ class QueryBuilder(Generic[P, QueryType]):
                 f"Invalid join condition: {on}, should be MyTable.column == OtherTable.column"
             )
 
-        on_left, _ = on.left.to_query()
-        comparison = QueryLiteral(on.comparison.value)
-        on_right, _ = on.right.to_query()
+        # Let the comparison update to handle its current usage in a join
+        on_join = on.force_join_constraints()
+
+        on_left, _ = on_join.left.to_query()
+        comparison = QueryLiteral(on_join.comparison.value)
+        on_right, _ = on_join.right.to_query()
 
         join_sql = f"{join_type} JOIN {sql(table)} ON {on_left} {comparison} {on_right}"
         self._join_clauses.append(join_sql)

{iceaxe-0.6.0.dev2 → iceaxe-0.6.0.dev3/iceaxe.egg-info}/PKG-INFO

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

{iceaxe-0.6.0.dev2 → iceaxe-0.6.0.dev3}/pyproject.toml

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