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

duckdb_kernel/parser/RAParser.py

@@ -1,4 +1,3 @@
-from .LogicParser import LogicParser
 from .ParserError import RAParserError
 from .elements import *
 from .tokenizer import *
@@ -55,7 +54,7 @@ class RAParser:
                     if target is None:
                         op = operator(
                             RAParser.parse_tokens(tokens[-1], depth=depth + 1),
-                            LogicParser.parse_tokens(*tokens[-i + 1:-1], depth=depth + 1)
+                            operator.parse_args(*tokens[-i + 1:-1], depth=depth + 1)
                         )
 
                     # Otherwise the handed target is this operator's
@@ -63,7 +62,7 @@ class RAParser:
                     else:
                         op = operator(
                             target,
-                            LogicParser.parse_tokens(*tokens[-i + 1:], depth=depth + 1)
+                            operator.parse_args(*tokens[-i + 1:], depth=depth + 1)
                         )
 
                     # If there are any more tokens the operator is

duckdb_kernel/parser/elements/LogicElement.py

@@ -1,5 +1,3 @@
-from typing import Iterator
-
 from ..util.RenamableColumnList import RenamableColumnList
 
 

duckdb_kernel/parser/elements/RARelationReference.py

@@ -0,0 +1,86 @@
+import re
+
+from . import RAUnaryOperator
+from .LogicElement import LogicElement
+from ..ParserError import RAParserError
+from ..tokenizer import Token
+
+
+class RARelationReference(LogicElement):
+    @staticmethod
+    def parse_tokens(operator: type[RAUnaryOperator], *tokens: Token, depth: int = 0) -> 'RARelationReference':
+        try:
+            # If we get one single token, it should be like
+            # R -> "R"
+            # [ R ] -> "R"
+            # [ R(A, B, C) ] -> "R(A, B, C)"
+            # (A, B, C) -> "(A, B, C")
+            # [ (A, B, C) ] -> "(A, B, C)"
+            if len(tokens) == 1:
+                return RARelationReference._parse_one_token(*tokens)
+
+            # If we get two tokens, it should be like
+            # R(A, B, C) -> "R", "A, B, C"
+            # R A -> "R", "A"
+            # (The latter equals R(A), but we should think about rejecting this type.)
+            elif len(tokens) == 2:
+                return RARelationReference._parse_two_tokens(*tokens)
+
+            # Otherwise, the input is malformed.
+            else:
+                raise AssertionError()
+
+        except AssertionError:
+            raise RAParserError(f'malformed input for operator {operator.symbols()[0]} {tokens=}', depth=depth)
+
+    @staticmethod
+    def _parse_one_token(token: Token) -> 'RARelationReference':
+        match = re.fullmatch(r'^\s*([A-Za-z0-9]+)?\s*(\(?((\s*[A-Za-z0-9]+\s*,\s*)*(\s*[A-Za-z0-9]+\s*,?\s*))\)?)?\s*$', token)
+        if match is None:
+            raise AssertionError()
+
+        if match.group(1) is not None:
+            relation = match.group(1).strip()
+        else:
+            relation = None
+
+        if match.group(3) is not None:
+            attributes = [b for b in (a.strip() for a in match.group(3).split(',')) if b != '']
+        else:
+            attributes = None
+
+        if relation is None and attributes is None:
+            raise AssertionError()
+
+        return RARelationReference(relation, attributes)
+
+    @staticmethod
+    def _parse_two_tokens(token1: Token, token2: Token) -> 'RARelationReference':
+        # We expect the first token to be a relation name and the second one
+        # to be a list of column names separated by commas.
+        relation = token1.strip()
+        attributes = [b for b in (a.strip() for a in token2.split(',')) if b != '']
+
+        return RARelationReference(relation, attributes)
+
+    def __init__(self, relation: str | None, attributes: list[str] | None):
+        # check duplicated attributes
+        if attributes is not None:
+            for i in range(len(attributes)):
+                for k in range(i + 1, len(attributes)):
+                    if attributes[i] == attributes[k]:
+                        raise RAParserError(f'duplicate attribute {attributes[i]}', 0)
+                    if attributes[i].lower() == attributes[k].lower():
+                        raise RAParserError(f'duplicate attribute {attributes[i]}={attributes[k]}', 0)
+
+        # store
+        self.relation: str | None = relation
+        self.attributes: list[str] | None = attributes
+
+    def __str__(self) -> str:
+        if self.relation is not None and self.attributes is None:
+            return self.relation
+        elif self.relation is None and self.attributes is not None:
+            return f'({", ".join(self.attributes)})'
+        else:
+            return f'{self.relation}({", ".join(self.attributes)})'

duckdb_kernel/parser/elements/RAUnaryOperator.py

@@ -3,9 +3,15 @@ from typing import Iterator
 from .LogicElement import LogicElement
 from .RAElement import RAElement
 from .RAOperator import RAOperator
+from ..tokenizer import Token
 
 
 class RAUnaryOperator(RAOperator):
+    @classmethod
+    def parse_args(cls: type['RAUnaryOperator'], *tokens: Token, depth: int):
+        from .. import LogicParser
+        return LogicParser.parse_tokens(*tokens, depth=depth)
+
     def __init__(self, target: RAElement):
         self.target: RAElement = target
 

duckdb_kernel/parser/elements/__init__.py

@@ -11,6 +11,7 @@ from .RAUnaryOperator import RAUnaryOperator
 from .RAOperand import RAOperand
 from .binary import RA_BINARY_OPERATORS, RA_BINARY_SYMBOLS
 from .unary import RA_UNARY_OPERATORS
+from .RARelationReference import RARelationReference
 
 from .DCOperand import DCOperand
 from .binary import DC_SET

duckdb_kernel/parser/elements/unary/AttributeRename.py

@@ -0,0 +1,39 @@
+from typing import Dict, Tuple
+
+from ..LogicElement import LogicElement
+from ..RAElement import RAElement
+from ..RAUnaryOperator import RAUnaryOperator
+from ..binary import ArrowLeft
+from ...util.RenamableColumnList import RenamableColumnList
+from ....db import Table
+
+
+class AttributeRename(RAUnaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return 'β', 'beta'
+
+    def __init__(self, target: RAElement, arg: LogicElement):
+        if not isinstance(arg, ArrowLeft):
+            raise AssertionError('only arrow statements allowed as parameter')
+
+        super().__init__(target)
+        self.arrow: ArrowLeft = arg
+
+    @property
+    def arg(self) -> LogicElement:
+        return self.arrow
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subquery
+        subquery, subcols = self.target.to_sql(tables)
+
+        # find and rename column
+        subcols.rename(str(self.arrow.right), str(self.arrow.left))
+
+        # return sql statement
+        return subquery, subcols
+
+        # We replace the "real" attribute name later anyway,
+        # so we do not need to change the sql statement here.
+        # return f'SELECT DISTINCT {subcols.list} FROM ({subquery}) {self._name()}', subcols

duckdb_kernel/parser/elements/unary/Projection.py

@@ -13,7 +13,7 @@ class Projection(RAUnaryOperator):
     def symbols() -> Tuple[str, ...]:
         return 'Π', 'π', 'pi'
 
-    def __init__(self, target: RAElement, arg: LogicOperand):
+    def __init__(self, target: RAElement, arg: LogicElement):
         if not isinstance(arg, LogicOperand):
             raise AssertionError('only argument lists allowed as parameter')
 

duckdb_kernel/parser/elements/unary/Rename.py

@@ -1,39 +1,93 @@
 from typing import Tuple, Dict
 
-from duckdb_kernel.db import Table
+from .. import RARelationReference
 from ..LogicElement import LogicElement
 from ..RAElement import RAElement
 from ..RAUnaryOperator import RAUnaryOperator
-from ..binary import ArrowLeft
+from ...ParserError import RAParserError
+from ...tokenizer import Token
 from ...util.RenamableColumnList import RenamableColumnList
+from ....db import Table
 
 
 class Rename(RAUnaryOperator):
     @staticmethod
     def symbols() -> Tuple[str, ...]:
-        return 'β', 'beta'
+        return 'ρ', 'ϱ', 'rho'
 
-    def __init__(self, target: RAElement, arg: ArrowLeft):
-        if not isinstance(arg, ArrowLeft):
-            raise AssertionError('only arrow statements allowed as parameter')
+    @classmethod
+    def parse_args(cls: type[RAUnaryOperator], *tokens: Token, depth: int):
+        from .. import RARelationReference
+        return RARelationReference.parse_tokens(cls, *tokens, depth=depth)
 
+    def __init__(self, target: RAElement, arg: RARelationReference):
         super().__init__(target)
-        self.arrow: ArrowLeft = arg
+        self.reference: RARelationReference = arg
 
     @property
     def arg(self) -> LogicElement:
-        return self.arrow
+        return self.reference
 
     def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
         # execute subquery
         subquery, subcols = self.target.to_sql(tables)
 
-        # find and rename column
-        subcols.rename(str(self.arrow.right), str(self.arrow.left))
+        # rename attributes
+        if self.reference.relation is None and self.reference.attributes is not None:
+            return self._to_sql_with_renamed_attributes(tables, subquery, subcols)
 
-        # return sql statement
+        # rename relation
+        elif self.reference.relation is not None and self.reference.attributes is None:
+            return self._to_sql_with_renamed_relation(tables, subquery, subcols)
+
+        # rename relation and attributes
+        else:
+            return self._to_sql_with_renamed_relation_and_attributes(tables, subquery, subcols)
+
+    def _to_sql_with_renamed_relation(self,
+                                      tables: Dict[str, Table],
+                                      subquery: str,
+                                      subcols: RenamableColumnList) -> Tuple[str, RenamableColumnList]:
+        # check if there are two columns with the same name
+        for i in range(len(subcols)):
+            for k in range(i + 1, len(subcols)):
+                if subcols[i].name == subcols[k].name:
+                    raise RAParserError(
+                        f'attribute {subcols[i].name} is present in both {subcols[i].table.name} and {subcols[k].table.name}',
+                        depth=0
+                    )
+
+        # add new table
+        table = Table(self.reference.relation)
+        # tables[self.reference.relation] = table
+
+        # set table for all attributes
+        for col in subcols:
+            col.table = table
+
+        # return
         return subquery, subcols
 
-        # We replace the "real" attribute name later anyway,
-        # so we do not need to change the sql statement here.
-        # return f'SELECT DISTINCT {subcols.list} FROM ({subquery}) {self._name()}', subcols
+    def _to_sql_with_renamed_attributes(self,
+                                        tables: Dict[str, Table],
+                                        subquery: str,
+                                        subcols: RenamableColumnList) -> Tuple[str, RenamableColumnList]:
+        # check if there are more names than subcols
+        if len(self.reference.attributes) > len(subcols):
+            raise RAParserError('more names than attributes', 0)
+
+        # rename columns
+        for col, new_name in zip(subcols, self.reference.attributes):
+            col.name = new_name
+
+        # return
+        return subquery, subcols
+
+    def _to_sql_with_renamed_relation_and_attributes(self,
+                                                     tables: Dict[str, Table],
+                                                     subquery: str,
+                                                     subcols: RenamableColumnList) -> Tuple[str, RenamableColumnList]:
+        subquery, subcols = self._to_sql_with_renamed_attributes(tables, subquery, subcols)
+        subquery, subcols = self._to_sql_with_renamed_relation(tables, subquery, subcols)
+
+        return subquery, subcols

duckdb_kernel/parser/elements/unary/__init__.py

@@ -1,3 +1,4 @@
+from .AttributeRename import AttributeRename
 from .Not import Not
 from .Projection import Projection
 from .Rename import Rename
@@ -10,6 +11,7 @@ LOGIC_UNARY_OPERATORS = [
 ]
 
 RA_UNARY_OPERATORS = [
+    AttributeRename,
     Projection,
     Rename,
     Selection

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
 
 
@@ -102,8 +102,8 @@ def test_comments():
         assert isinstance(root.right, RAOperand) and root.right.name == 'Seasons'
 
     for query in (
-        '-- comment',
-        '/* comment */'
+            '-- comment',
+            '/* comment */'
     ):
         root = RAParser.parse_query(query)
         assert root is None
@@ -500,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',
@@ -518,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'
 
@@ -547,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'
 
@@ -566,6 +566,162 @@ 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):
+                RAParser.parse_query(query)
+
+        # exception when using a renamed relation outside its scope
+        with pytest.raises(AssertionError):
+            root = RAParser.parse_query('ρ [ R ] (Users) x R')
+            con.execute_ra_return_cols(root)
+
+
 def test_unary_operator_selection():
     with Connection() as con:
         for query in (
@@ -637,13 +793,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
@@ -956,30 +1120,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
@@ -1369,13 +1561,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
@@ -1396,13 +1597,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
@@ -1423,13 +1633,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
@@ -1490,53 +1709,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
@@ -1597,13 +1865,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
@@ -1624,13 +1901,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
@@ -1668,8 +1954,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

@@ -82,7 +82,7 @@ class ResultSetComparator:
 
         for le, re in zip(left, right):
             if isinstance(le, float) or isinstance(re, float):
-                if abs(le - re) > 1e-6:
+                if abs(le - re) > 1e-4:
                     return False
             elif isinstance(le, date) or isinstance(re, date):
                 if str(le) != str(re):

{jupyter_duckdb-1.4.107.dist-info → jupyter_duckdb-1.4.109.dist-info}/METADATA

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

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

@@ -27,18 +27,19 @@ duckdb_kernel/magics/__init__.py,sha256=ggxzDzDEsKMZzYsWw9JqYVJhciJPvPVYGV7oNo9Y
 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=raQN-H_LmDaIekr-49alMegcnKVF2HA98EqBZo_-2Xc,3371
+duckdb_kernel/parser/RAParser.py,sha256=pNTnIRH9TzoawGPlM16JCv0KgYu0KZN2K3XC72-pL-4,3324
 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
+duckdb_kernel/parser/elements/LogicElement.py,sha256=uH-0Ax6Etp97b3VLnc24RB3rMLCbbPUrCKi2JBBVCLs,251
 duckdb_kernel/parser/elements/LogicOperand.py,sha256=B9NvriloQE5eP734dNMZBZwrdaaIfsuAmZlG1t2eMhs,1021
 duckdb_kernel/parser/elements/LogicOperator.py,sha256=lkM4TAGkXUhsO4w4PLKVA0bgCRGPQQFpNA1FcWWOW9Q,1028
 duckdb_kernel/parser/elements/RABinaryOperator.py,sha256=XN41stGc1e-a4dZ1AQVtQ3lEgjUGNt3dMfYXp85LEeE,538
 duckdb_kernel/parser/elements/RAElement.py,sha256=3qf-ZLQU5WAH_3TvEnfXUg8Y9lE2Fg01D82XutIfgjg,1661
 duckdb_kernel/parser/elements/RAOperand.py,sha256=pghnTYCrrT6MkvynJRgVFPRoMvxIGNB3FTjaq-uCpDQ,1078
 duckdb_kernel/parser/elements/RAOperator.py,sha256=rtqMFBIBBqT-Bwg7Qm4WQwbDrE28Nb74F_7XMeR3ks4,255
-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/RARelationReference.py,sha256=d3GLFnfNbQ22BzrI61jxUGXCP3RwheeZGDGCpA0CEkc,3404
+duckdb_kernel/parser/elements/RAUnaryOperator.py,sha256=TyMh5Vh6cdeL8muNRBTgnU6I1JJe97OCv5MH09cCJk0,877
+duckdb_kernel/parser/elements/__init__.py,sha256=yZj38th1ogacHU80ExPsjDeAf6dqZsw3jrkuKA7b3kg,619
 duckdb_kernel/parser/elements/binary/Add.py,sha256=XGkZMfab01huk9EaI6JUfzkd2STbV1C_-TyC2guKE8I,190
 duckdb_kernel/parser/elements/binary/And.py,sha256=p6TQE49DtHlMlTkH9GqyrQVcYWsVgdIMTTCxNuNORuQ,267
 duckdb_kernel/parser/elements/binary/ArrowLeft.py,sha256=u4fZSoyT9lfvWXBwuhUl4DdjVZAOqyVIKmMVbpElLD4,203
@@ -65,11 +66,12 @@ duckdb_kernel/parser/elements/binary/RightSemiJoin.py,sha256=B7adyKnIRiwrqZ4wQkz
 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=-4ZY6vpsiyT8eDkLwyFGHJFWXIMCNYNz9ejFFcjEG5U,1451
+duckdb_kernel/parser/elements/unary/AttributeRename.py,sha256=iMRjU2idjr22-CIR5FIupCKPtxc4WjsrzSbeTxLEQmY,1275
 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
+duckdb_kernel/parser/elements/unary/Projection.py,sha256=CcSSLWdDHk1U5JSLhY_NFTdus0BoVNDojVVdIE4SYVo,1112
+duckdb_kernel/parser/elements/unary/Rename.py,sha256=opHSTvQ8jh2yZKmTfSiS8a7vchDuvBXbv1jC77E1Mx4,3755
 duckdb_kernel/parser/elements/unary/Selection.py,sha256=TKykDMw0QGQcMFp0r7g6ye4CkjshBTNq14c7qtMkqs4,955
-duckdb_kernel/parser/elements/unary/__init__.py,sha256=48EDygy0pD7l3J_BlXGc-b7HYPaiHQa1-0Mcsj9Xzr0,270
+duckdb_kernel/parser/elements/unary/__init__.py,sha256=70Gjzfk--ua1B3YG__y-2h2hpVookLYzvrj07GA0UaA,336
 duckdb_kernel/parser/tokenizer/Token.py,sha256=gsCzgU_zLiA-yD0FWvd2qS9LQUXbivESYH-34Glffqs,2404
 duckdb_kernel/parser/tokenizer/Tokenizer.py,sha256=PWGgS7gYgpULiKGDho842UbaXuqmwEkccixuF10oi5g,5081
 duckdb_kernel/parser/tokenizer/__init__.py,sha256=EOSmfc2RJwtB5cE1Hhj1JAra97tckxxS8-legybPy60,58
@@ -79,10 +81,10 @@ duckdb_kernel/parser/util/RenamableColumnList.py,sha256=5oEDbtvl4YfHbkxu_Ny2pc0E
 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=E-PppvBU6AuLFpg0M3chFscm-2Kuv2rkz85PL2NCESc,15968
-duckdb_kernel/tests/test_ra.py,sha256=qvI5Sxkl8Sr3_E7qgMh5B1wJbMEekAXlXp1sm16uZTk,71194
+duckdb_kernel/tests/test_ra.py,sha256=-1SHhD99tZpO_YidW70LNHUHCEwv9-vBQs3-vg7DbRY,83066
 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=5Pj1Vpi6laJJOK9HYiFwjrz0zj7Ogj8hYnTKIdN07wo,2831
+duckdb_kernel/util/ResultSetComparator.py,sha256=yNca2DBJu6EaPo11cQSWFrXELdadeFlPw9Q80JgVLYU,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
@@ -96,7 +98,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.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,,
+jupyter_duckdb-1.4.109.dist-info/METADATA,sha256=HXebOLrYx4Ry7zsv5295hO1BhWyvM16WedLRff_xjBM,9272
+jupyter_duckdb-1.4.109.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jupyter_duckdb-1.4.109.dist-info/top_level.txt,sha256=KvRRPMnmkQNuhyBsXoPmwyt26LRDp0O-0HN6u0Dm5jA,14
+jupyter_duckdb-1.4.109.dist-info/RECORD,,