jupyter-duckdb 1.2.0.0__tar.gz → 1.2.0.2__tar.gz

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/PKG-INFO

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

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/db/Table.py

@@ -14,11 +14,19 @@ class Table:
         self.unique_keys: List[Constraint] = []
         self.foreign_keys: List[ForeignKey] = []
 
+    @staticmethod
+    def normalize_name(name: str) -> str:
+        return name.lower()
+
     @property
     def id(self) -> str:
         name = re.sub(r'[^A-Za-z]', '_', self.name)
         return f'table_{name}'
 
+    @property
+    def normalized_name(self) -> str:
+        return self.normalize_name(self.name)
+
     def get_column(self, name: str) -> "Column":
         for column in self.columns:
             if column.name == name:

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/db/implementation/duckdb/Connection.py

@@ -59,7 +59,7 @@ class Connection(Base):
                     WHERE table_type == 'BASE TABLE'
                 ''').fetchall():
             table = Table(table_name)
-            tables[table_name] = table
+            tables[table.normalized_name] = table
 
         # Get column names and data types for each table.
         for table_name, column_name, data_type, is_nullable in self.con.execute('''
@@ -71,8 +71,9 @@ class Connection(Base):
                     FROM information_schema.columns
                     ORDER BY ordinal_position ASC
                 ''').fetchall():
-            if table_name in tables:
-                table = tables[table_name]
+            normalized_table_name = Table.normalize_name(table_name)
+            if normalized_table_name in tables:
+                table = tables[normalized_table_name]
 
                 column = Column(table, column_name, data_type, is_nullable == 'YES')
                 table.columns.append(column)
@@ -88,10 +89,12 @@ class Connection(Base):
                     ORDER BY constraint_index ASC
                 ''').fetchall():
             # get table
-            if table_name not in tables:
+            normalized_table_name = Table.normalize_name(table_name)
+
+            if normalized_table_name not in tables:
                 raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
 
-            table = tables[table_name]
+            table = tables[normalized_table_name]
 
             # store constraint
             if constraint_index in constraints:
@@ -102,7 +105,7 @@ class Connection(Base):
                 table,
                 tuple(table.get_column(c) for c in constraint_columns)
             )
-            constraints[(table_name, *constraint_columns)] = constraint
+            constraints[(normalized_table_name, *constraint_columns)] = constraint
 
             # store key
             if table.primary_key is not None:
@@ -121,10 +124,12 @@ class Connection(Base):
                     ORDER BY constraint_index ASC
                 ''').fetchall():
             # get table
-            if table_name not in tables:
+            normalized_table_name = Table.normalize_name(table_name)
+
+            if normalized_table_name not in tables:
                 raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
 
-            table = tables[table_name]
+            table = tables[normalized_table_name]
 
             # store constraint
             if constraint_index in constraints:
@@ -135,7 +140,7 @@ class Connection(Base):
                 table,
                 tuple(table.get_column(c) for c in constraint_columns)
             )
-            constraints[(table_name, *constraint_columns)] = constraint
+            constraints[(normalized_table_name, *constraint_columns)] = constraint
 
             # store key
             table.unique_keys.append(constraint)
@@ -153,13 +158,15 @@ class Connection(Base):
                     ORDER BY constraint_index ASC
                 ''').fetchall():
             # get table
-            if table_name not in tables:
+            normalized_table_name = Table.normalize_name(table_name)
+
+            if normalized_table_name not in tables:
                 raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
 
-            table = tables[table_name]
+            table = tables[normalized_table_name]
 
             # lookup constraint
-            constraint_key = (referenced_table, *referenced_column_names)
+            constraint_key = (Table.normalize_name(referenced_table), *referenced_column_names)
             if constraint_key not in constraints:
                 raise AssertionError(f'constraint with key {constraint_key} not discovered previously')
 

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/db/implementation/postgres/Connection.py

@@ -88,7 +88,7 @@ class Connection(Base):
             WHERE table_schema='public' AND table_type='BASE TABLE'
         ''').fetchall():
             table = Table(table_name)
-            tables[table_name] = table
+            tables[table.normalized_name] = table
 
         # Get column names and data types for each table.
         for table_name, column_name, data_type, is_nullable in self.con.execute('''
@@ -100,8 +100,9 @@ class Connection(Base):
                     FROM information_schema.columns
                     ORDER BY ordinal_position ASC
                 ''').fetchall():
-            if table_name in tables:
-                table = tables[table_name]
+            normalized_table_name = Table.normalize_name(table_name)
+            if normalized_table_name in tables:
+                table = tables[normalized_table_name]
 
                 column = Column(table, column_name, data_type, is_nullable == 'YES')
                 table.columns.append(column)
@@ -126,10 +127,12 @@ class Connection(Base):
 
         for constraint_name, (table_name, column_names) in constraints_dict.items():
             # get table
-            if table_name not in tables:
+            normalized_table_name = Table.normalize_name(table_name)
+
+            if normalized_table_name not in tables:
                 raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
 
-            table = tables[table_name]
+            table = tables[normalized_table_name]
 
             # store constraint
             constraint = Constraint(
@@ -166,10 +169,12 @@ class Connection(Base):
 
         for constraint_name, (table_name, column_names) in constraints_dict.items():
             # get table
-            if table_name not in tables:
+            normalized_table_name = Table.normalize_name(table_name)
+
+            if normalized_table_name not in tables:
                 raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
 
-            table = tables[table_name]
+            table = tables[normalized_table_name]
 
             # store constraint
             constraint = Constraint(
@@ -197,20 +202,23 @@ class Connection(Base):
                 raise AssertionError(f'could not parse foreign key definitions for table {source_table_name}')
 
             source_table_name = strip_delimiters(source_table_name)
+            normalized_source_table_name = Table.normalize_name(source_table_name)
             source_table_column_names = [strip_delimiters(c) for c in match.group(1).split(',')]
+
             target_table_name = strip_delimiters(match.group(2))
+            normalized_target_table_name = Table.normalize_name(target_table_name)
             target_table_column_names = [strip_delimiters(c) for c in match.group(3).split(',')]
 
             # get tables
-            if source_table_name not in tables:
+            if normalized_source_table_name not in tables:
                 raise AssertionError(f'unknown table {source_table_name} for foreign key {fk_name}')
 
-            source_table = tables[source_table_name]
+            source_table = tables[normalized_source_table_name]
 
-            if target_table_name not in tables:
+            if normalized_target_table_name not in tables:
                 raise AssertionError(f'unknown table {target_table_name} for foreign key {fk_name}')
 
-            target_table = tables[target_table_name]
+            target_table = tables[normalized_target_table_name]
 
             # store constraint
             constraint = Constraint(

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/db/implementation/sqlite/Connection.py

@@ -61,7 +61,7 @@ class Connection(Base):
                         WHERE type ='table' AND name NOT LIKE 'sqlite_%';
                     ''').fetchall():
                 table = Table(table_name)
-                tables[table_name] = table
+                tables[table.normalized_name] = table
 
             # Get column names and data types for each table.
             for table_name, table in tables.items():
@@ -174,8 +174,10 @@ class Connection(Base):
                         current_targets = []
 
                     # add columns to parse later
+                    normalized_to_table_name = Table.normalize_name(to_table_name)
+
                     current_sources.append(table.get_column(from_col))
-                    current_targets.append(tables[to_table_name].get_column(to_col))
+                    current_targets.append(tables[normalized_to_table_name].get_column(to_col))
 
                 if len(current_sources) > 0:
                     store()

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/kernel.py

@@ -313,7 +313,7 @@ class DuckDBKernel(Kernel):
             for dc in data_columns:
                 found = 0
                 for i, rc in enumerate(result_columns):
-                    if dc == rc:
+                    if dc.lower() == rc.lower():
                         column_order.append(i)
                         found += 1
 

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/parser/elements/binary/ConditionalSet.py

@@ -116,7 +116,7 @@ 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.

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/duckdb_kernel/parser/util/RenamableColumn.py

@@ -13,7 +13,7 @@ class RenamableColumn(Column):
         return f'{self.table.name}.{self.name}'
 
     def matches(self, name: str) -> bool:
-        return self.name == name or self.full_name == name
+        return self.name.lower() == name.lower() or self.full_name.lower() == name.lower()
 
     def rename(self):
         old_name = self.current_name

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/src/jupyter_duckdb.egg-info/PKG-INFO

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

{jupyter_duckdb-1.2.0.0 → jupyter_duckdb-1.2.0.2}/test/test_dc.py

@@ -2,14 +2,32 @@ from duckdb_kernel.parser import DCParser
 from . import Connection
 
 
+def test_case_insensitivity():
+    for query in (
+            '{ username | users(id, username) }',
+            '{ username | Users(id, username) }',
+            '{ username | USERS(id, username) }',
+            '{ username | uSers(id, username) }'
+    ):
+        root = DCParser.parse_query(query)
+
+        # execute to test case insensitivity
+        with Connection() as con:
+            assert con.execute_dc(root) == [
+                ('Alice',),
+                ('Bob',),
+                ('Charlie',)
+            ]
+
+
 def test_simple_queries():
     with Connection() as con:
         for query in [
-            '{ id | users(id, _) }',
-            '{ id | users (id, _) }',
-            '{ id | users id,_ }',
-            '{id|users(id,_)}',
-            'id | users (id ,_)',
+            '{ id | Users(id, _) }',
+            '{ id | Users (id, _) }',
+            '{ id | Users id,_ }',
+            '{id|Users(id,_)}',
+            'id | Users (id ,_)',
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -19,8 +37,8 @@ def test_simple_queries():
             ]
 
         for query in [
-            '{ id, name | users(id, name) }',
-            '{ id,name | users(id, name) }'
+            '{ id, name | Users(id, name) }',
+            '{ id,name | Users(id, name) }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -32,14 +50,14 @@ def test_simple_queries():
 
 def test_asterisk_projection():
     with Connection() as con:
-        root = DCParser.parse_query('{ * | users(id, _) }')
+        root = DCParser.parse_query('{ * | Users(id, _) }')
         assert con.execute_dc(root) == [
             (1,),
             (2,),
             (3,)
         ]
 
-        root = DCParser.parse_query('{ * | users(id, name) }')
+        root = DCParser.parse_query('{ * | Users(id, name) }')
         assert con.execute_dc(root) == [
             (1, 'Alice'),
             (2, 'Bob'),
@@ -50,9 +68,9 @@ def test_asterisk_projection():
 def test_conditions():
     with Connection() as con:
         for query in [
-            '{ name | users(id, name) ∧ id > 1 }',
-            '{ name | users(id, name) ∧ id ≠ 1 }',
-            '{ name | users(id, name) ∧ (id = 2 ∨ id = 3) }'
+            '{ name | Users(id, name) ∧ id > 1 }',
+            '{ name | Users(id, name) ∧ id ≠ 1 }',
+            '{ name | Users(id, name) ∧ (id = 2 ∨ id = 3) }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -61,7 +79,7 @@ def test_conditions():
             ]
 
         for query in [
-            '{ id | users(id, name) ∧ name > "B" ∧ name < "C" }'
+            '{ id | Users(id, name) ∧ name > "B" ∧ name < "C" }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -73,7 +91,7 @@ def test_shortcut_conditions():
     with Connection() as con:
         # single shortcut conditions
         for query in [
-            '{ name | users(1, name) }'
+            '{ name | Users(1, name) }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -81,7 +99,7 @@ def test_shortcut_conditions():
             ]
 
         for query in [
-            '{ season_name | seasons(1, 1, season_name) }'
+            '{ season_name | Seasons(1, 1, season_name) }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -90,7 +108,7 @@ def test_shortcut_conditions():
 
         # multiple shortcut conditions
         for query in [
-            '{ sname, ename | seasons(snum, 2, sname) ∧ episodes(enum, snum, 2, ename) }'
+            '{ sname, ename | Seasons(snum, 2, sname) ∧ Episodes(enum, snum, 2, ename) }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -108,7 +126,7 @@ def test_joins():
     with Connection() as con:
         # with one attribute
         for query in [
-            '{ sename | shows(shid, shname) ∧ seasons(senum, shid, sename) }'
+            '{ sename | Shows(shid, shname) ∧ Seasons(senum, shid, sename) }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -119,8 +137,8 @@ def test_joins():
             ]
 
         for query in [
-            '{ sename | shows(shid, shname) ∧ seasons(senum, shid, sename) ∧ shname = "Show 1" }',
-            '{ sename | seasons(senum, shid, sename) ∧ shows(shid, "Show 1") }'
+            '{ sename | Shows(shid, shname) ∧ Seasons(senum, shid, sename) ∧ shname = "Show 1" }',
+            '{ sename | Seasons(senum, shid, sename) ∧ Shows(shid, "Show 1") }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -130,7 +148,7 @@ def test_joins():
 
         # with multiple attributes
         for query in [
-            '{ sname, ename | seasons(snum, shid, sname) ∧ episodes(enum, snum, shid, ename) ∧ shid = 2 }'
+            '{ sname, ename | Seasons(snum, shid, sname) ∧ Episodes(enum, snum, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -145,7 +163,7 @@ def test_joins():
 
         # join three relations
         for query in [
-            '{ 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" }'
+            '{ 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) == [
@@ -153,7 +171,7 @@ def test_joins():
             ]
 
         # cross join
-        root = DCParser.parse_query('{ sename | shows(shid1, shname) ∧ seasons(senum, shid2, sename) ∧ shid1 = shid2 }')
+        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',),
@@ -162,8 +180,8 @@ def test_joins():
         ]
 
         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" }'
+            '{ 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) == [
@@ -175,10 +193,10 @@ def test_underscores():
     with Connection() as con:
         # distinct underscores
         for query in [
-            '{ ename | seasons(snum, shid, sname) ∧ episodes(_, snum, shid, ename) ∧ shid = 2 }',
-            '{ ename | seasons(snum, shid, sname) ∧ episodes(enum, _, shid, ename) ∧ shid = 2 }',
-            '{ ename | seasons(snum, shid, sname) ∧ episodes(__, snum, shid, ename) ∧ shid = 2 }',
-            '{ ename | seasons(snum, shid, sname) ∧ episodes(_, __, shid, ename) ∧ shid = 2 }'
+            '{ ename | Seasons(snum, shid, sname) ∧ Episodes(_, snum, shid, ename) ∧ shid = 2 }',
+            '{ ename | Seasons(snum, shid, sname) ∧ Episodes(enum, _, shid, ename) ∧ shid = 2 }',
+            '{ ename | Seasons(snum, shid, sname) ∧ Episodes(__, snum, shid, ename) ∧ shid = 2 }',
+            '{ ename | Seasons(snum, shid, sname) ∧ Episodes(_, __, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -193,7 +211,7 @@ def test_underscores():
 
         # reused underscores in a single relation
         for query in [
-            '{ ename | seasons(snum, shid, sname) ∧ episodes(_, _, shid, ename) ∧ shid = 2 }'
+            '{ ename | Seasons(snum, shid, sname) ∧ Episodes(_, _, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [
@@ -208,8 +226,8 @@ def test_underscores():
 
         # reused underscores in two different relations
         for query in [
-            '{ ename | seasons(_, shid, _) ∧ episodes(_, _, shid, ename) ∧ shid = 2 }',
-            '{ ename | seasons(_, shid, __) ∧ episodes(_, __, shid, ename) ∧ shid = 2 }'
+            '{ ename | Seasons(_, shid, _) ∧ Episodes(_, _, shid, ename) ∧ shid = 2 }',
+            '{ ename | Seasons(_, shid, __) ∧ Episodes(_, __, shid, ename) ∧ shid = 2 }'
         ]:
             root = DCParser.parse_query(query)
             assert con.execute_dc(root) == [