jupyter-duckdb 1.2.0.6__py3-none-any.whl → 1.2.100__py3-none-any.whl

duckdb_kernel/parser/RAParser.py

@@ -19,10 +19,14 @@ class RAParser:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
         # binary operators
-        for operator in RA_BINARY_OPERATORS:
+        for operator_symbols in RA_BINARY_SYMBOLS:
             # iterate tokens and match symbol
             for i in range(1, len(tokens) + 1):
-                if tokens[-i].lower() in operator.symbols():
+                lower_token = tokens[-i].lower()
+
+                if lower_token in operator_symbols:
+                    operator = operator_symbols[lower_token]
+
                     # raise error if left or right operand missing
                     if i == 1:
                         raise RAParserError(f'right operand missing after {tokens[-i]}', depth)

duckdb_kernel/parser/elements/__init__.py

@@ -9,7 +9,7 @@ from .RAOperator import RAOperator
 from .RABinaryOperator import RABinaryOperator
 from .RAUnaryOperator import RAUnaryOperator
 from .RAOperand import RAOperand
-from .binary import RA_BINARY_OPERATORS
+from .binary import RA_BINARY_OPERATORS, RA_BINARY_SYMBOLS
 from .unary import RA_UNARY_OPERATORS
 
 from .DCOperand import DCOperand

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,37 @@
+from typing import Optional
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+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)
+
+        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 {select_clause} FROM ({lq}) {self._name()} FULL OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

duckdb_kernel/parser/elements/binary/LeftOuterJoin.py

@@ -0,0 +1,24 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+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)
+
+        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

duckdb_kernel/parser/elements/binary/RightOuterJoin.py

@@ -0,0 +1,24 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+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)
+
+        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

duckdb_kernel/parser/elements/binary/__init__.py

@@ -2,6 +2,9 @@ from .Cross import Cross
 from .Difference import Difference
 from .Intersection import Intersection
 from .Join import Join
+from .LeftOuterJoin import LeftOuterJoin
+from .RightOuterJoin import RightOuterJoin
+from .FullOuterJoin import FullOuterJoin
 from .Union import Union
 
 from .Add import Add
@@ -30,12 +33,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],
+    [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/util/RenamableColumnList.py

@@ -73,18 +73,26 @@ class RenamableColumnList(list[RenamableColumn]):
 
         return RenamableColumnList(cols.values())
 
-    def intersect(self, other: 'RenamableColumnList') \
+    def intersect(self, other: 'RenamableColumnList', prefer_right: bool = False) \
             -> Tuple[List[Tuple[RenamableColumn, RenamableColumn]], 'RenamableColumnList']:
         self_cols: Dict[str, RenamableColumn] = {col.name: col for col in self}
         other_cols: Dict[str, RenamableColumn] = {col.name: col for col in other}
 
+        replacements: Dict[RenamableColumn, RenamableColumn] = {}
         intersection: List[Tuple[RenamableColumn, RenamableColumn]] = []
+
         for name in tuple(self_cols.keys()):
             if name in other_cols:
+                if prefer_right:
+                    replacements[self_cols[name]] = other_cols[name]
+
                 intersection.append((self_cols[name], other_cols[name]))
                 del other_cols[name]
 
         # if len(intersection) == 0:
         #     raise AssertionError('no common attributes found for join')
 
-        return intersection, RenamableColumnList(self_cols.values(), other_cols.values())
+        return intersection, RenamableColumnList(
+            (replacements.get(x, x) for x in self_cols.values()),
+            other_cols.values()
+        )

duckdb_kernel/tests/__init__.py

@@ -0,0 +1,76 @@
+import os
+from typing import Dict, List, Tuple
+
+from duckdb_kernel.db import Connection as DB, Table
+from duckdb_kernel.db.error import EmptyResultError
+from duckdb_kernel.parser.elements import RAElement
+from duckdb_kernel.parser.elements.binary import ConditionalSet
+
+with open('examples/tables.sql', 'r', encoding='utf-8') as file:
+    EXAMPLE_STMTS = [stmt
+                     for stmt in file.read().split(';')
+                     if stmt.strip()]
+
+
+class Connection:
+    def __enter__(self):
+        db_type = os.environ.get('DB_TYPE')
+        if db_type == 'postgres':
+            host = os.environ.get('POSTGRES_HOST', 'localhost')
+            port = int(os.environ.get('POSTGRES_PORT', 5432))
+            username = os.environ.get('POSTGRES_USER', 'postgres')
+            password = os.environ.get('POSTGRES_PASSWORD', 'postgres')
+
+            from duckdb_kernel.db.implementation.postgres import Connection as PostgreSQL
+            self.con: DB = PostgreSQL(host, port, username, password, None)
+        elif db_type == 'sqlite':
+            from duckdb_kernel.db.implementation.sqlite import Connection as SQLite
+            self.con: DB = SQLite(':memory:')
+        else:
+            from duckdb_kernel.db.implementation.duckdb import Connection as DuckDB
+            self.con: DB = DuckDB(':memory:')
+
+        for stmt in EXAMPLE_STMTS:
+            try:
+                self.con.execute(stmt)
+            except EmptyResultError:
+                pass
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.con.close()
+
+    @property
+    def tables(self) -> Dict[str, Table]:
+        return self.con.analyze()
+
+    def execute_sql_return_cols(self, query: str) -> Tuple[List, List]:
+        return self.con.execute(query)
+
+    def execute_sql(self, query: str) -> List:
+        _, rows = self.execute_sql_return_cols(query)
+        return rows
+
+    def execute_ra_return_cols(self, root: RAElement) -> Tuple[List, List]:
+        sql = root.to_sql_with_renamed_columns(self.tables)
+        cols, rows = self.execute_sql_return_cols(sql)
+
+        return cols, sorted(rows, key=lambda t: tuple(-1 if x is None else x for x in t))
+
+    def execute_ra(self, root: RAElement) -> List:
+        _, rows = self.execute_ra_return_cols(root)
+        return rows
+
+    def execute_dc_return_cols(self, root: ConditionalSet) -> Tuple[List, List]:
+        sql, cnm = root.to_sql_with_renamed_columns(self.tables)
+        cols, rows = self.execute_sql_return_cols(sql)
+
+        return [cnm.get(c, c) for c in cols], sorted(rows)
+
+    def execute_dc(self, root: ConditionalSet) -> List:
+        _, rows = self.execute_dc_return_cols(root)
+        return rows
+
+
+__all__ = ['Connection']