jupyter-duckdb 1.4.106__py3-none-any.whl → 1.4.108__py3-none-any.whl

duckdb_kernel/tests/test_ra.py

@@ -3,7 +3,7 @@ import pytest
 import duckdb_kernel.parser.elements.binary as BinaryOperators
 import duckdb_kernel.parser.elements.unary as UnaryOperators
 from duckdb_kernel.parser import RAParser, RAParserError
-from duckdb_kernel.parser.elements import RAOperand, LogicElement
+from duckdb_kernel.parser.elements import RAOperand, LogicElement, RARelationReference
 from . import Connection
 
 
@@ -101,6 +101,13 @@ def test_comments():
         assert isinstance(root.left, RAOperand) and root.left.name == 'Shows'
         assert isinstance(root.right, RAOperand) and root.right.name == 'Seasons'
 
+    for query in (
+        '-- comment',
+        '/* comment */'
+    ):
+        root = RAParser.parse_query(query)
+        assert root is None
+
 
 def test_binary_operator_cross():
     for query in (
@@ -236,6 +243,14 @@ def test_binary_operator_join():
                 (2, 'Show 2', 2, 'Show 2 / Season 2')
             ]
 
+    for query in (
+            r'Shows ⋈ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_ljoin():
     for query in (
@@ -262,6 +277,14 @@ def test_binary_operator_ljoin():
                 (3, 'Charlie', None),
             ]
 
+    for query in (
+            r'Shows ⟕ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_rjoin():
     for query in (
@@ -287,6 +310,14 @@ def test_binary_operator_rjoin():
                 (4, None, 'David')
             ]
 
+    for query in (
+            r'Shows ⟖ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_fjoin():
     for query in (
@@ -315,6 +346,14 @@ def test_binary_operator_fjoin():
                 (4, None, 'David')
             ]
 
+    for query in (
+            r'Shows ⟗ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_lsjoin():
     for query in (
@@ -338,6 +377,14 @@ def test_binary_operator_lsjoin():
                 (2, 'Bob')
             ]
 
+    for query in (
+            r'Shows ⋉ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_rsjoin():
     for query in (
@@ -361,6 +408,14 @@ def test_binary_operator_rsjoin():
                 (2, 'Bob')
             ]
 
+    for query in (
+            r'Shows ⋊ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_union():
     for query in (
@@ -445,7 +500,7 @@ def test_unary_operator_projection():
             ]
 
 
-def test_unary_operator_rename():
+def test_unary_operator_attributerename():
     with Connection() as con:
         for query in (
                 r'β Id2 ← Id Users',
@@ -463,7 +518,7 @@ def test_unary_operator_rename():
         ):
             root = RAParser.parse_query(query)
 
-            assert isinstance(root, UnaryOperators.Rename)
+            assert isinstance(root, UnaryOperators.AttributeRename)
             assert isinstance(root.arg, LogicElement)
             assert isinstance(root.target, RAOperand) and root.target.name == 'Users'
 
@@ -492,9 +547,9 @@ def test_unary_operator_rename():
         ):
             root = RAParser.parse_query(query)
 
-            assert isinstance(root, UnaryOperators.Rename)
+            assert isinstance(root, UnaryOperators.AttributeRename)
             assert isinstance(root.arg, LogicElement)
-            assert isinstance(root.target, UnaryOperators.Rename)
+            assert isinstance(root.target, UnaryOperators.AttributeRename)
             assert isinstance(root.target.arg, LogicElement)
             assert isinstance(root.target.target, RAOperand) and root.target.target.name == 'Users'
 
@@ -511,6 +566,157 @@ def test_unary_operator_rename():
             ]
 
 
+def test_unary_operator_rename():
+    with Connection() as con:
+        # relation
+        for query in (
+                # ρ
+                r'ρ R Users',
+                r'ρ R ( Users )',
+                r'ρ [ R ] Users',
+                r'ρ [ R ] ( Users )',
+                # ϱ
+                r'ϱ R Users',
+                r'ϱ R ( Users )',
+                r'ϱ [ R ] Users',
+                r'ϱ [ R ] ( Users )',
+                # rho
+                r'rho R Users',
+                r'rho R ( Users )',
+                r'rho [ R ] Users',
+                r'rho [ R ] ( Users )',
+        ):
+            root = RAParser.parse_query(query)
+
+            assert isinstance(root, UnaryOperators.Rename)
+            assert isinstance(root.arg, RARelationReference)
+            assert isinstance(root.target, RAOperand) and root.target.name == 'Users'
+
+            cols, rows = con.execute_ra_return_cols(root)
+
+            assert root.arg.relation == 'R'
+            assert root.arg.attributes is None
+
+            assert [c.lower() for c in cols] == [
+                'id',
+                'username'
+            ]
+            assert rows == [
+                (1, 'Alice'),
+                (2, 'Bob'),
+                (3, 'Charlie')
+            ]
+
+        # attributes
+        for query in (
+                # ρ
+                r'ρ (A,) Users',
+                r'ρ (A,) ( Users )',
+                r'ρ [ (A,) ] Users',
+                r'ρ [ (A,) ] ( Users )',
+                # ϱ
+                r'ϱ (A,) Users',
+                r'ϱ (A,) ( Users )',
+                r'ϱ [ (A,) ] Users',
+                r'ϱ [ (A,) ] ( Users )',
+                # rho
+                r'rho (A,) Users',
+                r'rho (A,) ( Users )',
+                r'rho [ (A,) ] Users',
+                r'rho [ (A,) ] ( Users )',
+        ):
+            root = RAParser.parse_query(query)
+
+            assert isinstance(root, UnaryOperators.Rename)
+            assert isinstance(root.arg, RARelationReference)
+            assert isinstance(root.target, RAOperand) and root.target.name == 'Users'
+
+            cols, rows = con.execute_ra_return_cols(root)
+
+            assert root.arg.relation is None
+            assert root.arg.attributes == ['A']
+
+            assert [c.lower() for c in cols] == [
+                'a',
+                'username'
+            ]
+            assert rows == [
+                (1, 'Alice'),
+                (2, 'Bob'),
+                (3, 'Charlie')
+            ]
+
+        for query in (
+                # ρ
+                r'ρ (A,B) Users',
+                r'ρ (A, B) Users',
+                r'ρ (A,B) ( Users )',
+                r'ρ (A, B) ( Users )',
+                r'ρ [ (A,B) ] Users',
+                r'ρ [ (A, B) ] Users',
+                r'ρ [ (A,B) ] ( Users )',
+                r'ρ [ (A, B) ] ( Users )',
+                # ϱ
+                r'ϱ (A,B) Users',
+                r'ϱ (A, B) Users',
+                r'ϱ (A,B) ( Users )',
+                r'ϱ (A, B) ( Users )',
+                r'ϱ [ (A,B) ] Users',
+                r'ϱ [ (A, B) ] Users',
+                r'ϱ [ (A,B) ] ( Users )',
+                r'ϱ [ (A, B) ] ( Users )',
+                # rho
+                r'rho (A,B) Users',
+                r'rho (A, B) Users',
+                r'rho (A,B) ( Users )',
+                r'rho (A, B) ( Users )',
+                r'rho [ (A,B) ] Users',
+                r'rho [ (A, B) ] Users',
+                r'rho [ (A,B) ] ( Users )',
+                r'rho [ (A, B) ] ( Users )',
+        ):
+            root = RAParser.parse_query(query)
+
+            assert isinstance(root, UnaryOperators.Rename)
+            assert isinstance(root.arg, RARelationReference)
+            assert isinstance(root.target, RAOperand) and root.target.name == 'Users'
+
+            cols, rows = con.execute_ra_return_cols(root)
+
+            assert root.arg.relation is None
+            assert root.arg.attributes == ['A', 'B']
+
+            assert [c.lower() for c in cols] == [
+                'a',
+                'b'
+            ]
+            assert rows == [
+                (1, 'Alice'),
+                (2, 'Bob'),
+                (3, 'Charlie')
+            ]
+
+        for query in (
+                # ρ
+                r'ρ (A,A) (Users)',
+                r'ρ (A,a) (Users)',
+                r'ρ (A, A) (Users)',
+                r'ρ (A, a) (Users)',
+                # ϱ
+                r'ϱ (A,A) (Users)',
+                r'ϱ (A,a) (Users)',
+                r'ϱ (A, A) (Users)',
+                r'ϱ (A, a) (Users)',
+                # rho
+                r'rho (A,A) (Users)',
+                r'rho (A,a) (Users)',
+                r'rho (A, A) (Users)',
+                r'rho (A, a) (Users)',
+        ):
+            with pytest.raises(RAParserError):
+                root = RAParser.parse_query(query)
+
+
 def test_unary_operator_selection():
     with Connection() as con:
         for query in (
@@ -582,13 +788,21 @@ def test_unary_inner_to_outer_evaluation_order():
     assert root.target.condition.left == ('Id',) and root.target.condition.right == ('1',)
 
     root = RAParser.parse_query(r'β [ Id3 ← Id2 ] β [ Id2 ← Id ] (Users)')
-    assert isinstance(root, UnaryOperators.Rename)
+    assert isinstance(root, UnaryOperators.AttributeRename)
     assert isinstance(root.arrow, BinaryOperators.ArrowLeft)
     assert root.arrow.left == ('Id3',) and root.arrow.right == ('Id2',)
-    assert isinstance(root.target, UnaryOperators.Rename)
+    assert isinstance(root.target, UnaryOperators.AttributeRename)
     assert isinstance(root.target.arrow, BinaryOperators.ArrowLeft)
     assert root.target.arrow.left == ('Id2',) and root.target.arrow.right == ('Id',)
 
+    root = RAParser.parse_query(r'ρ [ S(X, Y) ] ρ [ R(A, B) ] (Users)')
+    assert isinstance(root, UnaryOperators.Rename)
+    assert isinstance(root.arg, RARelationReference)
+    assert root.arg.relation == 'S' and root.arg.attributes == ['X', 'Y']
+    assert isinstance(root.target, UnaryOperators.Rename)
+    assert isinstance(root.target.arg, RARelationReference)
+    assert root.target.arg.relation == 'R' and root.target.arg.attributes == ['A', 'B']
+
 
 def test_binary_left_to_right_evaluation_order():
     # difference
@@ -901,30 +1115,58 @@ def test_binary_left_to_right_evaluation_order():
 
 
 def test_unary_evaluation_order():
-    root = RAParser.parse_query(r'π [ Id2 ] β [ Id2 ← Id ] (Users)')
+    # π
+    root = RAParser.parse_query(r'π [ Id ] σ [ Id > 1 ] (Users)')
     assert isinstance(root, UnaryOperators.Projection)
-    assert isinstance(root.target, UnaryOperators.Rename)
+    assert isinstance(root.target, UnaryOperators.Selection)
 
-    root = RAParser.parse_query(r'β [ Id2 ← Id ] π [ Id ] (Users)')
-    assert isinstance(root, UnaryOperators.Rename)
-    assert isinstance(root.target, UnaryOperators.Projection)
+    root = RAParser.parse_query(r'π [ Id2 ] β [ Id2 ← Id ] (Users)')
+    assert isinstance(root, UnaryOperators.Projection)
+    assert isinstance(root.target, UnaryOperators.AttributeRename)
 
-    root = RAParser.parse_query(r'π [ Id ] σ [ Id > 1 ] (Users)')
+    root = RAParser.parse_query(r'π [ Id2 ] ρ [ R(Id2, Username2) ] (Users)')
     assert isinstance(root, UnaryOperators.Projection)
-    assert isinstance(root.target, UnaryOperators.Selection)
+    assert isinstance(root.target, UnaryOperators.Rename)
 
+    # σ
     root = RAParser.parse_query(r'σ [ Id > 1 ] π [ Id ] (Users)')
     assert isinstance(root, UnaryOperators.Selection)
     assert isinstance(root.target, UnaryOperators.Projection)
 
     root = RAParser.parse_query(r'σ [ Id2 > 1 ] β [ Id2 ← Id ] (Users)')
     assert isinstance(root, UnaryOperators.Selection)
+    assert isinstance(root.target, UnaryOperators.AttributeRename)
+
+    root = RAParser.parse_query(r'σ [ Id2 > 1 ] ρ [ R(Id2, Username2) ] (Users)')
+    assert isinstance(root, UnaryOperators.Selection)
     assert isinstance(root.target, UnaryOperators.Rename)
 
+    # β
+    root = RAParser.parse_query(r'β [ Id2 ← Id ] π [ Id ] (Users)')
+    assert isinstance(root, UnaryOperators.AttributeRename)
+    assert isinstance(root.target, UnaryOperators.Projection)
+
     root = RAParser.parse_query(r'β [ Id2 ← Id ] σ [ Id > 1 ] (Users)')
+    assert isinstance(root, UnaryOperators.AttributeRename)
+    assert isinstance(root.target, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'β [ Id3 ← Id2 ] ρ [ R(Id2, Username2) ] (Users)')
+    assert isinstance(root, UnaryOperators.AttributeRename)
+    assert isinstance(root.target, UnaryOperators.Rename)
+
+    # ρ
+    root = RAParser.parse_query(r'ρ [ R(Id2,) ] π [ Id ] (Users)')
+    assert isinstance(root, UnaryOperators.Rename)
+    assert isinstance(root.target, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2, Username2) ] σ [ Id > 1 ] (Users)')
     assert isinstance(root, UnaryOperators.Rename)
     assert isinstance(root.target, UnaryOperators.Selection)
 
+    root = RAParser.parse_query(r'ρ [ R(Id3, Username2) ] β [ Id2 ← Id ] (Users)')
+    assert isinstance(root, UnaryOperators.Rename)
+    assert isinstance(root.target, UnaryOperators.AttributeRename)
+
 
 def test_binary_evaluation_order():
     # difference <-> union
@@ -1314,13 +1556,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Difference)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
-    # difference <-> rename
+    # difference <-> attribute rename
     root = RAParser.parse_query(r'a \ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Difference)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a \ b')
     assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
+
+    # difference <-> rename
+    root = RAParser.parse_query(r'a \ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a \ b')
+    assert isinstance(root, BinaryOperators.Difference)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
     # difference <-> selection
@@ -1341,13 +1592,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Union)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
-    # union <-> rename
+    # union <-> attribute rename
     root = RAParser.parse_query(r'a ∪ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Union)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ∪ b')
     assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
+
+    # union <-> rename
+    root = RAParser.parse_query(r'a ∪ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ∪ b')
+    assert isinstance(root, BinaryOperators.Union)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
     # union <-> selection
@@ -1368,13 +1628,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Intersection)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
-    # intersection <-> rename
+    # intersection <-> attribute rename
     root = RAParser.parse_query(r'a ∩ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Intersection)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ∩ b')
     assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
+
+    # intersection <-> rename
+    root = RAParser.parse_query(r'a ∩ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ∩ b')
+    assert isinstance(root, BinaryOperators.Intersection)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
     # intersection <-> selection
@@ -1435,53 +1704,102 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.RightSemiJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
-    # join <-> rename
+    # join <-> attribute rename
     root = RAParser.parse_query(r'a ⋈ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Join)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⋈ b')
     assert isinstance(root, BinaryOperators.Join)
-    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'a ⟕ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.LeftOuterJoin)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⟕ b')
     assert isinstance(root, BinaryOperators.LeftOuterJoin)
-    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'a ⟖ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.RightOuterJoin)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⟖ b')
     assert isinstance(root, BinaryOperators.RightOuterJoin)
-    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'a ⟗ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.FullOuterJoin)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⟗ b')
     assert isinstance(root, BinaryOperators.FullOuterJoin)
-    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'a ⋉ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.LeftSemiJoin)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⋉ b')
     assert isinstance(root, BinaryOperators.LeftSemiJoin)
-    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'a ⋊ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.RightSemiJoin)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⋊ b')
     assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
+
+    # join <-> rename
+    root = RAParser.parse_query(r'a ⋈ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ⋈ b')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⟕ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ⟕ b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⟖ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ⟖ b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⟗ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ⟗ b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⋉ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ⋉ b')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⋊ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ⋊ b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
     # join <-> selection
@@ -1542,13 +1860,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Cross)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
-    # cross <-> rename
+    # cross <-> attribute rename
     root = RAParser.parse_query(r'a x β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Cross)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a x b')
     assert isinstance(root, BinaryOperators.Cross)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
+
+    # cross <-> rename
+    root = RAParser.parse_query(r'a x ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.Cross)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a x b')
+    assert isinstance(root, BinaryOperators.Cross)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
     # cross <-> selection
@@ -1569,13 +1896,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Division)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
-    # division <-> rename
+    # division <-> attribute rename
     root = RAParser.parse_query(r'a ÷ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Division)
-    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.AttributeRename)
 
     root = RAParser.parse_query(r'β [ Id2 ← Id ] a ÷ b')
     assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.AttributeRename)
+
+    # division <-> rename
+    root = RAParser.parse_query(r'a ÷ ρ [ R(Id2) ] b')
+    assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'ρ [ R(Id2) ] a ÷ b')
+    assert isinstance(root, BinaryOperators.Division)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
     # division <-> selection
@@ -1613,8 +1949,8 @@ def test_special_queries():
         assert isinstance(root.left, UnaryOperators.Selection)
         assert isinstance(root.left.target, UnaryOperators.Projection)
         assert isinstance(root.left.target.target, RAOperand) and root.left.target.target.name == 'Users'
-        assert isinstance(root.right, UnaryOperators.Rename)
-        assert isinstance(root.right.target, UnaryOperators.Rename)
+        assert isinstance(root.right, UnaryOperators.AttributeRename)
+        assert isinstance(root.right.target, UnaryOperators.AttributeRename)
         assert isinstance(root.right.target.target, RAOperand) and root.right.target.target.name == 'BannedUsers'
 
         assert con.execute_ra(root) == [

duckdb_kernel/util/ResultSetComparator.py

@@ -1,11 +1,26 @@
+import datetime
 from datetime import date
-from typing import Tuple, List, Optional
+from typing import Tuple, List, Optional, Any
 
 
 class ResultSetComparator:
     def __init__(self, left: List[Tuple | List], right: List[Tuple | List]):
-        self._left: List[Tuple] = [tuple(t) for t in left]
-        self._right: List[Tuple] = [tuple(t) for t in right]
+        self._left: List[Tuple] = [tuple(self.format_value(t)) for t in left]
+        self._right: List[Tuple] = [tuple(self.format_value(t)) for t in right]
+
+    @staticmethod
+    def format_value(value: Any) -> Any:
+        if isinstance(value, tuple) or isinstance(value, list):
+            return tuple(ResultSetComparator.format_value(t) for t in value)
+
+        if isinstance(value, datetime.datetime):
+            return value.strftime("%Y-%m-%d %H:%M:%S")
+        if isinstance(value, datetime.date):
+            return value.strftime("%Y-%m-%d")
+        if isinstance(value, datetime.time):
+            return value.strftime("%H:%M:%S")
+
+        return value
 
     @property
     def left_only(self) -> List[Tuple]:

{jupyter_duckdb-1.4.106.dist-info → jupyter_duckdb-1.4.108.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jupyter-duckdb
-Version: 1.4.106
+Version: 1.4.108
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs