jupyter-duckdb 1.2.0.1__py3-none-any.whl → 1.4.111__py3-none-any.whl

duckdb_kernel/tests/test_result_comparison.py

@@ -0,0 +1,173 @@
+from duckdb_kernel.util.ResultSetComparator import ResultSetComparator
+
+
+def test_equals():
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (3, "Charlie")
+    ], [
+        (1, "Alice"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == []
+    assert rsc.ordered_right_only == []
+
+
+def test_equals_only_unordered():
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (3, "Charlie")
+    ], [
+        (3, "Charlie"),
+        (1, "Alice")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == [(3, "Charlie")]
+    assert rsc.ordered_right_only == [(1, "Alice")]
+
+
+def test_missing():
+    # first missing
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == [(1, "Alice")]
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == [(1, "Alice")]
+    assert rsc.ordered_right_only == []
+
+    # middle missing
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (1, "Alice"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == [(2, "Bob")]
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == [(2, "Bob")]
+    assert rsc.ordered_right_only == []
+
+    # last missing
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (1, "Alice"),
+        (2, "Bob")
+    ])
+
+    assert rsc.left_only == [(3, "Charlie")]
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == [(3, "Charlie")]
+    assert rsc.ordered_right_only == []
+
+
+def test_unnecessary():
+    # first unnecessary
+    rsc = ResultSetComparator([
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (1, "Alice"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == [(1, "Alice")]
+    assert rsc.ordered_left_only == []
+    assert rsc.ordered_right_only == [(1, "Alice")]
+
+    # middle unnecessary
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (3, "Charlie")
+    ], [
+        (1, "Alice"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == [(2, "Bob")]
+    assert rsc.ordered_left_only == []
+    assert rsc.ordered_right_only == [(2, "Bob")]
+
+    # last unnecessary
+    rsc = ResultSetComparator([
+        (1, "Alice"),
+        (2, "Bob")
+    ], [
+        (1, "Alice"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == [(3, "Charlie")]
+    assert rsc.ordered_left_only == []
+    assert rsc.ordered_right_only == [(3, "Charlie")]
+
+
+def test_repeating():
+    # equal
+    rsc = ResultSetComparator([
+        (2, "Bob"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (2, "Bob"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == []
+    assert rsc.ordered_right_only == []
+
+    # missing
+    rsc = ResultSetComparator([
+        (2, "Bob"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == [(2, "Bob")]
+    assert rsc.right_only == []
+    assert rsc.ordered_left_only == [(2, "Bob")]
+    assert rsc.ordered_right_only == []
+
+    # unnecessary
+    rsc = ResultSetComparator([
+        (2, "Bob"),
+        (3, "Charlie")
+    ], [
+        (2, "Bob"),
+        (2, "Bob"),
+        (3, "Charlie")
+    ])
+
+    assert rsc.left_only == []
+    assert rsc.right_only == [(2, "Bob")]
+    assert rsc.ordered_left_only == []
+    assert rsc.ordered_right_only == [(2, "Bob")]

duckdb_kernel/tests/test_sql.py

@@ -0,0 +1,48 @@
+import pytest
+
+from duckdb_kernel.db.error import EmptyResultError
+from . import Connection
+
+
+def test_simple_queries():
+    query = 'SELECT Username FROM Users'
+
+    with Connection() as con:
+        assert con.execute_sql(query) == [
+            ('Alice',),
+            ('Bob',),
+            ('Charlie',)
+        ]
+
+
+def test_empty_result():
+    with Connection() as con:
+        query = "SELECT Username FROM Users WHERE Username = 'abcdef'"
+        assert con.execute_sql(query) == []
+
+    with Connection() as con:
+        query = 'CREATE TABLE foo (bar INTEGER PRIMARY KEY)'
+        try:
+            assert con.execute_sql(query) == []
+        except EmptyResultError:
+            pass
+
+
+def test_empty_queries():
+    for query in [
+        '',
+        ' ',
+        '\n',
+        '-- this is an empty query too'
+    ]:
+        with pytest.raises(EmptyResultError):
+            with Connection() as con:
+                con.execute_sql(query)
+
+    with pytest.raises(Exception):
+        with Connection() as con:
+            query = '-- this is a query with syntax errors\nFOR foo IN bar'
+            try:
+                con.execute_sql(query)
+            except EmptyResultError:
+                pass

duckdb_kernel/util/ResultSetComparator.py

@@ -1,11 +1,29 @@
+import datetime
+import decimal
 from datetime import date
-from typing import Tuple, List, Optional
+from typing import Tuple, List, Optional, Any
 
 
 class ResultSetComparator:
     def __init__(self, left: List[Tuple | List], right: List[Tuple | List]):
-        self._left: List[Tuple] = [tuple(t) for t in left]
-        self._right: List[Tuple] = [tuple(t) for t in right]
+        self._left: List[Tuple] = [tuple(self.format_value(t)) for t in left]
+        self._right: List[Tuple] = [tuple(self.format_value(t)) for t in right]
+
+    @staticmethod
+    def format_value(value: Any) -> Any:
+        if isinstance(value, tuple) or isinstance(value, list):
+            return tuple(ResultSetComparator.format_value(t) for t in value)
+
+        if isinstance(value, datetime.datetime):
+            return value.strftime("%Y-%m-%d %H:%M:%S")
+        if isinstance(value, datetime.date):
+            return value.strftime("%Y-%m-%d")
+        if isinstance(value, datetime.time):
+            return value.strftime("%H:%M:%S")
+        if isinstance(value, decimal.Decimal):
+            return float(value)
+
+        return value
 
     @property
     def left_only(self) -> List[Tuple]:
@@ -67,7 +85,7 @@ class ResultSetComparator:
 
         for le, re in zip(left, right):
             if isinstance(le, float) or isinstance(re, float):
-                if abs(le - re) > 1e-6:
+                if abs(le - re) > 1e-4:
                     return False
             elif isinstance(le, date) or isinstance(re, date):
                 if str(le) != str(re):

duckdb_kernel/util/SQL.py

@@ -0,0 +1,6 @@
+# see https://www.postgresql.org/docs/current/sql-commands.html
+SQL_KEYWORDS = ('ABORT', 'ALTER', 'ANALYZE', 'BEGIN', 'CALL', 'CHECKPOINT', 'CLOSE', 'CLUSTER', 'COMMENT', 'COMMIT',
+                'COPY', 'CREATE', 'DEALLOCATE', 'DECLARE', 'DELETE', 'DISCARD', 'DO', 'DROP', 'END', 'EXECUTE',
+                'EXPLAIN', 'FETCH', 'GRANT', 'IMPORT', 'INSERT', 'LISTEN', 'LOAD', 'LOCK', 'MERGE', 'MOVE', 'NOTIFY',
+                'PREPARE', 'REASSIGN', 'REFRESH', 'REINDEX', 'RELEASE', 'RESET', 'REVOKE', 'ROLLBACK', 'SAVEPOINT',
+                'SECURITY', 'SELECT', 'SET', 'SHOW', 'START', 'TRUNCATE', 'UNLISTEN', 'UPDATE', 'VACUUM', 'VALUES')

duckdb_kernel/util/TestError.py

@@ -0,0 +1,4 @@
+class TestError(Exception):
+    @property
+    def message(self) -> str:
+        return str(self)

duckdb_kernel/visualization/Plotly.py

@@ -0,0 +1,144 @@
+import json
+from decimal import Decimal
+from typing import Dict, List, Optional
+from uuid import uuid4
+
+from .lib import init_plotly
+
+
+def __div_id() -> str:
+    return f'div-{str(uuid4())}'
+
+
+def __layout(title: Optional[str]):
+    layout = {
+        'dragmode': False,
+        'xaxis': {
+            'rangeselector': {
+                'visible': False
+            }
+        }
+    }
+
+    if title is not None:
+        layout['title'] = {
+            'text': title,
+            'font': {
+                'family': 'sans-serif',
+                'size': 32,
+                'color': 'rgb(0, 0, 0)'
+            },
+            'xanchor': 'center'
+        }
+
+    return layout
+
+
+def __config():
+    return {
+        'displayModeBar': False,
+        'scrollZoom': False
+    }
+
+
+def __fix_decimal(x: List):
+    return [float(x) if isinstance(x, Decimal) else x
+            for x in x]
+
+
+def draw_chart(title: Optional[str], traces: List[Dict] | Dict) -> str:
+    init = init_plotly()
+    div_id = __div_id()
+    layout = __layout(title)
+    config = __config()
+
+    if not isinstance(traces, str):
+        traces = json.dumps(traces)
+
+    return f'''
+        <script type="text/javascript">
+            {init}
+        </script>
+
+        <div id="{div_id}"></div>
+        <script type="text/javascript">
+            Plotly.newPlot('{div_id}', {traces}, {json.dumps(layout)}, {json.dumps(config)});
+        </script>
+    '''
+
+
+def draw_scatter_chart(title: Optional[str], x, **ys) -> str:
+    return draw_chart(title, [
+        {
+            'x': __fix_decimal(x),
+            'y': __fix_decimal(y),
+            'mode': 'markers',
+            'type': 'scatter',
+            'name': name
+        }
+        for name, y in ys.items()
+    ])
+
+
+def draw_line_chart(title: Optional[str], x, **ys) -> str:
+    return draw_chart(title, [
+        {
+            'x': __fix_decimal(x),
+            'y': __fix_decimal(y),
+            'mode': 'lines+markers',
+            'name': name
+        }
+        for name, y in ys.items()
+    ])
+
+
+def draw_bar_chart(title: Optional[str], x, **ys) -> str:
+    return draw_chart(title, [
+        {
+            'x': __fix_decimal(x),
+            'y': __fix_decimal(y),
+            'type': 'bar',
+            'name': name
+        }
+        for name, y in ys.items()
+    ])
+
+
+def draw_pie_chart(title: Optional[str], x, y) -> str:
+    return draw_chart(title, [{
+        'values': __fix_decimal(y),
+        'labels': __fix_decimal(x),
+        'type': 'pie'
+    }])
+
+
+def draw_bubble_chart(title: Optional[str], x, y, s, c) -> str:
+    return draw_chart(title, [{
+        'x': __fix_decimal(x),
+        'y': __fix_decimal(y),
+        'mode': 'markers',
+        'marker': {
+            'size': __fix_decimal(s),
+            'color': __fix_decimal(c)
+        }
+    }])
+
+
+def draw_heatmap_chart(title: Optional[str], x, y, z) -> str:
+    return draw_chart(title, [{
+        'x': __fix_decimal(x[0]),
+        'y': __fix_decimal(y[0]),
+        'z': [__fix_decimal(v) for v in z[0]],
+        'type': 'heatmap'
+    }])
+
+
+__all__ = [
+    'draw_chart',
+    'draw_scatter_chart',
+    'draw_line_chart',
+    'draw_bar_chart',
+    'draw_pie_chart',
+    'draw_bubble_chart',
+    'draw_heatmap_chart',
+]

duckdb_kernel/visualization/RATreeDrawer.py

@@ -1,12 +1,14 @@
-from typing import Dict
+from typing import Dict, Optional
 
 from graphviz import Digraph
+from uuid import uuid4
 
 from duckdb_kernel.db import Table
 from duckdb_kernel.parser.elements import RAElement
 from duckdb_kernel.util.formatting import row_count
 from .Drawer import Drawer
 from ..db import Connection
+from .lib import *
 
 
 class RATreeDrawer(Drawer):
@@ -15,6 +17,9 @@ class RATreeDrawer(Drawer):
         self.root_node: RAElement = root_node
         self.tables: Dict[str, Table] = tables
 
+        self.nodes: Dict[str, RAElement] = {}
+        self.root_node_id: Optional[str] = None
+
     def to_graph(self) -> Digraph:
         # create graph
         ps = Digraph('Schema',
@@ -31,7 +36,11 @@ class RATreeDrawer(Drawer):
 
     def __add_node(self, ps: Digraph, node: RAElement) -> str:
         # use id of node object as identifier
-        node_id = f'node_{id(node)}'
+        node_id = f'node_{str(uuid4()).replace("-", "_")}'
+
+        self.nodes[node_id] = node
+        if node == self.root_node:
+            self.root_node_id = node_id
 
         # generate child nodes
         child_ids = [self.__add_node(ps, child) for child in node.children]
@@ -69,3 +78,26 @@ class RATreeDrawer(Drawer):
 
         # return node identifier to generate edges
         return node_id
+
+    def to_interactive_svg(self) -> str:
+        div_id = f'div-{str(uuid4())}'
+
+        css = init_css()
+        ra = init_ra()
+        svg = self.to_svg(True)
+
+        return f'''
+            <style type="text/css">
+                {css}
+            </style>
+            
+            <div id="{div_id}">
+                {svg}
+            </div>
+            
+            <script type="text/javascript">
+                {ra}
+                
+                animate_ra('{div_id}', '{self.root_node_id}')
+            </script>
+        '''

duckdb_kernel/visualization/__init__.py

@@ -1,2 +1,3 @@
+from .Plotly import *
 from .RATreeDrawer import RATreeDrawer
 from .SchemaDrawer import SchemaDrawer

duckdb_kernel/visualization/lib/__init__.py

@@ -0,0 +1,53 @@
+import os
+
+__CSS_INITIALIZED = False
+__RA_INITIALIZED = False
+__PLOTLY_INITIALIZED = False
+
+__location = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
+
+
+def init_css() -> str:
+    global __CSS_INITIALIZED
+
+    if not __CSS_INITIALIZED:
+        with open(os.path.join(__location, 'ra.css')) as ra_file:
+            css = ra_file.read()
+    else:
+        css = ''
+
+    __CSS_INITIALIZED = True
+    return css
+
+
+def init_ra() -> str:
+    global __RA_INITIALIZED
+
+    if not __RA_INITIALIZED:
+        with open(os.path.join(__location, 'ra.js')) as ra_file:
+            ra = ra_file.read()
+    else:
+        ra = ''
+
+    __RA_INITIALIZED = True
+    return ra
+
+
+def init_plotly() -> str:
+    global __PLOTLY_INITIALIZED
+
+    if not __PLOTLY_INITIALIZED:
+        with open(os.path.join(__location, 'plotly-3.0.1.min.js')) as plotly_file:
+            plotly = plotly_file.read()
+    else:
+        plotly = ''
+
+    __PLOTLY_INITIALIZED = True
+    return plotly
+
+
+__all__ = [
+    'init_css',
+    'init_ra',
+    'init_plotly',
+]