jupyter-duckdb 0.9.2.2.dev202401171418__py3-none-any.whl → 0.9.2.3__py3-none-any.whl

duckdb_kernel/db/Connection.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Tuple, Any
 
-from . import Table
+from .Table import Table
 
 
 class Connection:
@@ -10,6 +10,17 @@ class Connection:
     def close(self):
         pass
 
+    @staticmethod
+    def plain_explain() -> bool:
+        return False
+
+    @staticmethod
+    def multiple_statements_per_query() -> bool:
+        return True
+
+    def __str__(self) -> str:
+        raise NotImplementedError
+
     def execute(self, query: str) -> Tuple[List[str], List[List[Any]]]:
         raise NotImplementedError
 

duckdb_kernel/db/Table.py

@@ -3,7 +3,7 @@ from typing import List, Optional
 
 from . import Column
 from . import ForeignKey
-from .Constraint import Constraint
+from . import Constraint
 
 
 class Table:

duckdb_kernel/db/__init__.py

@@ -1,12 +1,6 @@
-from .DatabaseError import DatabaseError
 from .Column import Column
+from .Connection import Connection
 from .Constraint import Constraint
+from .DatabaseError import DatabaseError
 from .ForeignKey import ForeignKey
 from .Table import Table
-
-try:
-    from .duckdb import Connection
-    SQLITE_MODE = False
-except ImportError:
-    from .sqlite import Connection
-    SQLITE_MODE = True

duckdb_kernel/db/error/EmptyResultError.py

@@ -0,0 +1,5 @@
+from ..DatabaseError import DatabaseError
+
+
+class EmptyResultError(DatabaseError):
+    pass

duckdb_kernel/db/error/__init__.py

@@ -0,0 +1 @@
+from .EmptyResultError import EmptyResultError

duckdb_kernel/db/{duckdb → implementation/duckdb}/Connection.py

@@ -2,17 +2,25 @@ from typing import Dict, List, Tuple, Any
 
 import duckdb
 
-from .. import DatabaseError, Column, Constraint, ForeignKey, Table
-from ..Connection import Connection as Base
+from ... import DatabaseError, Column, Constraint, ForeignKey, Table
+from ...Connection import Connection as Base
 
 
 class Connection(Base):
     def __init__(self, path: str):
+        self.path: str = path
         self.con: duckdb.DuckDBPyConnection = duckdb.connect(path, read_only=False)
 
     def close(self):
         self.con.close()
 
+    @staticmethod
+    def plain_explain() -> bool:
+        return True
+
+    def __str__(self) -> str:
+        return f'DuckDB: {self.path}'
+
     def execute(self, query: str) -> Tuple[List[str], List[List[Any]]]:
         with self.con.cursor() as cursor:
             try:

duckdb_kernel/db/implementation/postgres/Connection.py

@@ -0,0 +1,226 @@
+import contextlib
+import re
+from typing import Tuple, List, Any, Optional, Dict
+from uuid import uuid4
+
+import psycopg
+
+from ... import DatabaseError, Column, Constraint, ForeignKey, Table
+from ...Connection import Connection as Base
+from ...error import EmptyResultError
+
+
+class Connection(Base):
+    def __init__(self,
+                 host: str, port: int,
+                 username: Optional[str], password: Optional[str],
+                 database_name: Optional[str]):
+        self.host: str = host
+        self.port: int = port
+        self.username: Optional[str] = username
+
+        options = {
+            'host': host,
+            'port': port,
+            'user': username,
+            'password': password,
+            'autocommit': True
+        }
+
+        # If not database name is provided we create one.
+        if database_name is None:
+            # connect to the server without a database name
+            with contextlib.closing(psycopg.connect(**options, dbname='postgres')) as temp_con:
+                # create a database to use
+                database_name: str = 'db_' + str(uuid4()).replace('-', '')
+                temp_con.execute(f'CREATE DATABASE {database_name}')
+
+        # Finally the "real" connection is created using the database name.
+        self.con = psycopg.connect(**options, dbname=database_name)
+        self.database_name: str = database_name
+
+    def close(self):
+        self.con.close()
+
+    def __str__(self) -> str:
+        user = f'{self.username}@' if self.username is not None else ''
+        return f'PostgreSQL: {user}{self.host}:{self.port}/{self.database_name}'
+
+    def execute(self, query: str) -> Tuple[List[str], List[List[Any]]]:
+        with self.con.cursor() as cursor:
+            try:
+                cursor.execute(query)
+            except Exception as e:
+                if isinstance(e, psycopg.Error):
+                    text = str(e)
+                    raise DatabaseError(text)
+                else:
+                    raise e
+
+            # get rows
+            try:
+                rows = cursor.fetchall()
+            except psycopg.ProgrammingError as e:
+                text = str(e)
+                if text == "the last operation didn't produce a result":
+                    raise EmptyResultError()
+                else:
+                    raise e
+
+            # get columns
+            if cursor.description is None:
+                columns = []
+            else:
+                columns = [e[0] for e in cursor.description]
+
+        return columns, rows
+
+    def analyze(self) -> Dict[str, Table]:
+        tables: Dict[str, Table] = {}
+        constraints: Dict[str, Constraint] = {}
+        constraint_index: int = 0
+
+        # First, receive the table names.
+        for table_name, in self.con.execute('''
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema='public' AND table_type='BASE TABLE'
+        ''').fetchall():
+            table = Table(table_name)
+            tables[table_name] = table
+
+        # Get column names and data types for each table.
+        for table_name, column_name, data_type in self.con.execute('''
+                    SELECT
+                        table_name,
+                        column_name,
+                        data_type
+                    FROM information_schema.columns
+                    ORDER BY ordinal_position ASC
+                ''').fetchall():
+            if table_name in tables:
+                table = tables[table_name]
+
+                column = Column(table, column_name, data_type)
+                table.columns.append(column)
+
+        # Find primary keys.
+        constraints_dict = {}
+
+        for constraint_name, table_name, column_name in self.con.execute('''
+            SELECT tc.constraint_name, tc.table_name, c.column_name
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.constraint_column_usage AS ccu
+                USING (constraint_schema, constraint_name)
+            JOIN information_schema.columns AS c
+                ON c.table_schema = tc.constraint_schema AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+            WHERE tc.table_schema = 'public' AND tc.constraint_type = 'PRIMARY KEY'
+            ORDER BY tc.table_name, c.ordinal_position
+        '''):
+            if constraint_name not in constraints_dict:
+                constraints_dict[constraint_name] = (table_name, [])
+
+            constraints_dict[constraint_name][1].append(column_name)
+
+        for constraint_name, (table_name, column_names) in constraints_dict.items():
+            # get table
+            if table_name not in tables:
+                raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
+
+            table = tables[table_name]
+
+            # store constraint
+            constraint = Constraint(
+                constraint_index,
+                table,
+                tuple(table.get_column(c) for c in column_names)
+            )
+
+            constraint_index += 1
+
+            # store key
+            if table.primary_key is not None:
+                raise AssertionError(f'discovered second primary key for table {table_name}')
+
+            table.primary_key = constraint
+
+        # Find unqiue keys.
+        constraints_dict = {}
+
+        for constraint_name, table_name, column_name in self.con.execute('''
+            SELECT tc.constraint_name, tc.table_name, c.column_name
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.constraint_column_usage AS ccu
+                USING (constraint_schema, constraint_name)
+            JOIN information_schema.columns AS c
+                ON c.table_schema = tc.constraint_schema AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+            WHERE tc.table_schema = 'public' AND tc.constraint_type = 'UNIQUE'
+            ORDER BY tc.table_name, c.ordinal_position
+        '''):
+            if constraint_name not in constraints_dict:
+                constraints_dict[constraint_name] = (table_name, [])
+
+            constraints_dict[constraint_name][1].append(column_name)
+
+        for constraint_name, (table_name, column_names) in constraints_dict.items():
+            # get table
+            if table_name not in tables:
+                raise AssertionError(f'unknown table {table_name} for constraint {constraint_index}')
+
+            table = tables[table_name]
+
+            # store constraint
+            constraint = Constraint(
+                constraint_index,
+                table,
+                tuple(table.get_column(c) for c in column_names)
+            )
+
+            constraint_index += 1
+
+            # store key
+            table.unique_keys.append(constraint)
+
+        # Find foreign keys.
+        for source_table_name, fk_name, fk_def in self.con.execute('''
+            SELECT conrelid::regclass, conname, pg_get_constraintdef(oid)
+            FROM pg_constraint
+            WHERE contype = 'f'
+            AND connamespace = 'public'::regnamespace
+            ORDER BY conrelid::regclass::text, contype DESC
+        '''):
+            # extract information
+            match = re.match(r'^FOREIGN KEY \((.*?)\) REFERENCES (.*?)\((.*?)\)', fk_def, re.IGNORECASE)
+            if match is None:
+                raise AssertionError(f'could not parse foreign key definitions for table {source_table_name}')
+
+            source_table_column_names = [c.strip() for c in match.group(1).split(',')]
+            target_table_name = match.group(2).strip()
+            target_table_column_names = [c.strip() for c in match.group(3).split(',')]
+
+            # get tables
+            if 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]
+
+            if 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]
+
+            # store constraint
+            constraint = Constraint(
+                constraint_index,
+                target_table,
+                tuple(target_table.get_column(c) for c in target_table_column_names)
+            )
+
+            constraint_index += 1
+
+            # store key
+            key = ForeignKey(tuple(source_table.get_column(c) for c in source_table_column_names), constraint)
+            source_table.foreign_keys.append(key)
+
+        # return result
+        return tables

duckdb_kernel/db/{sqlite → implementation/sqlite}/Connection.py

@@ -2,8 +2,8 @@ import sqlite3
 from contextlib import closing
 from typing import Dict, List, Tuple, Any
 
-from .. import DatabaseError, Column, Constraint, ForeignKey, Table
-from ..Connection import Connection as Base
+from ... import DatabaseError, Column, Constraint, ForeignKey, Table
+from ...Connection import Connection as Base
 
 
 class Connection(Base):
@@ -14,6 +14,13 @@ class Connection(Base):
     def close(self):
         self.con.close()
 
+    @staticmethod
+    def multiple_statements_per_query() -> bool:
+        return False
+
+    def __str__(self) -> str:
+        return f'SQLite: {self.path}'
+
     def execute(self, query: str) -> Tuple[List[str], List[List[Any]]]:
         with closing(self.con.cursor()) as cursor:
             try:

duckdb_kernel/db/implementation/sqlite/__init__.py

@@ -0,0 +1 @@
+from .Connection import Connection

duckdb_kernel/kernel.py

@@ -8,7 +8,8 @@ from typing import Optional, Dict, List, Tuple
 
 from ipykernel.kernelbase import Kernel
 
-from .db import Connection, DatabaseError, SQLITE_MODE
+from .db import Connection, DatabaseError
+from .db.error import *
 from .magics import *
 from .parser import RAParser, DCParser
 from .util.ResultSetComparator import ResultSetComparator
@@ -20,7 +21,7 @@ class DuckDBKernel(Kernel):
     DEFAULT_MAX_ROWS = 20
 
     implementation = 'DuckDB'
-    implementation_version = '0.9.2'
+    implementation_version = '1.0'
     banner = 'DuckDB Kernel'
     language_info = {
         'name': 'duckdb',
@@ -87,7 +88,41 @@ class DuckDBKernel(Kernel):
     # database related functions
     def _load_database(self, path: str):
         if self._db is None:
-            self._db: Optional[Connection] = Connection(path)
+            # If the provided path looks like a postgres url,
+            # we want to use the postgres driver.
+            if path.startswith(('postgresql://', 'postgres://', 'pgsql://', 'psql://', 'pg://')):
+                # pull data from connection string
+                match = re.fullmatch(r'(postgresql|postgres|pgsql|psql|pg)://((.*?)(:(.*?))?@)?(.*?)(:(\d+))?(/(.*))?', path)
+
+                host = match.group(6)
+                port = int(match.group(8)) if match.group(8) is not None else 5432
+                username = match.group(3)
+                password = match.group(5)
+                database_name = match.group(10)
+
+                # load and create instance
+                try:
+                    from .db.implementation.postgres import Connection as Postgres
+                    self._db = Postgres(host, port, username, password, database_name)
+                except ImportError:
+                    self.print('psycopg could not be found', name='stderr')
+
+            # Otherwise the provided path is used to create an
+            # in-process instance.
+            else:
+                # By default, we try to load DuckDB.
+                try:
+                    from .db.implementation.duckdb import Connection as DuckDB
+                    self._db = DuckDB(path)
+
+                # If DuckDB is not installed or fails to load,
+                # we use SQLite instead.
+                except ImportError:
+                    self.print('DuckDB is not available\n')
+
+                    from .db.implementation.sqlite import Connection as SQLite
+                    self._db = SQLite(path)
+
             return True
         else:
             return False
@@ -107,7 +142,12 @@ class DuckDBKernel(Kernel):
 
         # execute query and store start and end timestamp
         st = time.time()
-        columns, rows = self._db.execute(query)
+
+        try:
+            columns, rows = self._db.execute(query)
+        except EmptyResultError:
+            columns, rows = None, None
+
         et = time.time()
 
         # return result if silent
@@ -115,7 +155,7 @@ class DuckDBKernel(Kernel):
             return columns, rows
 
         # print EXPLAIN queries as raw text if using DuckDB
-        if query.strip().startswith('EXPLAIN') and not SQLITE_MODE:
+        if query.strip().startswith('EXPLAIN') and self._db.plain_explain():
             for ekey, evalue in rows:
                 self.print_data(f'<b>{ekey}</b><br><pre>{evalue}</pre>')
 
@@ -123,34 +163,38 @@ class DuckDBKernel(Kernel):
 
         # print every other query as a table
         else:
-            # table header
-            table_header = ''.join(f'<th>{c}</th>' for c in columns)
-
-            # table data
-            if max_rows is not None and len(rows) > max_rows:
-                table_data = f'''
-                    {rows_table(rows[:math.ceil(max_rows / 2)])}
-                    <tr>
-                        <td colspan="{len(columns)}" 
-                            style="text-align: center"
-                            title="{row_count(len(rows) - max_rows)} omitted">
-                            ...
-                        </td>
-                    </tr>
-                    {rows_table(rows[-math.floor(max_rows // 2):])}
-                '''
-            else:
-                table_data = rows_table(rows)
-
-            # send to client
-            self.print_data(f'''
-                <table class="duckdb-query-result">
-                    {table_header}
-                    {table_data}
-                </table>
-            ''')
+            if columns is not None:
+                # table header
+                table_header = ''.join(f'<th>{c}</th>' for c in columns)
+
+                # table data
+                if max_rows is not None and len(rows) > max_rows:
+                    table_data = f'''
+                        {rows_table(rows[:math.ceil(max_rows / 2)])}
+                        <tr>
+                            <td colspan="{len(columns)}" 
+                                style="text-align: center"
+                                title="{row_count(len(rows) - max_rows)} omitted">
+                                ...
+                            </td>
+                        </tr>
+                        {rows_table(rows[-math.floor(max_rows // 2):])}
+                    '''
+                else:
+                    table_data = rows_table(rows)
+
+                # send to client
+                self.print_data(f'''
+                    <table class="duckdb-query-result">
+                        {table_header}
+                        {table_data}
+                    </table>
+                ''')
+
+                self.print_data(f'{row_count(len(rows))} in {et - st:.3f}s')
 
-            self.print_data(f'{row_count(len(rows))} in {et - st:.3f}s')
+            else:
+                self.print_data(f'statement executed without result in {et - st:.3f}s')
 
         return columns, rows
 
@@ -167,12 +211,8 @@ class DuckDBKernel(Kernel):
             if not silent:
                 self.print('unloaded database\n')
 
-        # print kernel version
-        if not silent:
-            if not SQLITE_MODE:
-                self.print(f'{self.implementation} {self.implementation_version}\n')
-            else:
-                self.print('SQLite (DuckDB is not installed)\n')
+        # No user cares about the kernel version,
+        # so I removed the printing.
 
         # clean path
         if path.startswith(("'", '"')):
@@ -186,7 +226,8 @@ class DuckDBKernel(Kernel):
 
         if self._load_database(path):
             if not silent:
-                self.print(f'loaded database "{path}"\n')
+                # self.print(f'loaded database "{path}"\n')
+                self.print(str(self._db))
 
         # copy data from source database
         if of is not None:
@@ -202,12 +243,12 @@ class DuckDBKernel(Kernel):
                     content = file.read()
 
                     # You can only execute one statement at a time using SQLite.
-                    if SQLITE_MODE:
+                    if not self._db.multiple_statements_per_query():
                         statements = re.split(r';\r?\n', content)
                         for statement in statements:
                             self._db.execute(statement)
 
-                    # DuckDB can execute multiple statements at a time.
+                    # Other DBMS can execute multiple statements at a time.
                     else:
                         self._db.execute(content)
 

duckdb_kernel/parser/elements/RAElement.py

@@ -35,9 +35,9 @@ class RAElement:
 
         # if all columns are from the same relation we can skip the relation name
         if len(set(c.table for c in columns)) == 1:
-            column_names = ', '.join(f"{c.current_name} AS '{c.name}'" for c in columns)
+            column_names = ', '.join(f'{c.current_name} AS "{c.name}"' for c in columns)
         else:
-            column_names = ', '.join(f"{c.current_name} AS '{c.full_name}'" for c in columns)
+            column_names = ', '.join(f'{c.current_name} AS "{c.full_name}"' for c in columns)
 
         return f'SELECT {column_names} FROM ({sql}) {self._name()}'
 

duckdb_kernel/parser/elements/binary/ConditionalSet.py

@@ -334,10 +334,10 @@ class ConditionalSet:
             target_table_stmt = table_statements[target_name]
             sql_tables += f' LEFT JOIN {target_table_stmt} ON {join_condition}'
 
-        sql_join_filters = '1'
+        sql_join_filters = '1=1'
         for _, _, _, join_filter in sorted_negative_joins:
             sql_join_filters += f' AND {join_filter}'
 
-        sql_condition = condition.to_sql(joined_columns) if condition is not None else 1
+        sql_condition = condition.to_sql(joined_columns) if condition is not None else '1=1'
 
         return f'SELECT DISTINCT {sql_select} FROM {sql_tables} WHERE ({sql_join_filters}) AND ({sql_condition})'

{jupyter_duckdb-0.9.2.2.dev202401171418.dist-info → jupyter_duckdb-0.9.2.3.dist-info}/METADATA

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

{jupyter_duckdb-0.9.2.2.dev202401171418.dist-info → jupyter_duckdb-0.9.2.3.dist-info}/RECORD

@@ -1,18 +1,22 @@
 duckdb_kernel/__init__.py,sha256=6auU6zeJrsA4fxPSr2PYamS8fG-SMXTn5YQFXF2cseo,33
 duckdb_kernel/__main__.py,sha256=Z3GwHEBWoQjNm2Y84ijnbA0Lk66L7nsFREuqhZ_ptk0,165
 duckdb_kernel/kernel.json,sha256=_7E8Ci2FSdCvnzCjsOaue8QE8AvpS5JLQuxORO5IGtA,127
-duckdb_kernel/kernel.py,sha256=NGFdha_cnRh8rGuMOr4diCwpKKfpjpYRK7_Dc32sABQ,16561
+duckdb_kernel/kernel.py,sha256=XjRN0_lPQvGFGJ8r8ZveAu09fLXG2IArIXZvU0-DUqs,18393
 duckdb_kernel/db/Column.py,sha256=M9VRAaQ0uEWxZMaXjfFyjaDPpHsLuTSlvGaI5NDo6sM,516
-duckdb_kernel/db/Connection.py,sha256=gCzcNitLaAIh9CwsqUyS_nd47Doje6nWvDXcnmpnO9s,368
+duckdb_kernel/db/Connection.py,sha256=5pH-CwGh-r9Q2QwJKGSxvoINBU-sqmvZyG4Q1digfeE,599
 duckdb_kernel/db/Constraint.py,sha256=1YgUHk7s8mHCVedbcuJKyXDykj7_ybbwT3Dk9p2VMis,287
 duckdb_kernel/db/DatabaseError.py,sha256=43zl8yym1f-fxH_UtGIbWnDnBE_TRwr9aCziY9t40QY,41
 duckdb_kernel/db/ForeignKey.py,sha256=iurUAXwTwSIpLXsL0B7BA8jqDTfW4_wkeHxoqQbZwiU,470
-duckdb_kernel/db/Table.py,sha256=Jv9un_oX-nupx2EqzJDn_UHtAwddgFGSEapho2kIDrY,756
-duckdb_kernel/db/__init__.py,sha256=5kEM0lmq3tdvL-sqg_IQuSNYK0FJ-UiXYqCkg4gVVD8,306
-duckdb_kernel/db/duckdb/Connection.py,sha256=4B1BUGIQjfD-W0A6_NeZ_WuDTkkCj3-CU6zTdb-Q9D4,5913
-duckdb_kernel/db/duckdb/__init__.py,sha256=HKogB1es4wOiQUoh7_eT32xnUFLmzoCyR_0LuY9r8YQ,35
-duckdb_kernel/db/sqlite/Connection.py,sha256=0LPjQTEdqSBkNMtLGwO-JvEVP-zSf6fIahXstTguH4E,6662
-duckdb_kernel/db/sqlite/__init__.py,sha256=HKogB1es4wOiQUoh7_eT32xnUFLmzoCyR_0LuY9r8YQ,35
+duckdb_kernel/db/Table.py,sha256=6M_CTBV3QlrL_7CdYfu6s9LelXBQ5RdMUAyntE6xcDI,746
+duckdb_kernel/db/__init__.py,sha256=PKQYQDCW7VQYxmzhQK6A0Qloka9FdMfeFQMfY-CjBSA,198
+duckdb_kernel/db/error/EmptyResultError.py,sha256=N9Oxi2HDZBKaRQsfRsWpJJGOYX4BjdQqWOU-XvzUzNY,92
+duckdb_kernel/db/error/__init__.py,sha256=oHfhfbcfyTJ3pAPN835omdQcebvJTauuULFx5gm9rq4,47
+duckdb_kernel/db/implementation/duckdb/Connection.py,sha256=CUpfIv5OVnKv82MsMVB_QEWrxlIDkNGcqxpSpRc9MQU,6086
+duckdb_kernel/db/implementation/duckdb/__init__.py,sha256=HKogB1es4wOiQUoh7_eT32xnUFLmzoCyR_0LuY9r8YQ,35
+duckdb_kernel/db/implementation/postgres/Connection.py,sha256=ztfDIZH34X1XauGATqRNfcKZ81_r-SPfOiPmEgcaOyw,8605
+duckdb_kernel/db/implementation/postgres/__init__.py,sha256=HKogB1es4wOiQUoh7_eT32xnUFLmzoCyR_0LuY9r8YQ,35
+duckdb_kernel/db/implementation/sqlite/Connection.py,sha256=S-cyRlYP0nzITza5yIedXNPMJTM4Z5uY2CP1RPVaycE,6822
+duckdb_kernel/db/implementation/sqlite/__init__.py,sha256=HKogB1es4wOiQUoh7_eT32xnUFLmzoCyR_0LuY9r8YQ,35
 duckdb_kernel/magics/MagicCommand.py,sha256=OoQ6j4cNtIYjaK4MPVzJyv1eYTNu4_a7qoRx-5G3Hg0,2346
 duckdb_kernel/magics/MagicCommandCallback.py,sha256=r1kkJyRR7sZnrnlMH3w4bGqDAJL-BVTIB4-Kn66ynlM,764
 duckdb_kernel/magics/MagicCommandException.py,sha256=MwuWkpA6NoCqz437urdI0RVXhbSbVdziuRoi7slYFPc,49
@@ -27,7 +31,7 @@ duckdb_kernel/parser/elements/LogicElement.py,sha256=YasKHxWLDDP8UdyLIKbXzqIRA8-
 duckdb_kernel/parser/elements/LogicOperand.py,sha256=B9NvriloQE5eP734dNMZBZwrdaaIfsuAmZlG1t2eMhs,1021
 duckdb_kernel/parser/elements/LogicOperator.py,sha256=lkM4TAGkXUhsO4w4PLKVA0bgCRGPQQFpNA1FcWWOW9Q,1028
 duckdb_kernel/parser/elements/RABinaryOperator.py,sha256=XN41stGc1e-a4dZ1AQVtQ3lEgjUGNt3dMfYXp85LEeE,538
-duckdb_kernel/parser/elements/RAElement.py,sha256=gFnByFmDR34mo4nJa432c8tCE9AMPv9Gjn2fT3zL7_Y,1468
+duckdb_kernel/parser/elements/RAElement.py,sha256=d6QWO8KlWcwhA4tXtWsf8K4oT3OMMjTvEnUD4yaWQ_c,1468
 duckdb_kernel/parser/elements/RAOperand.py,sha256=pghnTYCrrT6MkvynJRgVFPRoMvxIGNB3FTjaq-uCpDQ,1078
 duckdb_kernel/parser/elements/RAOperator.py,sha256=rtqMFBIBBqT-Bwg7Qm4WQwbDrE28Nb74F_7XMeR3ks4,255
 duckdb_kernel/parser/elements/RAUnaryOperator.py,sha256=XC1nphkSm88JaEu5V_HKnb_8JNoeBfE3EvNL4o0qh2c,654
@@ -35,7 +39,7 @@ duckdb_kernel/parser/elements/__init__.py,sha256=4DA2M43hh9d1fZb5Z6YnTTI-IBkDyhC
 duckdb_kernel/parser/elements/binary/Add.py,sha256=XGkZMfab01huk9EaI6JUfzkd2STbV1C_-TyC2guKE8I,190
 duckdb_kernel/parser/elements/binary/And.py,sha256=0jgetTG8yo5TJSeK70Kj-PI9ERyek1eyMQXX5HBxa4Y,274
 duckdb_kernel/parser/elements/binary/ArrowLeft.py,sha256=u4fZSoyT9lfvWXBwuhUl4DdjVZAOqyVIKmMVbpElLD4,203
-duckdb_kernel/parser/elements/binary/ConditionalSet.py,sha256=wTum6yIspWjH3b_IDZBfD1DzG_xwKzpD_To9jBann_A,16643
+duckdb_kernel/parser/elements/binary/ConditionalSet.py,sha256=OKpUsTP3HzsDg0vVkb3JqWZd5AUL1RnZXmF-8qWoRq8,16649
 duckdb_kernel/parser/elements/binary/Cross.py,sha256=jVY3cvD6qDWZkJ7q74lFUPO2VdDt4aAjdk2YAfg-ZC4,687
 duckdb_kernel/parser/elements/binary/Difference.py,sha256=2oCdVm2dgd4Xh6ysLqqv1JgfNS_Bjtd8oA-kNBoFLf0,743
 duckdb_kernel/parser/elements/binary/Divide.py,sha256=d7mzaOeRYSRO1F-2IHsv_C939TuYtLppbf4-5GSRJXs,265
@@ -70,7 +74,7 @@ duckdb_kernel/visualization/Drawer.py,sha256=D0LkiGMvuJ2v6cQSg_axLTGaM4VXAJEQJAy
 duckdb_kernel/visualization/RATreeDrawer.py,sha256=j-Vy1zpYMzwZ3CsphyfPW-J7ou9a9tM6aXXgAlQTgDI,2128
 duckdb_kernel/visualization/SchemaDrawer.py,sha256=fkp7tnyfzKQBXVI6X7efAvT8lczi_XlA7Hc_rhP_47s,2955
 duckdb_kernel/visualization/__init__.py,sha256=5eMJmxJ01XAXcgWDn3t70eSZF2PGaXdNo6GK-x-0H3s,78
-jupyter_duckdb-0.9.2.2.dev202401171418.dist-info/METADATA,sha256=DGnAtkYGcLIHWsydwAyXRzJ35jwyT3NzT_8n7Bniu-s,7764
-jupyter_duckdb-0.9.2.2.dev202401171418.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-jupyter_duckdb-0.9.2.2.dev202401171418.dist-info/top_level.txt,sha256=KvRRPMnmkQNuhyBsXoPmwyt26LRDp0O-0HN6u0Dm5jA,14
-jupyter_duckdb-0.9.2.2.dev202401171418.dist-info/RECORD,,
+jupyter_duckdb-0.9.2.3.dist-info/METADATA,sha256=bNaTQa_rguAVOoSbK3pWKwq4I2hbBDzZXSARO1yg9p8,7748
+jupyter_duckdb-0.9.2.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+jupyter_duckdb-0.9.2.3.dist-info/top_level.txt,sha256=KvRRPMnmkQNuhyBsXoPmwyt26LRDp0O-0HN6u0Dm5jA,14
+jupyter_duckdb-0.9.2.3.dist-info/RECORD,,