jupyter-duckdb 0.9.2.5__tar.gz → 0.9.2.6__tar.gz

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jupyter-duckdb
-Version: 0.9.2.5
+Version: 0.9.2.6
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs
@@ -247,6 +247,7 @@ The supported operations are:
 - Difference `\`
 - Natural Join `⋈`
 - Cross Product `×`
+- Division `÷`
 
 The Dockerfile also installs the Jupyter Lab plugin
 [jupyter-ra-extension](https://pypi.org/project/jupyter-ra-extension/). It adds

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/README.md

@@ -229,6 +229,7 @@ The supported operations are:
 - Difference `\`
 - Natural Join `⋈`
 - Cross Product `×`
+- Division `÷`
 
 The Dockerfile also installs the Jupyter Lab plugin
 [jupyter-ra-extension](https://pypi.org/project/jupyter-ra-extension/). It adds

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/src/duckdb_kernel/parser/elements/binary/Difference.py

@@ -17,7 +17,7 @@ class Difference(RABinaryOperator):
 
         # check number of columns
         if len(lcols) != len(rcols):
-            raise AssertionError(f'difference can only be applied to relations with the same number of columns')
+            raise AssertionError('difference can only be applied to relations with the same number of columns')
 
         # create sql
         return f'{lq} EXCEPT {rq}', lcols

jupyter-duckdb-0.9.2.6/src/duckdb_kernel/parser/elements/binary/Division.py

@@ -0,0 +1,48 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+from ...util.RenamableColumnList import RenamableColumnList
+
+
+class Division(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return '÷', ':'
+
+    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)
+
+        # difference and intersection preparation
+        diff_cols = lcols.difference(rcols)
+        diff_name = ', '.join(c.current_name for c in diff_cols)
+
+        inter_cols, p = lcols.intersect(rcols)
+        if len(inter_cols) == 0:
+            raise AssertionError('divison can only be applied to relations with common columns')
+
+        inter_name = ' AND '.join(f'{r.current_name} = {l.current_name}' for l, r in inter_cols)
+        # inter_name_left = ', '.join(l.current_name for l, _ in inter_cols)
+        inter_name_right = ', '.join(r.current_name for _, r in inter_cols)
+
+        print('-', diff_name)
+        print(inter_name)
+        print(inter_name_right)
+
+        # create sql
+        return f'''
+            SELECT {diff_name}
+            FROM ({lq}) {self._name()}
+            WHERE EXISTS (
+                SELECT {inter_name_right}
+                FROM ({rq}) {self._name()}
+                WHERE {inter_name}
+            )
+            GROUP BY {diff_name}
+            HAVING COUNT(*) = (
+                SELECT COUNT(*)
+                FROM ({rq}) {self._name()}
+            )
+        ''', diff_cols

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/src/duckdb_kernel/parser/elements/binary/__init__.py

@@ -9,6 +9,7 @@ from .And import And
 from .ArrowLeft import ArrowLeft
 from .ConditionalSet import ConditionalSet
 from .Divide import Divide
+from .Division import Division
 from .Equal import Equal
 from .GreaterThan import GreaterThan
 from .GreaterThanEqual import GreaterThanEqual
@@ -33,7 +34,8 @@ RA_BINARY_OPERATORS = [
     Union,
     Intersection,
     Join,
-    Cross
+    Cross,
+    Division
 ]
 
 DC_SET = ConditionalSet

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/src/duckdb_kernel/parser/util/RenamableColumnList.py

@@ -61,6 +61,18 @@ class RenamableColumnList(list[RenamableColumn]):
 
         return RenamableColumnList(cols.values())
 
+    def difference(self, other: 'RenamableColumnList') -> 'RenamableColumnList':
+        cols: Dict[str, RenamableColumn] = {}
+
+        for col in self:
+            cols[col.name] = col
+
+        for col in other:
+            if col.name in cols:
+                del cols[col.name]
+
+        return RenamableColumnList(cols.values())
+
     def intersect(self, other: 'RenamableColumnList') \
             -> Tuple[List[Tuple[RenamableColumn, RenamableColumn]], 'RenamableColumnList']:
         self_cols: Dict[str, RenamableColumn] = {col.name: col for col in self}

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/src/jupyter_duckdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jupyter-duckdb
-Version: 0.9.2.5
+Version: 0.9.2.6
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs
@@ -247,6 +247,7 @@ The supported operations are:
 - Difference `\`
 - Natural Join `⋈`
 - Cross Product `×`
+- Division `÷`
 
 The Dockerfile also installs the Jupyter Lab plugin
 [jupyter-ra-extension](https://pypi.org/project/jupyter-ra-extension/). It adds

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/src/jupyter_duckdb.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ src/duckdb_kernel/parser/elements/binary/ConditionalSet.py
 src/duckdb_kernel/parser/elements/binary/Cross.py
 src/duckdb_kernel/parser/elements/binary/Difference.py
 src/duckdb_kernel/parser/elements/binary/Divide.py
+src/duckdb_kernel/parser/elements/binary/Division.py
 src/duckdb_kernel/parser/elements/binary/Equal.py
 src/duckdb_kernel/parser/elements/binary/GreaterThan.py
 src/duckdb_kernel/parser/elements/binary/GreaterThanEqual.py

{jupyter-duckdb-0.9.2.5 → jupyter-duckdb-0.9.2.6}/test/test_ra.py

@@ -9,10 +9,10 @@ from . import Connection
 
 def test_case_insensitivity():
     for query in (
-        'users',
-        'Users',
-        'USERS',
-        'userS'
+            'users',
+            'Users',
+            'USERS',
+            'userS'
     ):
         root = RAParser.parse_query(query)
 
@@ -72,6 +72,27 @@ def test_binary_operator_difference():
             ]
 
 
+def test_binary_operator_division():
+    for query in (
+            r'π [show_id, season_number, episode_number] (episodes) ÷ π [ episode_number ] (σ [ show_id = 1 AND season_number = 1 ] (episodes))',
+            r'π [show_id, season_number, episode_number] (episodes) : π [ episode_number ] (σ [ show_id = 1 AND season_number = 1 ] (episodes))',
+    ):
+        root = RAParser.parse_query(query)
+
+        assert isinstance(root, BinaryOperators.Division)
+        assert isinstance(root.left, UnaryOperators.Projection)
+        assert isinstance(root.left.target, RAOperand) and root.left.target.name == 'episodes'
+        assert isinstance(root.right, UnaryOperators.Projection)
+        assert isinstance(root.right.target, UnaryOperators.Selection)
+        assert isinstance(root.right.target.target, RAOperand) and root.right.target.target.name == 'episodes'
+
+        with Connection() as con:
+            assert con.execute_ra(root) == [
+                (1, 1),
+                (1, 2)
+            ]
+
+
 def test_binary_operator_intersection():
     for query in (
             r'users ∩ banned_users',
@@ -325,6 +346,15 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Difference)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
 
+    # difference <-> division
+    root = RAParser.parse_query(r'a \ b ÷ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
     # union <-> intersection
     root = RAParser.parse_query(r'a ∪ b ∩ c')
     assert isinstance(root, BinaryOperators.Union)
@@ -352,6 +382,15 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Union)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
 
+    # union <-> division
+    root = RAParser.parse_query(r'a ∪ b ÷ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
     # intersection <-> join
     root = RAParser.parse_query(r'a ∩ b ⋈ c')
     assert isinstance(root, BinaryOperators.Intersection)
@@ -370,6 +409,15 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Intersection)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
 
+    # intersection <-> division
+    root = RAParser.parse_query(r'a ∩ b ÷ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
     # join <-> cross
     root = RAParser.parse_query(r'a ⋈ b x c')
     assert isinstance(root, BinaryOperators.Join)
@@ -379,6 +427,24 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     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)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
+    # cross <-> division
+    root = RAParser.parse_query(r'a x b ÷ c')
+    assert isinstance(root, BinaryOperators.Cross)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b x c')
+    assert isinstance(root, BinaryOperators.Cross)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
 
 def test_mixed_evaluation_order():
     # difference <-> projection
@@ -516,6 +582,33 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Cross)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
 
+    # division <-> projection
+    root = RAParser.parse_query(r'a ÷ π [ id ] b')
+    assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'π [ id ] a ÷ b')
+    assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
+
+    # division <-> 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)
+
+    root = RAParser.parse_query(r'β [ id2 ← id ] a ÷ b')
+    assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    # division <-> selection
+    root = RAParser.parse_query(r'a ÷ σ [ id > 1 ] b')
+    assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'σ [ id > 1 ] a ÷ b')
+    assert isinstance(root, BinaryOperators.Division)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
+
 
 def test_special_queries():
     with Connection() as con: