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

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

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

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

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

{jupyter_duckdb-1.4.107 → jupyter_duckdb-1.4.109}/src/duckdb_kernel/parser/elements/LogicElement.py

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

jupyter_duckdb-1.4.109/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.107 → jupyter_duckdb-1.4.109}/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.107 → jupyter_duckdb-1.4.109}/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.107/src/duckdb_kernel/parser/elements/unary/Rename.py → jupyter_duckdb-1.4.109/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.107 → jupyter_duckdb-1.4.109}/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.109/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.107 → jupyter_duckdb-1.4.109}/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