jupyter-duckdb 0.9.2.1.dev202311171355__tar.gz → 0.9.2.2__tar.gz

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jupyter-duckdb
-Version: 0.9.2.1.dev202311171355
+Version: 0.9.2.2
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/setup.py

@@ -1,13 +1,12 @@
 import os
+import re
 from datetime import datetime
 
 from setuptools import setup, find_packages
 
 # version
-version = '0.9.2.1'
-
-if os.getenv('DEV') == '1':
-    version += '.dev' + datetime.now().strftime('%Y%m%d%H%M')
+version = os.getenv('PACKAGE_VERSION', '1.0')
+version = re.sub(r'[^dev0-9._]', '', version)
 
 # install requires
 install_requires = [

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/src/duckdb_kernel/kernel.py

@@ -41,7 +41,7 @@ class DuckDBKernel(Kernel):
             MagicCommand('all', 'all_rows').on(self._all_magic),
             MagicCommand('max_rows').arg('count').on(self._max_rows_magic),
             MagicCommand('query_max_rows').arg('count').on(self._query_max_rows_magic),
-            MagicCommand('schema').flag('td').on(self._schema_magic),
+            MagicCommand('schema').flag('td').opt('only').on(self._schema_magic),
             MagicCommand('ra').flag('analyze').code(True).on(self._ra_magic),
             MagicCommand('dc').code(True).on(self._dc_magic)
         )
@@ -336,7 +336,7 @@ class DuckDBKernel(Kernel):
             'max_rows': int(count) if count.lower() != 'none' else None
         }
 
-    def _schema_magic(self, silent: bool, td: bool):
+    def _schema_magic(self, silent: bool, td: bool, only: Optional[str]):
         if self._db is None:
             raise AssertionError('load a database first')
 
@@ -346,8 +346,42 @@ class DuckDBKernel(Kernel):
         # analyze tables
         tables = self._db.analyze()
 
+        # apply filter
+        if only is None:
+            table_values = list(tables.values())
+
+        else:
+            whitelist = set()
+
+            # split and strip names
+            names = [n.strip() for n in re.split(r'[, \t]', only)]
+
+            # add initial tables to result set
+            for name in names:
+                if name not in tables:
+                    raise AssertionError(f'table {name} not found')
+                whitelist.add(tables[name])
+
+            # iterate until the result set does not change
+            last_size = 0
+            while last_size < len(whitelist):
+                last_size = len(whitelist)
+
+                # everything a foreign key reaches from this group
+                for rel in list(whitelist):
+                    for fe in rel.foreign_keys:
+                        whitelist.add(fe.constraint.table)
+
+                # everything that is reachable using a foreign key
+                for rel in tables.values():
+                    for fe in rel.foreign_keys:
+                        if fe.constraint.table in whitelist:
+                            whitelist.add(rel)
+
+            table_values = list(whitelist)
+
         # create and show visualization
-        vd = SchemaDrawer(list(tables.values()))
+        vd = SchemaDrawer(table_values)
         svg = vd.to_svg(not td)
 
         self.print_data(svg)

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/src/duckdb_kernel/parser/elements/RAOperand.py

@@ -22,10 +22,13 @@ class RAOperand(RAElement):
         yield
 
     def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
-        if self.relation not in tables:
+        table_keys = {key.lower(): key for key in tables}
+        relation_lower = self.relation.lower()
+
+        if relation_lower not in table_keys:
             raise AssertionError(f'unknown relation {self.relation}')
 
-        cols = RenamableColumnList.from_iter(tables[self.name].columns)
+        cols = RenamableColumnList.from_iter(tables[table_keys[relation_lower]].columns)
         column_names = ', '.join(c.rename() for c in cols)
 
         return f'SELECT DISTINCT {column_names} FROM {self.relation}', cols

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/src/duckdb_kernel/parser/elements/binary/ConditionalSet.py

@@ -149,9 +149,9 @@ class ConditionalSet:
         # names for the attributes. We store the related operands and the join conditions.
         # Furthermore, `select_columns` contains a mapping from column names to a part of
         # a "select as" statement and joined_columns is a list of all columns that were
-        # used for joins, so the resulting sql statement do not become ambiguous if they
+        # used for joins, so the resulting sql statements do not become ambiguous if they
         # are used for filtering.
-        positive_joins: List[Tuple[str, str, List[str]]] = []
+        positive_joins: List[Tuple[str, str, Optional[List[str]]]] = []
         select_columns: Dict[str, str] = {}
         joined_columns: RenamableColumnList = RenamableColumnList()
 
@@ -206,9 +206,22 @@ class ConditionalSet:
                         already_joined.add(join_tuple)
                         discovered_joins += 1
 
-                # If no joins were discovered using this table, an exception is raised.
+                # If no common attributes were discovered using this table,
+                # a cross join is used instead.
                 if discovered_joins == 0:
-                    raise AssertionError('no common attributes found for join')
+                    # Find any other table for the cross join, so the joins
+                    # can later be constructed.
+                    for right_name, _, _ in relevant_positive:
+                        if left_name != right_name:
+                            break
+                    else:
+                        raise AssertionError(f'could not build join for relation {left_name}')
+
+                    join_tuple = min(left_name, right_name), max(left_name, right_name)
+
+                    # Store the join with a join condition that is None.
+                    positive_joins.append((left_name, right_name, None))
+                    already_joined.add(join_tuple)
 
         # Last but not least we need to include the "negative" joins. They only
         # remove tuples and never add any attributes, so we only track the
@@ -249,12 +262,17 @@ class ConditionalSet:
         for _, target_name, join_condition in positive_joins:
             if target_name not in all_positive_conditions:
                 all_positive_conditions[target_name] = []
-            all_positive_conditions[target_name].extend(join_condition)
+            if join_condition is not None:
+                all_positive_conditions[target_name].extend(join_condition)
 
-        sorted_positive_joins: List[Tuple[str, str, str]] = []
+        sorted_positive_joins: List[Tuple[str, str, Optional[str]]] = []
         while len(used_relations) < len(relevant_positive):
             for source_name, target_name, _ in positive_joins:
-                join_condition = ' AND '.join(all_positive_conditions[target_name])
+                apc = all_positive_conditions[target_name]
+                if len(apc) == 0:
+                    join_condition = None
+                else:
+                    join_condition = ' AND '.join(apc)
 
                 if source_name in used_relations and target_name not in used_relations:
                     sorted_positive_joins.append((source_name, target_name, join_condition))
@@ -308,7 +326,10 @@ class ConditionalSet:
         sql_tables = table_statements[relevant_positive[0][0]]
         for _, target_name, join_condition in sorted_positive_joins:
             target_table_stmt = table_statements[target_name]
-            sql_tables += f' JOIN {target_table_stmt} ON {join_condition}'
+            if join_condition is None:
+                sql_tables += f' CROSS JOIN {target_table_stmt}'
+            else:
+                sql_tables += f' JOIN {target_table_stmt} ON {join_condition}'
         for _, target_name, join_condition, _ in sorted_negative_joins:
             target_table_stmt = table_statements[target_name]
             sql_tables += f' LEFT JOIN {target_table_stmt} ON {join_condition}'

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/src/jupyter_duckdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jupyter-duckdb
-Version: 0.9.2.1.dev202311171355
+Version: 0.9.2.2
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/test/test_dc.py

@@ -30,6 +30,23 @@ def test_simple_queries():
             ]
 
 
+def test_asterisk_projection():
+    with Connection() as con:
+        root = DCParser.parse_query('{ * | users(id, _) }')
+        assert con.execute_dc(root) == [
+            (1,),
+            (2,),
+            (3,)
+        ]
+
+        root = DCParser.parse_query('{ * | users(id, name) }')
+        assert con.execute_dc(root) == [
+            (1, 'Alice'),
+            (2, 'Bob'),
+            (3, 'Charlie')
+        ]
+
+
 def test_conditions():
     with Connection() as con:
         for query in [
@@ -135,6 +152,24 @@ def test_joins():
                 ('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) == [
+            ('Show 1 / Season 1',),
+            ('Show 1 / Season 2',),
+            ('Show 2 / Season 1',),
+            ('Show 2 / Season 2',)
+        ]
+
+        for query in [
+            '{ s2,c5 | shows(sa1,s2) ∧ episodes(e1,e2,sb1,e4) ∧ characters(c1,e1,c3,sb1,c5) ∧ sa1=2 ∧ sa1 = sb1 ∧ e4="Show 2 / Season 1 / Episode 2" }',
+            '{ 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) == [
+                ('Show 2', 'Actor F')
+            ]
+
 
 def test_underscores():
     with Connection() as con:

{jupyter-duckdb-0.9.2.1.dev202311171355 → jupyter-duckdb-0.9.2.2}/test/test_ra.py

@@ -7,6 +7,31 @@ from duckdb_kernel.parser.elements import RAOperand, LogicElement
 from . import Connection
 
 
+def test_case_insensitivity():
+    for query in (
+        'users',
+        'Users',
+        'USERS',
+        'userS'
+    ):
+        root = RAParser.parse_query(query)
+
+        # root is an RAOperand
+        assert isinstance(root, RAOperand)
+
+        # Root's name is the relation name in whatever case
+        # it has been written.
+        assert root.name == query
+
+        # execute to test case insensitivity
+        with Connection() as con:
+            assert con.execute_ra(root) == [
+                (1, 'Alice'),
+                (2, 'Bob'),
+                (3, 'Charlie')
+            ]
+
+
 def test_binary_operator_cross():
     for query in (
             r'shows x seasons',