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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jupyter-duckdb
-Version: 1.4.106
+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.106 → jupyter_duckdb-1.4.107}/setup.py

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

{jupyter_duckdb-1.4.106 → 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.106 → 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.106 → 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.106 → jupyter_duckdb-1.4.107}/src/duckdb_kernel/parser/elements/binary/Cross.py

@@ -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.106 → 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.106 → 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.106 → 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.106 → jupyter_duckdb-1.4.107}/src/duckdb_kernel/parser/elements/binary/LeftSemiJoin.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 LeftSemiJoin(RABinaryOperator):
 
         # 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 {lcols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', lcols
+        return f'SELECT DISTINCT {lcols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', lcols

{jupyter_duckdb-1.4.106 → 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.106 → jupyter_duckdb-1.4.107}/src/duckdb_kernel/parser/elements/binary/RightSemiJoin.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 RightSemiJoin(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 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 {rcols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', rcols
+        return f'SELECT DISTINCT {rcols.list} FROM ({lq}) {self._name()} JOIN ({rq}) {self._name()} ON {on_clause}', rcols

{jupyter_duckdb-1.4.106 → 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 [

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.107}/src/duckdb_kernel/tests/test_ra.py

@@ -101,6 +101,13 @@ def test_comments():
         assert isinstance(root.left, RAOperand) and root.left.name == 'Shows'
         assert isinstance(root.right, RAOperand) and root.right.name == 'Seasons'
 
+    for query in (
+        '-- comment',
+        '/* comment */'
+    ):
+        root = RAParser.parse_query(query)
+        assert root is None
+
 
 def test_binary_operator_cross():
     for query in (
@@ -236,6 +243,14 @@ def test_binary_operator_join():
                 (2, 'Show 2', 2, 'Show 2 / Season 2')
             ]
 
+    for query in (
+            r'Shows ⋈ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_ljoin():
     for query in (
@@ -262,6 +277,14 @@ def test_binary_operator_ljoin():
                 (3, 'Charlie', None),
             ]
 
+    for query in (
+            r'Shows ⟕ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_rjoin():
     for query in (
@@ -287,6 +310,14 @@ def test_binary_operator_rjoin():
                 (4, None, 'David')
             ]
 
+    for query in (
+            r'Shows ⟖ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_fjoin():
     for query in (
@@ -315,6 +346,14 @@ def test_binary_operator_fjoin():
                 (4, None, 'David')
             ]
 
+    for query in (
+            r'Shows ⟗ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_lsjoin():
     for query in (
@@ -338,6 +377,14 @@ def test_binary_operator_lsjoin():
                 (2, 'Bob')
             ]
 
+    for query in (
+            r'Shows ⋉ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_rsjoin():
     for query in (
@@ -361,6 +408,14 @@ def test_binary_operator_rsjoin():
                 (2, 'Bob')
             ]
 
+    for query in (
+            r'Shows ⋊ Users',
+    ):
+        with pytest.raises(RAParserError):
+            with Connection() as con:
+                root = RAParser.parse_query(query)
+                con.execute_ra_return_cols(root)
+
 
 def test_binary_operator_union():
     for query in (

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.107}/src/duckdb_kernel/util/ResultSetComparator.py

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

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.107}/src/jupyter_duckdb.egg-info/PKG-INFO

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