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

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

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

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

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.108}/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.108}/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.108}/src/duckdb_kernel/parser/RAParser.py

@@ -1,4 +1,3 @@
-from .LogicParser import LogicParser
 from .ParserError import RAParserError
 from .elements import *
 from .tokenizer import *
@@ -10,7 +9,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 +18,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]))
 
@@ -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
@@ -76,7 +75,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.108}/src/duckdb_kernel/parser/elements/LogicElement.py

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

jupyter_duckdb-1.4.108/src/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)})'

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.108}/src/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
 

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.108}/src/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

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.108}/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.108}/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.108}/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.108}/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.108}/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.108}/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.108}/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/src/duckdb_kernel/parser/elements/unary/Rename.py → jupyter_duckdb-1.4.108/src/duckdb_kernel/parser/elements/unary/AttributeRename.py

@@ -1,19 +1,19 @@
-from typing import Tuple, Dict
+from typing import Dict, Tuple
 
-from duckdb_kernel.db import Table
 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 Rename(RAUnaryOperator):
+class AttributeRename(RAUnaryOperator):
     @staticmethod
     def symbols() -> Tuple[str, ...]:
         return 'β', 'beta'
 
-    def __init__(self, target: RAElement, arg: ArrowLeft):
+    def __init__(self, target: RAElement, arg: LogicElement):
         if not isinstance(arg, ArrowLeft):
             raise AssertionError('only arrow statements allowed as parameter')
 

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.108}/src/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')
 

jupyter_duckdb-1.4.108/src/duckdb_kernel/parser/elements/unary/Rename.py

@@ -0,0 +1,93 @@
+from typing import Tuple, Dict
+
+from .. import RARelationReference
+from ..LogicElement import LogicElement
+from ..RAElement import RAElement
+from ..RAUnaryOperator import RAUnaryOperator
+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 'ρ', 'ϱ', 'rho'
+
+    @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.reference: RARelationReference = arg
+
+    @property
+    def arg(self) -> LogicElement:
+        return self.reference
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subquery
+        subquery, subcols = self.target.to_sql(tables)
+
+        # 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)
+
+        # 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
+
+    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

{jupyter_duckdb-1.4.106 → jupyter_duckdb-1.4.108}/src/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

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