jupyter-duckdb 1.2.0.0__py3-none-any.whl → 1.4.111__py3-none-any.whl

duckdb_kernel/parser/elements/binary/ConditionalSet.py

@@ -8,6 +8,7 @@ from ..LogicElement import LogicElement
 from ..LogicOperand import LogicOperand
 from ..LogicOperator import LogicOperator
 from ..unary import Not
+from ...ParserError import DCParserError
 from ...tokenizer import Token
 from ...util.RenamableColumnList import RenamableColumnList
 from ....db import Table
@@ -42,8 +43,11 @@ class ConditionalSet:
 
                 # If a constant was found, we store the value and replace it with a random attribute name.
                 constant = le.names[i]
-                new_token = Token.random()
-                new_operand = DCOperand(le.relation, le.names[:i] + (new_token,) + le.names[i + 1:], skip_comma=True)
+                new_token = Token.random(constant)
+                new_operand = DCOperand(le.relation,
+                                        le.names[:i] + (new_token,) + le.names[i + 1:],
+                                        skip_comma=True,
+                                        depth=le.depth)
 
                 # We now need an equality comparison to ensure the introduced attribute is equal to the constant.
                 equality = Equal(
@@ -103,7 +107,7 @@ class ConditionalSet:
         # The default case is to return the LogicElement with not DCOperands.
         return le, []
 
-    def to_sql(self, tables: Dict[str, Table]) -> str:
+    def to_sql_with_renamed_columns(self, tables: Dict[str, Table]) -> Tuple[str, Dict[str, str]]:
         # First we have to find and remove all DCOperands from the operator tree.
         condition, dc_operands = self.split_tree(self.condition)
 
@@ -116,12 +120,13 @@ class ConditionalSet:
         underscore_regex = re.compile(r'_{1,}')
 
         for operand_i, operand in enumerate(dc_operands):
-            source_columns = tables[operand.relation].columns
+            source_columns = tables[Table.normalize_name(operand.relation)].columns
 
             # Raise an exception if the given number of operands does not match
             # the number of attributes in the relation.
             if len(source_columns) != len(operand.names):
-                raise AssertionError(f'invalid number of attributes for relation {operand.relation}')
+                raise DCParserError(f'invalid number of attributes for relation {operand.relation}',
+                                    depth=operand.depth)
 
             # Create a column list for this operand.
             rcl: RenamableColumnList = RenamableColumnList.from_iter(source_columns)
@@ -215,7 +220,8 @@ class ConditionalSet:
                         if left_name != right_name:
                             break
                     else:
-                        raise AssertionError(f'could not build join for relation {left_name}')
+                        raise DCParserError(f'could not build join for relation {left_name}',
+                                            depth=left_op.depth)
 
                     join_tuple = min(left_name, right_name), max(left_name, right_name)
 
@@ -253,7 +259,7 @@ class ConditionalSet:
 
             # If no joins were discovered using this table, an exception is raised.
             if discovered_joins == 0:
-                raise AssertionError('no common attributes found for join')
+                raise DCParserError('no common attributes found for join', depth=right_op.depth)
 
         # The joins have to be sorted in a topologic order starting from t0.
         used_relations: Set[str] = {'t0'}
@@ -287,7 +293,8 @@ class ConditionalSet:
                     break
 
             else:
-                raise AssertionError('no valid topologic order found for positive joins')
+                raise DCParserError('no valid topologic order found for positive joins',
+                                    depth=min(op.depth for _, _, op in relevant_positive))
 
         all_negative_conditions: Dict[str, List[str]] = {}
         all_negative_filters: Dict[str, List[str]] = {}
@@ -317,7 +324,8 @@ class ConditionalSet:
                     used_relations.add(target_name)
                     break
             else:
-                raise AssertionError('no valid topologic order found for negative joins')
+                raise DCParserError('no valid topologic order found for negative joins',
+                                    depth=min(op.depth for _, _, op in relevant_negative))
 
         # Build the SQL statement.
         sql_select = ', '.join(select_columns[col] if col in select_columns else col
@@ -340,4 +348,23 @@ class ConditionalSet:
 
         sql_condition = condition.to_sql(joined_columns) if condition is not None else '1=1'
 
-        return f'SELECT DISTINCT {sql_select} FROM {sql_tables} WHERE ({sql_join_filters}) AND ({sql_condition})'
+        if self.projection == ('*',):
+            sql_order = ', '.join(f'{rc.name} ASC' for rcl in rcls for rc in rcl)
+        else:
+            sql_order = ', '.join(f'{col} ASC' for col in self.projection)
+
+        sql_query = f'SELECT DISTINCT {sql_select} FROM {sql_tables} WHERE ({sql_join_filters}) AND ({sql_condition}) ORDER BY {sql_order}'
+
+        # Create a mapping from intermediate column names to constant values.
+        column_name_mapping = {
+            p: p.constant
+            for o in dc_operands
+            for p in o.names
+            if p.constant is not None
+        }
+
+        return sql_query, column_name_mapping
+
+    def to_sql(self, tables: Dict[str, Table]) -> str:
+        sql, _ = self.to_sql_with_renamed_columns(tables)
+        return sql

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

duckdb_kernel/parser/elements/binary/Difference.py

@@ -8,7 +8,7 @@ from ...util.RenamableColumnList import RenamableColumnList
 class Difference(RABinaryOperator):
     @staticmethod
     def symbols() -> Tuple[str, ...]:
-        return '\\',
+        return '-', '\\'
 
     def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
         # execute subqueries

duckdb_kernel/parser/elements/binary/Divide.py

@@ -8,7 +8,7 @@ class Divide(LogicOperator):
 
     @staticmethod
     def symbols() -> Tuple[str, ...]:
-        return '÷', '/'
+        return '/', '÷'
 
     @property
     def sql_symbol(self) -> str:

duckdb_kernel/parser/elements/binary/Division.py

@@ -27,10 +27,6 @@ class Division(RABinaryOperator):
         # 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}

duckdb_kernel/parser/elements/binary/FullOuterJoin.py

@@ -0,0 +1,40 @@
+from typing import Optional
+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
+
+
+class FullOuterJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(10199), 'fjoin', 'ojoin'
+
+    @staticmethod
+    def _coalesce(c1: RenamableColumn, c2: Optional[RenamableColumn]) -> str:
+        if c2 is not None:
+            return f'COALESCE({c1.current_name}, {c2.current_name}) AS {c1.current_name}'
+        else:
+            return c1.current_name
+
+    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 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]
+        select_clause = ', '.join(select_cols)
+
+        on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
+
+        # create sql
+        return f'SELECT DISTINCT {select_clause} FROM ({lq}) {self._name()} FULL OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

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

duckdb_kernel/parser/elements/binary/LeftOuterJoin.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 LeftOuterJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(10197), 'ljoin'
+
+    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 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 DISTINCT {all_cols.list} FROM ({lq}) {self._name()} LEFT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

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

duckdb_kernel/parser/elements/binary/RightOuterJoin.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 RightOuterJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(10198), 'rjoin'
+
+    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 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 DISTINCT {all_cols.list} FROM ({lq}) {self._name()} RIGHT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

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

duckdb_kernel/parser/elements/binary/__init__.py

@@ -2,6 +2,11 @@ from .Cross import Cross
 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
 
 from .Add import Add
@@ -30,12 +35,22 @@ LOGIC_BINARY_OPERATORS = sorted([
 ], key=lambda x: x.order, reverse=True)
 
 RA_BINARY_OPERATORS = [
-    Difference,
-    Union,
-    Intersection,
-    Join,
-    Cross,
-    Division
+    [Difference],
+    [Union],
+    [Intersection],
+    [Join],
+    [LeftOuterJoin, RightOuterJoin, FullOuterJoin, LeftSemiJoin, RightSemiJoin],
+    [Cross],
+    [Division]
+]
+
+RA_BINARY_SYMBOLS = [
+    {
+        symbol: operator
+        for operator in level
+        for symbol in operator.symbols()
+    }
+    for level in RA_BINARY_OPERATORS
 ]
 
 DC_SET = ConditionalSet

duckdb_kernel/parser/elements/unary/AttributeRename.py

@@ -0,0 +1,39 @@
+from typing import Dict, Tuple
+
+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 AttributeRename(RAUnaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return 'β', 'beta'
+
+    def __init__(self, target: RAElement, arg: LogicElement):
+        if not isinstance(arg, ArrowLeft):
+            raise AssertionError('only arrow statements allowed as parameter')
+
+        super().__init__(target)
+        self.arrow: ArrowLeft = arg
+
+    @property
+    def arg(self) -> LogicElement:
+        return self.arrow
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subquery
+        subquery, subcols = self.target.to_sql(tables)
+
+        # find and rename column
+        subcols.rename(str(self.arrow.right), str(self.arrow.left))
+
+        # return sql statement
+        return subquery, subcols
+
+        # We replace the "real" attribute name later anyway,
+        # so we do not need to change the sql statement here.
+        # return f'SELECT DISTINCT {subcols.list} FROM ({subquery}) {self._name()}', subcols

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')
 

duckdb_kernel/parser/elements/unary/Rename.py

@@ -1,39 +1,93 @@
 from typing import Tuple, Dict
 
-from duckdb_kernel.db import Table
+from .. import RARelationReference
 from ..LogicElement import LogicElement
 from ..RAElement import RAElement
 from ..RAUnaryOperator import RAUnaryOperator
-from ..binary import ArrowLeft
+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 'β', 'beta'
+        return 'ρ', 'ϱ', 'rho'
 
-    def __init__(self, target: RAElement, arg: ArrowLeft):
-        if not isinstance(arg, ArrowLeft):
-            raise AssertionError('only arrow statements allowed as parameter')
+    @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.arrow: ArrowLeft = arg
+        self.reference: RARelationReference = arg
 
     @property
     def arg(self) -> LogicElement:
-        return self.arrow
+        return self.reference
 
     def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
         # execute subquery
         subquery, subcols = self.target.to_sql(tables)
 
-        # find and rename column
-        subcols.rename(str(self.arrow.right), str(self.arrow.left))
+        # 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)
 
-        # return sql statement
+        # 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
 
-        # We replace the "real" attribute name later anyway,
-        # so we do not need to change the sql statement here.
-        # return f'SELECT DISTINCT {subcols.list} FROM ({subquery}) {self._name()}', 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

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

duckdb_kernel/parser/tokenizer/Token.py

@@ -1,8 +1,9 @@
+from typing import Optional
 from uuid import uuid4
 
 
 class Token(str):
-    def __new__(cls, value: str):
+    def __new__(cls, value: str, constant: 'Token' = None):
         while True:
             # strip whitespaces
             value = value.strip()
@@ -38,20 +39,40 @@ class Token(str):
 
         return super().__new__(cls, value)
 
+    def __init__(self, value: str, constant: 'Token' = None):
+        self.constant: Optional[Token] = constant
+
     @staticmethod
-    def random() -> 'Token':
-        return Token('__' + str(uuid4()).replace('-', '_'))
+    def random(constant: 'Token' = None) -> 'Token':
+        return Token('__' + str(uuid4()).replace('-', '_'), constant)
 
     @property
     def empty(self) -> bool:
         return len(self) == 0
 
+    @property
+    def is_temporary(self) -> bool:
+        return self.startswith('__')
+
     @property
     def is_constant(self) -> bool:
         return ((self[0] == '"' and self[-1] == '"') or
                 (self[0] == "'" and self[-1] == "'") or
                 self.replace('.', '', 1).isnumeric())
 
+    @property
+    def no_quotes(self) -> str:
+        quotes = ('"', "'")
+
+        if self[0] in quotes and self[-1] in quotes:
+            return self[1:-1]
+        if self[0] in quotes:
+            return self[1:]
+        if self[-1] in quotes:
+            return self[:-1]
+        else:
+            return self
+
     @property
     def single_quotes(self) -> str:
         # TODO Is this comparison useless because tokens are cleaned automatically?