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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.7
+Version: 1.2.101
 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.101/setup.py

@@ -0,0 +1,52 @@
+import os
+
+# configuration
+PACKAGE_VERSION = '1.2.101'
+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.101}/src/duckdb_kernel/kernel.py

@@ -54,6 +54,8 @@ class DuckDBKernel(Kernel):
             MagicCommand('all_dc').arg('value', '1').on(self._all_dc_magic),
             MagicCommand('auto_parser').disable('sql', 'ra', 'dc').code(True).on(self._auto_parser_magic),
             MagicCommand('guess_parser').arg('value', '1').on(self._guess_parser_magic),
+            MagicCommand('plotly').arg('type').arg('mapping').opt('title').result(True).on(self._plotly_magic),
+            MagicCommand('plotly_raw').opt('title').result(True).on(self._plotly_raw_magic)
         )
 
         # create placeholders for database and tests
@@ -577,6 +579,90 @@ class DuckDBKernel(Kernel):
             if e.depth > 0:
                 raise e
 
+    def _plotly_magic(self, silent: bool, cols: List, rows: List[Tuple], type: str, mapping: str, title: str = None):
+        # split mapping and handle asterisks
+        mapping = [m.strip() for m in mapping.split(',')]
+
+        for i in range(len(mapping)):
+            if mapping[i] == '*':
+                mapping = mapping[:i] + cols + mapping[i+1:]
+
+        # convert all column names to lower case
+        lower_cols = [c.lower() for c in cols]
+        lower_mapping = [m.lower() for m in mapping]
+
+        # map desired columns to indices
+        mapped_indices = {}
+        for ok, lk in zip(mapping, lower_mapping):
+            for i in range(len(lower_cols)):
+                if lk == lower_cols[i]:
+                    mapped_indices[ok] = i
+                    break
+            else:
+                raise ValueError(f'unknown column {ok}')
+
+        # map desired columns to value lists
+        mapped_values = {
+            m: [r[i] for r in rows]
+            for m, i in mapped_indices.items()
+        }
+        mapped_keys = iter(mapped_values.keys())
+
+        # get required chart type
+        match type.lower():
+            case 'scatter':
+                if len(lower_mapping) < 2: raise ValueError('scatter requires at least x and y values')
+                html = draw_scatter_chart(title,
+                                          mapped_values[next(mapped_keys)],
+                                          **{k: mapped_values[k] for k in mapped_keys})
+            case 'line':
+                if len(lower_mapping) < 2: raise ValueError('lines requires at least x and y values')
+                html = draw_line_chart(title,
+                                       mapped_values[next(mapped_keys)],
+                                       **{k: mapped_values[k] for k in mapped_keys})
+
+            case 'bar':
+                if len(lower_mapping) < 2: raise ValueError('bar requires at least x and y values')
+                html = draw_bar_chart(title,
+                                      mapped_values[next(mapped_keys)],
+                                      **{k: mapped_values[k] for k in mapped_keys})
+
+            case 'pie':
+                if len(lower_mapping) != 2: raise ValueError('pie requires labels and values')
+                html = draw_pie_chart(title,
+                                      mapped_values[next(mapped_keys)],
+                                      mapped_values[next(mapped_keys)])
+
+            case 'bubble':
+                if len(lower_mapping) != 4: raise ValueError('bubble requires x, y, size and color')
+                html = draw_bubble_chart(title,
+                                         mapped_values[next(mapped_keys)],
+                                         mapped_values[next(mapped_keys)],
+                                         mapped_values[next(mapped_keys)],
+                                         mapped_values[next(mapped_keys)])
+
+            case 'heatmap':
+                if len(lower_mapping) != 3: raise ValueError('heatmap requires x, y and z values')
+                html = draw_heatmap_chart(title,
+                                          mapped_values[next(mapped_keys)],
+                                          mapped_values[next(mapped_keys)],
+                                          mapped_values[next(mapped_keys)])
+
+            case _:
+                raise ValueError(f'unknown type: {type}')
+
+        # finally print the code
+        self.print_data(html, mime='text/html')
+
+    def _plotly_raw_magic(self, silent: bool, cols: List, rows: List[Tuple], title: str = None):
+        if len(cols) != 1 and len(rows) != 1:
+            raise ValueError(f'expected exactly one column and one row')
+
+        self.print_data(
+            draw_chart(title, rows[0][0]),
+            mime='text/html'
+        )
+
     # jupyter related functions
     def do_execute(self, code: str, silent: bool,
                    store_history: bool = True, user_expressions: dict = None, allow_stdin: bool = False,

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.101}/src/duckdb_kernel/magics/MagicCommandHandler.py

@@ -1,5 +1,5 @@
 import re
-from typing import Dict, Tuple, List, Optional
+from typing import Dict, Tuple, List
 
 from . import MagicCommand, MagicCommandException, MagicCommandCallback
 from .StringWrapper import StringWrapper
@@ -62,6 +62,11 @@ class MagicCommandHandler:
             args = [group if group is not None else default
                     for group, (_, default, _) in zip(match.groups(), magic.args)]
 
+            args = [arg[1:-1]
+                    if arg is not None and (arg[0] == '"' and arg[-1] == '"' or arg[0] == "'" and arg[-1] == "'")
+                    else arg
+                    for arg in args]
+
             if any(arg is None for arg in args):
                 raise MagicCommandException(f'could not parse parameters for command "{command}"')
 
@@ -87,6 +92,9 @@ class MagicCommandHandler:
                 value = match.group(i + 2)
                 i += 3
 
+                if value is not None and (value[0] == '"' and value[-1] == '"' or value[0] == "'" and value[-1] == "'"):
+                    value = value[1:-1]
+
                 if name is not None:
                     optionals[name.lower()] = value
 

{jupyter_duckdb-1.2.7 → jupyter_duckdb-1.2.101}/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.101}/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.101}/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.101}/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.101/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.101/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',),