jupyter-duckdb 1.4.105__tar.gz → 1.4.107__tar.gz

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/PKG-INFO

@@ -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 → jupyter_duckdb-1.4.107}/setup.py

@@ -1,7 +1,7 @@
 import os
 
 # configuration
-PACKAGE_VERSION = '1.4.105'
+PACKAGE_VERSION = '1.4.107'
 DUCKDB_VERSION = '1.4.1'
 
 DEPENDENCIES = [

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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)

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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():

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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])

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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:

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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

jupyter_duckdb-1.4.107/src/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

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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

jupyter_duckdb-1.4.107/src/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

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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]
 ]

{jupyter_duckdb-1.4.105 → jupyter_duckdb-1.4.107}/src/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 [