jupyter-duckdb 1.2.7__tar.gz → 1.2.100__tar.gz

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.7
+Version: 1.2.100
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs
@@ -14,7 +14,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: jupyter
 Requires-Dist: graphviz==0.20.3
 Requires-Dist: checkmarkandcross
-Requires-Dist: duckdb==1.2.0
+Requires-Dist: duckdb==1.2.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

jupyter_duckdb-1.2.100/setup.py

@@ -0,0 +1,52 @@
+import os
+
+# configuration
+PACKAGE_VERSION = '1.2.100'
+DUCKDB_VERSION = '1.2.1'
+
+DEPENDENCIES = [
+    'jupyter',
+    'graphviz==0.20.3',
+    'checkmarkandcross'
+]
+
+if os.getenv('SQLITE') != '1' and os.getenv('DUCKDB') != '0':
+    DEPENDENCIES += [f'duckdb=={DUCKDB_VERSION}']
+
+# main setup
+if __name__ == '__main__':
+    from setuptools import setup, find_namespace_packages
+
+    # load README.md as long_description
+    with open('README.md', 'r', encoding='utf-8') as file:
+        long_description = file.read()
+
+    # main setup call
+    setup(
+        name='jupyter-duckdb',
+        version=PACKAGE_VERSION,
+        python_requires='>=3.10',
+        install_requires=DEPENDENCIES,
+        author='Eric Tröbs',
+        author_email='eric.troebs@tu-ilmenau.de',
+        description='a basic wrapper kernel for DuckDB',
+        long_description=long_description,
+        long_description_content_type='text/markdown',
+        url='https://github.com/erictroebs/jupyter-duckdb',
+        project_urls={
+            'Bug Tracker': 'https://github.com/erictroebs/jupyter-duckdb/issues',
+        },
+        classifiers=[
+            'Programming Language :: Python :: 3',
+            'License :: OSI Approved :: MIT License',
+            'Operating System :: OS Independent',
+        ],
+        package_dir={'': 'src'},
+        packages=find_namespace_packages(where='src'),
+        include_package_data=True,
+        package_data={
+            'duckdb_kernel': [
+                'kernel.json'
+            ]
+        }
+    )

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.100}/src/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

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.100}/src/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:

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.100}/src/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}

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.100}/src/duckdb_kernel/parser/elements/binary/FullOuterJoin.py

@@ -1,7 +1,9 @@
+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
 
 
@@ -10,6 +12,13 @@ class FullOuterJoin(RABinaryOperator):
     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)
@@ -19,9 +28,7 @@ class FullOuterJoin(RABinaryOperator):
         join_cols, all_cols = lcols.intersect(rcols)
 
         replacements = {c1: c2 for c1, c2 in join_cols}
-        select_cols = [
-            f'COALESCE({c.current_name}, {replacements.get(c).current_name})' if c in replacements else c.current_name
-            for c in all_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)

jupyter_duckdb-1.2.100/src/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']

{jupyter_duckdb-1.2.7/test → jupyter_duckdb-1.2.100/src/duckdb_kernel/tests}/test_dc.py

@@ -13,7 +13,12 @@ def test_case_insensitivity():
 
         # execute to test case insensitivity
         with Connection() as con:
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'username'
+            ]
+            assert rows == [
                 ('Alice',),
                 ('Bob',),
                 ('Charlie',)
@@ -29,7 +34,12 @@ def test_case_insensitivity():
 
         # execute to test case insensitivity
         with Connection() as con:
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'username'
+            ]
+            assert rows == [
                 ('Alice',),
                 ('Bob',),
                 ('Charlie',)
@@ -46,7 +56,12 @@ def test_simple_queries():
             'id | Users (id ,_)',
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'id'
+            ]
+            assert rows == [
                 (1,),
                 (2,),
                 (3,)
@@ -57,7 +72,13 @@ def test_simple_queries():
             '{ id,name | Users(id, name) }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'id',
+                'name'
+            ]
+            assert rows == [
                 (1, 'Alice'),
                 (2, 'Bob'),
                 (3, 'Charlie')
@@ -67,14 +88,25 @@ def test_simple_queries():
 def test_asterisk_projection():
     with Connection() as con:
         root = DCParser.parse_query('{ * | Users(id, _) }')
-        assert con.execute_dc(root) == [
+        cols, rows = con.execute_dc_return_cols(root)
+
+        assert [c.lower() for c in cols] == [
+            'id'
+        ]
+        assert rows == [
             (1,),
             (2,),
             (3,)
         ]
 
         root = DCParser.parse_query('{ * | Users(id, name) }')
-        assert con.execute_dc(root) == [
+        cols, rows = con.execute_dc_return_cols(root)
+
+        assert [c.lower() for c in cols] == [
+            'id',
+            'name'
+        ]
+        assert rows == [
             (1, 'Alice'),
             (2, 'Bob'),
             (3, 'Charlie')
@@ -89,7 +121,12 @@ def test_conditions():
             '{ name | Users(id, name) ∧ (id = 2 ∨ id = 3) }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'name'
+            ]
+            assert rows == [
                 ('Bob',),
                 ('Charlie',)
             ]
@@ -99,7 +136,12 @@ def test_conditions():
             '{ id | Users(id, name) ∧ name > "B" ∧ name < "C" }',
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'id'
+            ]
+            assert rows == [
                 (2,)
             ]
 
@@ -111,7 +153,12 @@ def test_shortcut_conditions():
             '{ name | Users(1, name) }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'name'
+            ]
+            assert rows == [
                 ('Alice',)
             ]
 
@@ -119,7 +166,12 @@ def test_shortcut_conditions():
             '{ season_name | Seasons(1, 1, season_name) }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'season_name'
+            ]
+            assert rows == [
                 ('Show 1 / Season 1',)
             ]
 
@@ -128,7 +180,13 @@ def test_shortcut_conditions():
             '{ sname, ename | Seasons(snum, 2, sname) ∧ Episodes(enum, snum, 2, ename) }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'sname',
+                'ename'
+            ]
+            assert rows == [
                 ('Show 2 / Season 1', 'Show 2 / Season 1 / Episode 1'),
                 ('Show 2 / Season 1', 'Show 2 / Season 1 / Episode 2'),
                 ('Show 2 / Season 1', 'Show 2 / Season 1 / Episode 3'),
@@ -146,7 +204,12 @@ def test_joins():
             '{ sename | Shows(shid, shname) ∧ Seasons(senum, shid, sename) }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'sename'
+            ]
+            assert rows == [
                 ('Show 1 / Season 1',),
                 ('Show 1 / Season 2',),
                 ('Show 2 / Season 1',),
@@ -158,7 +221,12 @@ def test_joins():
             '{ sename | Seasons(senum, shid, sename) ∧ Shows(shid, "Show 1") }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'sename'
+            ]
+            assert rows == [
                 ('Show 1 / Season 1',),
                 ('Show 1 / Season 2',)
             ]
@@ -168,7 +236,13 @@ def test_joins():
             '{ sname, ename | Seasons(snum, shid, sname) ∧ Episodes(enum, snum, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'sname',
+                'ename'
+            ]
+            assert rows == [
                 ('Show 2 / Season 1', 'Show 2 / Season 1 / Episode 1'),
                 ('Show 2 / Season 1', 'Show 2 / Season 1 / Episode 2'),
                 ('Show 2 / Season 1', 'Show 2 / Season 1 / Episode 3'),
@@ -183,13 +257,24 @@ def test_joins():
             '{ s2,c5 | Shows(s1,s2) ∧ Episodes(e1,e2,s1,e4) ∧ Characters(c1,e1,c3,s1,c5) ∧ s1=2 ∧ e4="Show 2 / Season 1 / Episode 2" }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                's2',
+                'c5'
+            ]
+            assert rows == [
                 ('Show 2', 'Actor F')
             ]
 
         # cross join
         root = DCParser.parse_query('{ sename | Shows(shid1, shname) ∧ Seasons(senum, shid2, sename) ∧ shid1 = shid2 }')
-        assert con.execute_dc(root) == [
+        cols, rows = con.execute_dc_return_cols(root)
+
+        assert [c.lower() for c in cols] == [
+            'sename'
+        ]
+        assert rows == [
             ('Show 1 / Season 1',),
             ('Show 1 / Season 2',),
             ('Show 2 / Season 1',),
@@ -201,7 +286,13 @@ def test_joins():
             '{ s2,c5 | Shows(sa1,s2) ∧ Episodes(e1,e2,sb1,e4) ∧ Characters(c1,e1,c3,sc1,c5) ∧ sa1=2 ∧ sa1 = sb1 ∧ sb1 = sc1 ∧ e4="Show 2 / Season 1 / Episode 2" }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                's2',
+                'c5'
+            ]
+            assert rows == [
                 ('Show 2', 'Actor F')
             ]
 
@@ -213,7 +304,14 @@ def test_disjunction_joins():
             "{ enum, snum, sid | Episodes(enum, snum, sid, ename) ∧ (Characters(cname1, enum, snum, sid, _) ∧ cname1 = 'Character B' ∨ Characters(cname2, enum, snum, sid, _) ∧ cname2 = 'Character D') }",
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'enum',
+                'snum',
+                'sid'
+            ]
+            assert rows == [
                 (1, 1, 1),
                 (2, 1, 1)
             ]
@@ -225,7 +323,13 @@ def test_cross_join():
             "{ cname1, cname2 | Characters(cname1, _, _, 2, _) ∧ Characters(cname2, _, _, 2, _) }",
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'cname1',
+                'cname2'
+            ]
+            assert rows == [
                 ('Character E', 'Character E'),
                 ('Character E', 'Character F'),
                 ('Character F', 'Character E'),
@@ -243,7 +347,12 @@ def test_underscores():
             '{ ename | Seasons(snum, shid, sname) ∧ Episodes(_, __, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'ename'
+            ]
+            assert rows == [
                 ('Show 2 / Season 1 / Episode 1',),
                 ('Show 2 / Season 1 / Episode 2',),
                 ('Show 2 / Season 1 / Episode 3',),
@@ -258,7 +367,12 @@ def test_underscores():
             '{ ename | Seasons(snum, shid, sname) ∧ Episodes(_, _, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'ename'
+            ]
+            assert rows == [
                 ('Show 2 / Season 1 / Episode 1',),
                 ('Show 2 / Season 1 / Episode 2',),
                 ('Show 2 / Season 1 / Episode 3',),
@@ -274,7 +388,12 @@ def test_underscores():
             '{ ename | Seasons(_, shid, __) ∧ Episodes(_, __, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
-            assert con.execute_dc(root) == [
+            cols, rows = con.execute_dc_return_cols(root)
+
+            assert [c.lower() for c in cols] == [
+                'ename'
+            ]
+            assert rows == [
                 ('Show 2 / Season 1 / Episode 1',),
                 ('Show 2 / Season 1 / Episode 2',),
                 ('Show 2 / Season 1 / Episode 3',),