jupyter-duckdb 1.4.105__py3-none-any.whl → 1.4.107__py3-none-any.whl

duckdb_kernel/kernel.py

@@ -535,6 +535,8 @@ class DuckDBKernel(Kernel):
 
         # parse ra input
         root_node = RAParser.parse_query(state.code)
+        if root_node is None:
+            return
 
         # create and show visualization
         if analyze:
@@ -575,6 +577,8 @@ class DuckDBKernel(Kernel):
 
         # parse dc input
         root_node = DCParser.parse_query(state.code)
+        if root_node is None:
+            return
 
         # generate sql
         sql, cnm = root_node.to_sql_with_renamed_columns(tables)

duckdb_kernel/parser/DCParser.py

@@ -1,15 +1,22 @@
 from .ParserError import DCParserError
 from .elements import *
 from .tokenizer import *
+from .util.QuerySplitter import get_last_query
 
 
 class DCParser:
     @staticmethod
     def parse_query(query: str) -> DC_SET:
+        # remove comments from query
+        query = get_last_query(query, split_at=None, remove_comments=True)
+
         # create initial token set
         initial_token = Token(query)
         tokens = tuple(Tokenizer.tokenize(initial_token))
 
+        if len(tokens) == 0:
+            return None
+
         # split at |
         for i, token in enumerate(tokens):
             if token in DC_SET.symbols():

duckdb_kernel/parser/RAParser.py

@@ -10,7 +10,7 @@ from .util.QuerySplitter import get_last_query
 
 class RAParser:
     @staticmethod
-    def parse_query(query: str) -> RAElement:
+    def parse_query(query: str) -> RAElement | None:
         # remove comments from query
         query = get_last_query(query, split_at=None, remove_comments=True)
 
@@ -19,7 +19,7 @@ class RAParser:
         return RAParser.parse_tokens(initial_token, depth=0)
 
     @staticmethod
-    def parse_tokens(*tokens: Token, target: RAOperator | RAOperand = None, depth: int = 0) -> RAElement:
+    def parse_tokens(*tokens: Token, target: RAOperator | RAOperand = None, depth: int = 0) -> RAElement | None:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
@@ -76,7 +76,9 @@ class RAParser:
                         return op
 
         # return as name
-        if len(tokens) > 1:
+        if len(tokens) == 0:
+            return None
+        elif len(tokens) == 1:
+            return RAOperand(tokens[0])
+        else:
             raise RAParserError(f'{tokens=}', depth)
-
-        return RAOperand(tokens[0])

duckdb_kernel/parser/elements/binary/And.py

@@ -8,7 +8,7 @@ class And(LogicOperator):
 
     @staticmethod
     def symbols() -> Tuple[str, ...]:
-        return '∧', 'and', 'and'
+        return '∧', 'and'
 
     @property
     def sql_symbol(self) -> str:

duckdb_kernel/parser/elements/binary/Cross.py

@@ -8,7 +8,7 @@ from ...util.RenamableColumnList import RenamableColumnList
 class Cross(RABinaryOperator):
     @staticmethod
     def symbols() -> Tuple[str, ...]:
-        return chr(215), 'x'
+        return chr(215), 'x', 'times'
 
     def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
         # execute subqueries
@@ -19,4 +19,4 @@ class Cross(RABinaryOperator):
         cols = lcols.merge(rcols)
 
         # create statement
-        return f'SELECT {cols.list} FROM ({lq}) {self._name()} CROSS JOIN ({rq}) {self._name()}', cols
+        return f'SELECT DISTINCT {cols.list} FROM ({lq}) {self._name()} CROSS JOIN ({rq}) {self._name()}', cols

duckdb_kernel/parser/elements/binary/FullOuterJoin.py

@@ -3,6 +3,7 @@ from typing import Tuple, Dict
 
 from duckdb_kernel.db import Table
 from ..RABinaryOperator import RABinaryOperator
+from ...ParserError import RAParserError
 from ...util.RenamableColumn import RenamableColumn
 from ...util.RenamableColumnList import RenamableColumnList
 
@@ -26,6 +27,8 @@ class FullOuterJoin(RABinaryOperator):
 
         # find matching columns
         join_cols, all_cols = lcols.intersect(rcols)
+        if len(join_cols) == 0:
+            raise RAParserError('no common attributes found for full outer join', 0)
 
         replacements = {c1: c2 for c1, c2 in join_cols}
         select_cols = [self._coalesce(c, replacements.get(c)) for c in all_cols]
@@ -34,4 +37,4 @@ class FullOuterJoin(RABinaryOperator):
         on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
 
         # create sql
-        return f'SELECT {select_clause} FROM ({lq}) {self._name()} FULL OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols
+        return f'SELECT DISTINCT {select_clause} FROM ({lq}) {self._name()} FULL OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

duckdb_kernel/parser/elements/binary/Join.py

@@ -2,6 +2,7 @@ from typing import Tuple, Dict
 
 from duckdb_kernel.db import Table
 from ..RABinaryOperator import RABinaryOperator
+from ...ParserError import RAParserError
 from ...util.RenamableColumnList import RenamableColumnList
 
 
@@ -17,8 +18,10 @@ class Join(RABinaryOperator):
 
         # find matching columns
         join_cols, all_cols = lcols.intersect(rcols)
+        if len(join_cols) == 0:
+            raise RAParserError('no common attributes found for join', 0)
 
         on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
 
         # create sql
-        return f'SELECT {all_cols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', all_cols
+        return f'SELECT DISTINCT {all_cols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

duckdb_kernel/parser/elements/binary/LeftOuterJoin.py

@@ -2,6 +2,7 @@ from typing import Tuple, Dict
 
 from duckdb_kernel.db import Table
 from ..RABinaryOperator import RABinaryOperator
+from ...ParserError import RAParserError
 from ...util.RenamableColumnList import RenamableColumnList
 
 
@@ -17,8 +18,10 @@ class LeftOuterJoin(RABinaryOperator):
 
         # find matching columns
         join_cols, all_cols = lcols.intersect(rcols)
+        if len(join_cols) == 0:
+            raise RAParserError('no common attributes found for left outer join', 0)
 
         on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
 
         # create sql
-        return f'SELECT {all_cols.list} FROM ({lq}) {self._name()} LEFT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols
+        return f'SELECT DISTINCT {all_cols.list} FROM ({lq}) {self._name()} LEFT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

duckdb_kernel/parser/elements/binary/LeftSemiJoin.py

@@ -0,0 +1,27 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+from ...ParserError import RAParserError
+from ...util.RenamableColumnList import RenamableColumnList
+
+
+class LeftSemiJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(8905), 'lsjoin'
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subqueries
+        lq, lcols = self.left.to_sql(tables)
+        rq, rcols = self.right.to_sql(tables)
+
+        # find matching columns
+        join_cols, all_cols = lcols.intersect(rcols)
+        if len(join_cols) == 0:
+            raise RAParserError('no common attributes found for left semi join', 0)
+
+        on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
+
+        # create sql
+        return f'SELECT DISTINCT {lcols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', lcols

duckdb_kernel/parser/elements/binary/RightOuterJoin.py

@@ -2,6 +2,7 @@ from typing import Tuple, Dict
 
 from duckdb_kernel.db import Table
 from ..RABinaryOperator import RABinaryOperator
+from ...ParserError import RAParserError
 from ...util.RenamableColumnList import RenamableColumnList
 
 
@@ -17,8 +18,10 @@ class RightOuterJoin(RABinaryOperator):
 
         # find matching columns
         join_cols, all_cols = lcols.intersect(rcols, prefer_right=True)
+        if len(join_cols) == 0:
+            raise RAParserError('no common attributes found for right outer join', 0)
 
         on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
 
         # create sql
-        return f'SELECT {all_cols.list} FROM ({lq}) {self._name()} RIGHT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols
+        return f'SELECT DISTINCT {all_cols.list} FROM ({lq}) {self._name()} RIGHT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

duckdb_kernel/parser/elements/binary/RightSemiJoin.py

@@ -0,0 +1,27 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+from ...ParserError import RAParserError
+from ...util.RenamableColumnList import RenamableColumnList
+
+
+class RightSemiJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(8906), 'rsjoin'
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subqueries
+        lq, lcols = self.left.to_sql(tables)
+        rq, rcols = self.right.to_sql(tables)
+
+        # find matching columns
+        join_cols, all_cols = lcols.intersect(rcols, prefer_right=True)
+        if len(join_cols) == 0:
+            raise RAParserError('no common attributes found for right semi join', 0)
+
+        on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
+
+        # create sql
+        return f'SELECT DISTINCT {rcols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', rcols

duckdb_kernel/parser/elements/binary/__init__.py

@@ -3,7 +3,9 @@ from .Difference import Difference
 from .Intersection import Intersection
 from .Join import Join
 from .LeftOuterJoin import LeftOuterJoin
+from .LeftSemiJoin import LeftSemiJoin
 from .RightOuterJoin import RightOuterJoin
+from .RightSemiJoin import RightSemiJoin
 from .FullOuterJoin import FullOuterJoin
 from .Union import Union
 
@@ -37,7 +39,7 @@ RA_BINARY_OPERATORS = [
     [Union],
     [Intersection],
     [Join],
-    [LeftOuterJoin, RightOuterJoin, FullOuterJoin],
+    [LeftOuterJoin, RightOuterJoin, FullOuterJoin, LeftSemiJoin, RightSemiJoin],
     [Cross],
     [Division]
 ]

duckdb_kernel/tests/test_dc.py

@@ -46,6 +46,35 @@ def test_case_insensitivity():
             ]
 
 
+def test_comments():
+    for query in (
+            '{ username | users(id, username) } -- cmmnt',
+            '{ username | users(id, username) } /* cmmnt */',
+            '{ username |  /* cmmnt */ users(id, username) }',
+    ):
+        root = DCParser.parse_query(query)
+
+        # execute to test case insensitivity
+        with Connection() as con:
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'username'
+            ]
+            assert rows == [
+                ('Alice',),
+                ('Bob',),
+                ('Charlie',)
+            ]
+
+    for query in (
+        '-- comment',
+        '/* comment */'
+    ):
+        root = DCParser.parse_query(query)
+        assert root is None
+
+
 def test_simple_queries():
     with Connection() as con:
         for query in [

duckdb_kernel/tests/test_ra.py

@@ -101,10 +101,18 @@ 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 (
             r'Shows x Seasons',
+            r'Shows times Seasons',
     ):
         root = RAParser.parse_query(query)
 
@@ -235,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 (
@@ -261,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 (
@@ -286,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 (
@@ -314,6 +346,76 @@ 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 (
+            r'Users ⋉ BannedUsers',
+            r'Users lsjoin BannedUsers'
+    ):
+        root = RAParser.parse_query(query)
+
+        assert isinstance(root, BinaryOperators.LeftSemiJoin)
+        assert isinstance(root.left, RAOperand) and root.left.name == 'Users'
+        assert isinstance(root.right, RAOperand) and root.right.name == 'BannedUsers'
+
+        with Connection() as con:
+            cols, rows = con.execute_ra_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'id',
+                'username'
+            ]
+            assert rows == [
+                (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 (
+            r'Users ⋊ BannedUsers',
+            r'Users rsjoin BannedUsers'
+    ):
+        root = RAParser.parse_query(query)
+
+        assert isinstance(root, BinaryOperators.RightSemiJoin)
+        assert isinstance(root.left, RAOperand) and root.left.name == 'Users'
+        assert isinstance(root.right, RAOperand) and root.right.name == 'BannedUsers'
+
+        with Connection() as con:
+            cols, rows = con.execute_ra_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'id',
+                'bannedusername'
+            ]
+            assert rows == [
+                (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 (
@@ -589,7 +691,7 @@ def test_binary_left_to_right_evaluation_order():
     assert root.right.name == 'c'
 
     # outer join
-    root = RAParser.parse_query(r'a ⟕ b ⟕ c')
+    root = RAParser.parse_query(r'a ⟕ b ⟕ c')  # left outer, left outer
     assert isinstance(root, BinaryOperators.LeftOuterJoin)
     assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -599,7 +701,7 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟖ b ⟖ c')
+    root = RAParser.parse_query(r'a ⟖ b ⟖ c')  # right outer, right outer
     assert isinstance(root, BinaryOperators.RightOuterJoin)
     assert isinstance(root.left, BinaryOperators.RightOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -609,7 +711,7 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟗ b ⟗ c')
+    root = RAParser.parse_query(r'a ⟗ b ⟗ c')  # full outer, full outer
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.left, BinaryOperators.FullOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -619,8 +721,29 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    # mixed outer joins
-    root = RAParser.parse_query(r'a ⟕ b ⟖ c')
+    # semi join
+    root = RAParser.parse_query(r'a ⋉ b ⋉ c')  # left semi, left semi
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋊ b ⋊ c')  # right semi, right semi
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    # mixed outer and semi joins
+    root = RAParser.parse_query(r'a ⟕ b ⟖ c')  # left outer, right outer
     assert isinstance(root, BinaryOperators.RightOuterJoin)
     assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -630,7 +753,7 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟕ b ⟗ c')
+    root = RAParser.parse_query(r'a ⟕ b ⟗ c')  # left outer, full outer
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -640,7 +763,27 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟖ b ⟕ c')
+    root = RAParser.parse_query(r'a ⟕ b ⋉ c')  # left outer, left semi
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟕ b ⋊ c')  # left outer, right semi
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟖ b ⟕ c')  # right outer, left outer
     assert isinstance(root, BinaryOperators.LeftOuterJoin)
     assert isinstance(root.left, BinaryOperators.RightOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -650,7 +793,7 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟖ b ⟗ c')
+    root = RAParser.parse_query(r'a ⟖ b ⟗ c')  # right outer, full outer
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.left, BinaryOperators.RightOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -660,7 +803,27 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟗ b ⟕ c')
+    root = RAParser.parse_query(r'a ⟖ b ⋉ c')  # right outer, left semi
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟖ b ⋊ c')  # right outer, right semi
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟗ b ⟕ c')  # full outer, left outer
     assert isinstance(root, BinaryOperators.LeftOuterJoin)
     assert isinstance(root.left, BinaryOperators.FullOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -670,7 +833,7 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
-    root = RAParser.parse_query(r'a ⟗ b ⟖ c')
+    root = RAParser.parse_query(r'a ⟗ b ⟖ c')  # full outer, right outer
     assert isinstance(root, BinaryOperators.RightOuterJoin)
     assert isinstance(root.left, BinaryOperators.FullOuterJoin)
     assert isinstance(root.left.left, RAOperand)
@@ -680,6 +843,106 @@ def test_binary_left_to_right_evaluation_order():
     assert isinstance(root.right, RAOperand)
     assert root.right.name == 'c'
 
+    root = RAParser.parse_query(r'a ⟗ b ⋉ c')  # full outer, left semi
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟗ b ⋊ c')  # full outer, right semi
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋉ b ⟕ c')  # left semi, left outer
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋉ b ⟖ c')  # left semi, right outer
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋉ b ⟗ c')  # left semi, full outer
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋉ b ⋊ c')  # left semi, right semi
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋊ b ⟕ c')  # right semi, left outer
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋊ b ⟖ c')  # right semi, right outer
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋊ b ⟗ c')  # right semi, full outer
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⋊ b ⋉ c')  # right semi, left semi
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
     # cross join
     root = RAParser.parse_query(r'a x b x c')
     assert isinstance(root, BinaryOperators.Cross)
@@ -770,6 +1033,22 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Difference)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
 
+    root = RAParser.parse_query(r'a \ b ⋉ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋉ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a \ b ⋊ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋊ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightSemiJoin)
+
     # difference <-> cross
     root = RAParser.parse_query(r'a \ b x c')
     assert isinstance(root, BinaryOperators.Difference)
@@ -830,6 +1109,22 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Union)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
 
+    root = RAParser.parse_query(r'a ∪ b ⋉ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋉ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ∪ b ⋊ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋊ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightSemiJoin)
+
     # union <-> cross
     root = RAParser.parse_query(r'a ∪ b x c')
     assert isinstance(root, BinaryOperators.Union)
@@ -881,6 +1176,22 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Intersection)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
 
+    root = RAParser.parse_query(r'a ∩ b ⋉ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋉ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ∩ b ⋊ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋊ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightSemiJoin)
+
     # intersection <-> cross
     root = RAParser.parse_query(r'a ∩ b x c')
     assert isinstance(root, BinaryOperators.Intersection)
@@ -932,6 +1243,22 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
 
+    root = RAParser.parse_query(r'a ⋉ b x c')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a x b ⋉ c')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a ⋊ b x c')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a x b ⋊ c')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
+
     # join <-> division
     root = RAParser.parse_query(r'a ⋈ b ÷ c')
     assert isinstance(root, BinaryOperators.Join)
@@ -965,6 +1292,22 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
 
+    root = RAParser.parse_query(r'a ⋉ b ÷ c')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ⋉ c')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ⋊ b ÷ c')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ⋊ c')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
     # natural join <-> outer join
     root = RAParser.parse_query(r'a ⋈ b ⟕ c')
     assert isinstance(root, BinaryOperators.Join)
@@ -990,6 +1333,22 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
 
+    root = RAParser.parse_query(r'a ⋈ b ⋉ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋉ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋈ b ⋊ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightSemiJoin)
+
+    root = RAParser.parse_query(r'a ⋊ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightSemiJoin)
+
     # cross <-> division
     root = RAParser.parse_query(r'a x b ÷ c')
     assert isinstance(root, BinaryOperators.Cross)
@@ -1115,6 +1474,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
+    root = RAParser.parse_query(r'a ⋉ π [ Id ] b')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'π [ Id ] a ⋉ b')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'a ⋊ π [ Id ] b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'π [ Id ] a ⋊ b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
+
     # join <-> rename
     root = RAParser.parse_query(r'a ⋈ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Join)
@@ -1148,6 +1523,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
+    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)
+
+    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)
+
+    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)
+
+    root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⋊ b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
     # join <-> selection
     root = RAParser.parse_query(r'a ⋈ σ [ Id > 1 ] b')
     assert isinstance(root, BinaryOperators.Join)
@@ -1181,6 +1572,22 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.FullOuterJoin)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
 
+    root = RAParser.parse_query(r'a ⋉ σ [ Id > 1 ] b')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'σ [ Id > 1 ] a ⋉ b')
+    assert isinstance(root, BinaryOperators.LeftSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'a ⋊ σ [ Id > 1 ] b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'σ [ Id > 1 ] a ⋊ b')
+    assert isinstance(root, BinaryOperators.RightSemiJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
+
     # cross <-> projection
     root = RAParser.parse_query(r'a x π [ Id ] b')
     assert isinstance(root, BinaryOperators.Cross)

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.105.dist-info → jupyter_duckdb-1.4.107.dist-info}/METADATA

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

{jupyter_duckdb-1.4.105.dist-info → jupyter_duckdb-1.4.107.dist-info}/RECORD

@@ -1,7 +1,7 @@
 duckdb_kernel/__init__.py,sha256=6auU6zeJrsA4fxPSr2PYamS8fG-SMXTn5YQFXF2cseo,33
 duckdb_kernel/__main__.py,sha256=Z3GwHEBWoQjNm2Y84ijnbA0Lk66L7nsFREuqhZ_ptk0,165
 duckdb_kernel/kernel.json,sha256=_7E8Ci2FSdCvnzCjsOaue8QE8AvpS5JLQuxORO5IGtA,127
-duckdb_kernel/kernel.py,sha256=pn7I_mZj910A1o_RF2_n1fU2aIRIU0fKgvUzU0GdxUw,28386
+duckdb_kernel/kernel.py,sha256=VOQQXr0Cn3BhFvOr_Oh1f2_OFUOUgvkyz4c55mRwdgs,28484
 duckdb_kernel/db/Column.py,sha256=GM5P6sFdlYK92hiKln5-6038gIDOTxh1AYbR4kiga_w,559
 duckdb_kernel/db/Connection.py,sha256=tBXQBYt9c52RLbpl9sakNuAm0Z84--fhZ4efo8ACz-U,670
 duckdb_kernel/db/Constraint.py,sha256=1YgUHk7s8mHCVedbcuJKyXDykj7_ybbwT3Dk9p2VMis,287
@@ -24,10 +24,10 @@ duckdb_kernel/magics/MagicCommandException.py,sha256=MwuWkpA6NoCqz437urdI0RVXhbS
 duckdb_kernel/magics/MagicCommandHandler.py,sha256=hKNHRfa0BSPei4QXdVlLlbpvZIhJJ91aaT_HTMiK28E,4700
 duckdb_kernel/magics/MagicState.py,sha256=Vt_KwUwQP3446c1snSxS68Skl5AZQzrJd2Q1ETpKuKI,344
 duckdb_kernel/magics/__init__.py,sha256=ggxzDzDEsKMZzYsWw9JqYVJhciJPvPVYGV7oNo9Yp-E,239
-duckdb_kernel/parser/DCParser.py,sha256=16c1mxa494KP9OreUKQHsSQKoDGZ7NNp2u_gi_D-dkw,2293
+duckdb_kernel/parser/DCParser.py,sha256=Hjlck8k17WhlHZ_zeEoQBP1xbf94bFD7YMEELTC7BnM,2507
 duckdb_kernel/parser/LogicParser.py,sha256=_vZwE5OPRUEN8aEC_fSZAYKR_dpexqNthXog9OFHYRY,1233
 duckdb_kernel/parser/ParserError.py,sha256=qJQVloFtID1HgVDQ1Io247bODT1ic3oO9Z1ZrWR-2Mk,321
-duckdb_kernel/parser/RAParser.py,sha256=YiXjJGdofnajqDbL3UYofIEj3mXll8Hb6dc2bX58ZNY,3284
+duckdb_kernel/parser/RAParser.py,sha256=raQN-H_LmDaIekr-49alMegcnKVF2HA98EqBZo_-2Xc,3371
 duckdb_kernel/parser/__init__.py,sha256=nTmDm1ADvNPDHhVJQLxKYmArNJk6967EUXqn5AkT8FM,126
 duckdb_kernel/parser/elements/DCOperand.py,sha256=qEg_6Us4WV1eK4Bq6oUsmFt_L_x5pJPGce_wSapzIYA,1149
 duckdb_kernel/parser/elements/LogicElement.py,sha256=YasKHxWLDDP8UdyLIKbXzqIRA8-XaakjmvTj-1Iuzyc,280
@@ -40,29 +40,31 @@ duckdb_kernel/parser/elements/RAOperator.py,sha256=rtqMFBIBBqT-Bwg7Qm4WQwbDrE28N
 duckdb_kernel/parser/elements/RAUnaryOperator.py,sha256=XC1nphkSm88JaEu5V_HKnb_8JNoeBfE3EvNL4o0qh2c,654
 duckdb_kernel/parser/elements/__init__.py,sha256=t5H6SVOm3z8r6UWRYOI7HmMIuB4Yh6TLNu4_N3jg2t0,566
 duckdb_kernel/parser/elements/binary/Add.py,sha256=XGkZMfab01huk9EaI6JUfzkd2STbV1C_-TyC2guKE8I,190
-duckdb_kernel/parser/elements/binary/And.py,sha256=0jgetTG8yo5TJSeK70Kj-PI9ERyek1eyMQXX5HBxa4Y,274
+duckdb_kernel/parser/elements/binary/And.py,sha256=p6TQE49DtHlMlTkH9GqyrQVcYWsVgdIMTTCxNuNORuQ,267
 duckdb_kernel/parser/elements/binary/ArrowLeft.py,sha256=u4fZSoyT9lfvWXBwuhUl4DdjVZAOqyVIKmMVbpElLD4,203
 duckdb_kernel/parser/elements/binary/ConditionalSet.py,sha256=yzUPWO4KL8BEIQ-SiV00bdLulwHoxgoJRxebyhsRSPU,17884
-duckdb_kernel/parser/elements/binary/Cross.py,sha256=jVY3cvD6qDWZkJ7q74lFUPO2VdDt4aAjdk2YAfg-ZC4,687
+duckdb_kernel/parser/elements/binary/Cross.py,sha256=9AFfnpkMApJQulqp81hMOn7yRDZXZJCP1UUaf_-HSrg,705
 duckdb_kernel/parser/elements/binary/Difference.py,sha256=4nyHhjo09UmYjtGNC3xGQxV5ROzCGOpPkyerUN-AlF4,746
 duckdb_kernel/parser/elements/binary/Divide.py,sha256=ubekU4C1wkCTidUSMLEj5neheRx0QjhWSrsPGuXTa1g,265
 duckdb_kernel/parser/elements/binary/Division.py,sha256=FOYxmeNGljRETwygtVn102POCUmt71t9DXdAnLFCXZM,1535
 duckdb_kernel/parser/elements/binary/Equal.py,sha256=xd5eMwVwM7thXqmoBg-JSux4y6osxxznNzaChmgrnGI,192
-duckdb_kernel/parser/elements/binary/FullOuterJoin.py,sha256=W6S3rNSX0eWWtowRd6KbZ4RJqzhJUOvNt2IABmkLMJo,1383
+duckdb_kernel/parser/elements/binary/FullOuterJoin.py,sha256=fXyz-eTVO4uzLSG4wky-SKh93u0Rzuxjlp_w-MVHS-M,1550
 duckdb_kernel/parser/elements/binary/GreaterThan.py,sha256=lW7EPYjwwZ1VLZOE4ai6MBW7Zq5itsUTi_v6FxoAuU0,204
 duckdb_kernel/parser/elements/binary/GreaterThanEqual.py,sha256=gO1I3J5CZwrpqZb5Oc-WJ_fCnGylpj4YKl4s-ZAr_-4,286
 duckdb_kernel/parser/elements/binary/Intersection.py,sha256=K6NrwcLTJ1BUccifVQ2R2YHR5B71LhjuLhOalxZcM0g,757
-duckdb_kernel/parser/elements/binary/Join.py,sha256=9Z3JinEav3ulLbZZZM9DLbprloHC0oGuSm40Kf1A0mM,836
-duckdb_kernel/parser/elements/binary/LeftOuterJoin.py,sha256=qCyHLMboNjzSDK_FREtYVwZx4UYkfRcy3FMo2pEf93o,846
+duckdb_kernel/parser/elements/binary/Join.py,sha256=t_PPV7rGXob34ls27IiNkSzgB5yg-XYhuKO9xDkLqQY,992
+duckdb_kernel/parser/elements/binary/LeftOuterJoin.py,sha256=HKQIQaV7Er6WYVqpdGgeVbe_DNEUwBoxL9CC0k9ZYBQ,1013
+duckdb_kernel/parser/elements/binary/LeftSemiJoin.py,sha256=sWzG5f3H8nGxmXbJUQFVpEZHjJOAcYo5unm3VvGrTIg,994
 duckdb_kernel/parser/elements/binary/LessThan.py,sha256=gNlyAvew0VyvU8x3ol88zbdh_t9GU51Kd2P_PmHUrAc,201
 duckdb_kernel/parser/elements/binary/LessThanEqual.py,sha256=BKKXBZ4TZQ4EBxBDSNzIpFl4Oz1IGI0tI0Oj7KZUoDo,283
 duckdb_kernel/parser/elements/binary/Minus.py,sha256=1XUTXCA0GcAcCnv9nq4B9ewT0XHJ91LlZGEW1y60POA,192
 duckdb_kernel/parser/elements/binary/Multiply.py,sha256=OctlfN71izFYxIpMo09Qwq-3BmQmSh6-PNKBljMsBrg,195
 duckdb_kernel/parser/elements/binary/Or.py,sha256=e1H_BuY7TQD7XHKGqJYLOebYQvrh1euWOUsXF0FT5dY,264
-duckdb_kernel/parser/elements/binary/RightOuterJoin.py,sha256=bDxTEQ_dJZ-MUuGbU1YL69kPFR0Hdkc1fow3wxOxfAY,867
+duckdb_kernel/parser/elements/binary/RightOuterJoin.py,sha256=cakJNIor_AQRe7LBrQVu2ZN_eksVAZqSVBy1EBFahLA,1035
+duckdb_kernel/parser/elements/binary/RightSemiJoin.py,sha256=B7adyKnIRiwrqZ4wQkz81O_1e6xFkHFajTtSZz-jpS0,1015
 duckdb_kernel/parser/elements/binary/Unequal.py,sha256=1hnC1RcPMxwKKv65OL5prunGgh9cRVDmzJutmtl7gtY,269
 duckdb_kernel/parser/elements/binary/Union.py,sha256=VYTj4M2PVEhWiDwjnyP8qpVVbGvIBSVshlEt-SZYCBY,739
-duckdb_kernel/parser/elements/binary/__init__.py,sha256=BieXw51EBgIwUEK-hn4jBb1b4VKJT6sRzaxwOrSXw2A,1342
+duckdb_kernel/parser/elements/binary/__init__.py,sha256=-4ZY6vpsiyT8eDkLwyFGHJFWXIMCNYNz9ejFFcjEG5U,1451
 duckdb_kernel/parser/elements/unary/Not.py,sha256=kG0a-dp3TNjPodUMPiQ6ihtsBrbvn1iWeIPCvtyAwdo,632
 duckdb_kernel/parser/elements/unary/Projection.py,sha256=CJ-MIf1-__1ewTjNZVy5hOz3Z18CWnCDNJBxUdpWXVQ,1112
 duckdb_kernel/parser/elements/unary/Rename.py,sha256=Zr2n9EJ3nA476lND0Djz2b6493nnsbSpJ9kkEgk5B_Y,1273
@@ -76,11 +78,11 @@ duckdb_kernel/parser/util/RenamableColumn.py,sha256=LxJhFDMUv_OxYYDLwKn63QGpBRfs
 duckdb_kernel/parser/util/RenamableColumnList.py,sha256=5oEDbtvl4YfHbkxu_Ny2pc0EYnhCZsf7EeoNQvftbrU,3281
 duckdb_kernel/parser/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 duckdb_kernel/tests/__init__.py,sha256=-BoPfo1FNQKnvAYt22Ioc21dbuO67QVFaV_SmS1zQw8,2731
-duckdb_kernel/tests/test_dc.py,sha256=HPJ6JGB7yXVKIOnDHB8KwX1A16ljU0I5Y8VFcJs-KVI,15192
-duckdb_kernel/tests/test_ra.py,sha256=YEL-Jwc9tIvCT-UGOaqfXJZZH0FAok3cj9sXK59xzkQ,53172
+duckdb_kernel/tests/test_dc.py,sha256=E-PppvBU6AuLFpg0M3chFscm-2Kuv2rkz85PL2NCESc,15968
+duckdb_kernel/tests/test_ra.py,sha256=qvI5Sxkl8Sr3_E7qgMh5B1wJbMEekAXlXp1sm16uZTk,71194
 duckdb_kernel/tests/test_result_comparison.py,sha256=TQVLPKKNyV2k3i4jCfasetPfVfCzgYZr92wxQmlzPnA,3859
 duckdb_kernel/tests/test_sql.py,sha256=p7UEokoJs2xc-url7xQ4PmWKxtExrDDYnMeoyR1JD0A,1208
-duckdb_kernel/util/ResultSetComparator.py,sha256=RZDIfjJyx8-eR-HIqQlEYgZd_V1ympbszpVRF4TlA7o,2262
+duckdb_kernel/util/ResultSetComparator.py,sha256=5Pj1Vpi6laJJOK9HYiFwjrz0zj7Ogj8hYnTKIdN07wo,2831
 duckdb_kernel/util/SQL.py,sha256=-uRfa0IwEQueZNZ7vkBPczLuvm_87y4_nnMBx3FgqNk,643
 duckdb_kernel/util/TestError.py,sha256=iwlGHr9j6pFDa2cGxqGyvJ-exrFUtPJjVm_OhHi4n3g,97
 duckdb_kernel/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -94,7 +96,7 @@ duckdb_kernel/visualization/lib/__init__.py,sha256=LYi0YPtn5fXOejbLIqbt_3KzP-Xrw
 duckdb_kernel/visualization/lib/plotly-3.0.1.min.js,sha256=oy6Be7Eh6eiQFs5M7oXuPxxm9qbJXEtTpfSI93dW16Q,4653932
 duckdb_kernel/visualization/lib/ra.css,sha256=foz1v69EQ117BDduB9QyHH978PbRs2TG1kBS4VGqZbI,57
 duckdb_kernel/visualization/lib/ra.js,sha256=VzMRn55ztcd5Kfu2B6gdRPARpi8n-fvs8oNFnfp55Ec,1845
-jupyter_duckdb-1.4.105.dist-info/METADATA,sha256=uuenj_81-ZaSUb0TQ2Sy8-rcrtZsa7GHfZQ7nElAzZ0,9272
-jupyter_duckdb-1.4.105.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jupyter_duckdb-1.4.105.dist-info/top_level.txt,sha256=KvRRPMnmkQNuhyBsXoPmwyt26LRDp0O-0HN6u0Dm5jA,14
-jupyter_duckdb-1.4.105.dist-info/RECORD,,
+jupyter_duckdb-1.4.107.dist-info/METADATA,sha256=jx9R59sGi_iPrSVoOZj4WLrG6FPzReXq1UTybnh_Vyo,9272
+jupyter_duckdb-1.4.107.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jupyter_duckdb-1.4.107.dist-info/top_level.txt,sha256=KvRRPMnmkQNuhyBsXoPmwyt26LRDp0O-0HN6u0Dm5jA,14
+jupyter_duckdb-1.4.107.dist-info/RECORD,,