plsqlwks 0.1.2__tar.gz → 0.1.3__tar.gz

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plsqlwks
-Version: 0.1.2
+Version: 0.1.3
 Summary: An ncurses SQL and PL/SQL workspace for Oracle databases.
 License-Expression: LicenseRef-plsqlwks-Donationware
 Project-URL: Repository, https://gitlab.com/unununu/plsqlwks

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/plsqlwks/__init__.py

@@ -1,3 +1,3 @@
 """ncurses SQL and PL/SQL workspace."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/plsqlwks/db/execution.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from datetime import datetime
 from decimal import Decimal
 from pathlib import Path
 import re
 from typing import Any, Mapping
+from uuid import uuid4
 
 import oracledb
 
@@ -42,6 +44,13 @@ CREATE_PLSQL_OBJECT_RE = re.compile(
 LOB_DISPLAY_LIMIT = 64 * 1024
 
 
+@dataclass
+class _QueryResultContinuationState:
+    cursor: Any
+    lookahead_row: Any
+    elapsed_seconds: float
+
+
 class ExecutionMixin:
     def execute_statement(
         self,
@@ -109,7 +118,11 @@ class ExecutionMixin:
                 more = ""
                 continuation = None
                 if len(fetched) > self.config.max_rows:
-                    continuation = QueryResultContinuation(cursor, fetched[self.config.max_rows], elapsed)
+                    continuation = self._register_result_continuation(
+                        cursor,
+                        fetched[self.config.max_rows],
+                        elapsed,
+                    )
                     keep_cursor_open = True
                     more = f" (limited to {len(rows)} rows)"
                 return QueryResult(
@@ -146,40 +159,104 @@ class ExecutionMixin:
             if not keep_cursor_open:
                 cursor.close()
 
-    def fetch_more_rows(self, result: QueryResult) -> QueryResultPage:
-        continuation = result.continuation
-        if continuation is None:
-            return QueryResultPage([], result.message)
+    def fetch_more_rows(
+        self,
+        continuation: QueryResultContinuation,
+        loaded_rows: int,
+    ) -> QueryResultPage:
+        state = self._result_continuations.get(continuation.token)
+        if state is None:
+            raise RuntimeError("Query result is stale or no longer available")
         started = datetime.now()
-        fetched = [continuation.lookahead_row, *continuation.cursor.fetchmany(self.config.max_rows)]
-        elapsed = continuation.elapsed_seconds + (datetime.now() - started).total_seconds()
-        result_rows = fetched[: self.config.max_rows]
-        rows, original_rows = materialize_result_rows(result_rows)
-        loaded_rows = len(result.rows) + len(rows)
-        more = ""
-        if len(fetched) > self.config.max_rows:
-            continuation.lookahead_row = fetched[self.config.max_rows]
-            continuation.elapsed_seconds = elapsed
-            more = f" (limited to {loaded_rows} rows)"
-        else:
-            continuation.close()
-            result.continuation = None
-        return QueryResultPage(
-            rows,
-            f"{loaded_rows} row(s){more} in {elapsed:.2f}s",
-            original_rows,
+        try:
+            fetched = [state.lookahead_row, *state.cursor.fetchmany(self.config.max_rows)]
+            elapsed = state.elapsed_seconds + (datetime.now() - started).total_seconds()
+            result_rows = fetched[: self.config.max_rows]
+            rows, original_rows = materialize_result_rows(result_rows)
+            total_loaded_rows = loaded_rows + len(rows)
+            more = ""
+            next_continuation: QueryResultContinuation | None = None
+            if len(fetched) > self.config.max_rows:
+                state.lookahead_row = fetched[self.config.max_rows]
+                state.elapsed_seconds = elapsed
+                next_continuation = continuation
+                more = f" (limited to {total_loaded_rows} rows)"
+            else:
+                self.close_result_continuation(continuation)
+            return QueryResultPage(
+                rows,
+                f"{total_loaded_rows} row(s){more} in {elapsed:.2f}s",
+                original_rows,
+                next_continuation,
+            )
+        except BaseException:
+            try:
+                self.close_result_continuation(continuation)
+            except Exception:
+                pass
+            raise
+
+    def close_result_continuation(self, continuation: QueryResultContinuation) -> None:
+        state = self._result_continuations.pop(continuation.token, None)
+        if state is not None:
+            state.cursor.close()
+
+    def close_all_result_continuations(self) -> None:
+        states = list(self._result_continuations.values())
+        self._result_continuations.clear()
+        first_error: Exception | None = None
+        for state in states:
+            try:
+                state.cursor.close()
+            except Exception as exc:
+                if first_error is None:
+                    first_error = exc
+        if first_error is not None:
+            raise first_error
+
+    def _register_result_continuation(
+        self,
+        cursor: Any,
+        lookahead_row: Any,
+        elapsed_seconds: float,
+    ) -> QueryResultContinuation:
+        continuation = QueryResultContinuation(uuid4().hex)
+        self._result_continuations[continuation.token] = _QueryResultContinuationState(
+            cursor,
+            lookahead_row,
+            elapsed_seconds,
         )
+        return continuation
 
     def execute_script(self, script: str) -> list[QueryResult]:
         results: list[QueryResult] = []
         statements = split_script(script)
         for idx, statement in enumerate(statements, start=1):
             title = f"Statement {idx} lines {statement.start_line}-{statement.end_line}"
-            results.append(self.execute_statement(statement.text, title=title))
+            result = self.execute_statement(statement.text, title=title)
+            self._append_script_result(results, result)
         if not statements:
             results.append(QueryResult("Script", [], [], "No statements to execute."))
         return results
 
+    def _append_script_result(
+        self,
+        results: list[QueryResult],
+        result: QueryResult,
+    ) -> None:
+        if result.columns and not _is_dbms_output_result(result):
+            for previous in reversed(results):
+                if not previous.columns or _is_dbms_output_result(previous):
+                    continue
+                if previous.continuation is not None:
+                    try:
+                        self.close_result_continuation(previous.continuation)
+                    except Exception:
+                        pass
+                    previous.continuation = None
+                break
+        results.append(result)
+
     def export_result(self, result: QueryResult, path: Path) -> None:
         path.parent.mkdir(parents=True, exist_ok=True)
         with path.open("w", encoding="utf-8", newline="") as handle:
@@ -223,6 +300,10 @@ def format_value(value: Any, *, lob_limit: int = LOB_DISPLAY_LIMIT) -> str:
     return display
 
 
+def _is_dbms_output_result(result: QueryResult) -> bool:
+    return len(result.columns) == 1 and result.columns[0].upper() == "DBMS_OUTPUT"
+
+
 def materialize_result_value(
     value: Any,
     *,
@@ -230,6 +311,9 @@ def materialize_result_value(
 ) -> tuple[str, Any]:
     if value is None:
         return NULL_DISPLAY_TOKEN, None
+    if isinstance(value, oracledb.Cursor):
+        value.close()
+        return "<REF CURSOR>", "<REF CURSOR>"
     if isinstance(value, oracledb.LOB):
         if lob_limit <= 0:
             raise ValueError("LOB display limit must be positive")
@@ -243,7 +327,37 @@ def materialize_result_value(
             return display, TruncatedLobValue(type_name, size)
         content = value.read()
         return _format_non_lob_value(content), content
-    return _format_non_lob_value(value), value
+    materialized = _materialize_plain_result_value(value, lob_limit=lob_limit)
+    return _format_non_lob_value(materialized), materialized
+
+
+def _materialize_plain_result_value(value: Any, *, lob_limit: int) -> Any:
+    """Return result data that contains no live python-oracledb handles."""
+    if isinstance(value, oracledb.Cursor):
+        value.close()
+        return "<REF CURSOR>"
+    if isinstance(value, oracledb.LOB):
+        return materialize_result_value(value, lob_limit=lob_limit)[1]
+    if isinstance(value, list):
+        return [_materialize_plain_result_value(item, lob_limit=lob_limit) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_materialize_plain_result_value(item, lob_limit=lob_limit) for item in value)
+    if isinstance(value, dict):
+        return {
+            _materialize_plain_result_value(key, lob_limit=lob_limit): _materialize_plain_result_value(
+                item, lob_limit=lob_limit
+            )
+            for key, item in value.items()
+        }
+    if isinstance(value, set):
+        return {_materialize_plain_result_value(item, lob_limit=lob_limit) for item in value}
+    if isinstance(value, frozenset):
+        return frozenset(
+            _materialize_plain_result_value(item, lob_limit=lob_limit) for item in value
+        )
+    if type(value).__module__.startswith("oracledb"):
+        return str(value)
+    return value
 
 
 def _format_non_lob_value(value: Any) -> str:

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/plsqlwks/db/models.py

@@ -39,18 +39,9 @@ class RowInsertResult:
     display_values: list[str]
 
 
-@dataclass
+@dataclass(frozen=True)
 class QueryResultContinuation:
-    cursor: Any
-    lookahead_row: Any
-    elapsed_seconds: float
-    closed: bool = False
-
-    def close(self) -> None:
-        if self.closed:
-            return
-        self.closed = True
-        self.cursor.close()
+    token: str = field(repr=False)
 
 
 @dataclass(frozen=True)
@@ -58,6 +49,7 @@ class QueryResultPage:
     rows: list[list[str]]
     message: str
     original_rows: list[list[Any]] = field(default_factory=list, repr=False, compare=False)
+    continuation: QueryResultContinuation | None = field(default=None, repr=False, compare=False)
 
 
 @dataclass

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/plsqlwks/db/session.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import oracledb
+from typing import Any
 
 from ..config import AppConfig
 from .editing import EditingMixin
@@ -24,27 +25,41 @@ class OracleWorkspace(
         self.read_only = config.read_only
         self.pending_rows_changed = 0
         self.pending_unknown_changes = False
+        self._result_continuations: dict[str, Any] = {}
 
     def connect(self) -> None:
         from . import read_password
 
         password = read_password(self.config.password_file)
         self.close()
-        self.connection = oracledb.connect(
+        connection = oracledb.connect(
             user=self.config.user,
             password=password,
             dsn=self.config.dsn,
         )
-        self.apply_autocommit()
-        self.enable_dbms_output()
+        self.connection = connection
+        try:
+            self.apply_autocommit()
+            self.enable_dbms_output()
+        except Exception:
+            try:
+                connection.close()
+            except Exception:
+                pass
+            self.connection = None
+            raise
 
     def close(self) -> None:
-        if self.connection is not None:
+        connection = self.connection
+        try:
+            self.close_all_result_continuations()
+        finally:
             try:
-                self.connection.close()
+                if connection is not None:
+                    connection.close()
             finally:
                 self.connection = None
-        self.clear_pending_transaction()
+                self.clear_pending_transaction()
 
     def ensure_connected(self) -> oracledb.Connection:
         if self.connection is None:
@@ -63,8 +78,9 @@ class OracleWorkspace(
         return True
 
     def set_autocommit(self, enabled: bool) -> None:
+        if self.connection is not None and hasattr(self.connection, "autocommit"):
+            self.connection.autocommit = enabled
         self.autocommit = enabled
-        self.apply_autocommit()
 
     def set_read_only(self, enabled: bool) -> None:
         self.read_only = enabled

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/plsqlwks/ui/__init__.py

@@ -36,6 +36,7 @@ from .browser import *
 from .menu import *
 from .commands import *
 from .results import *
+from .db_worker import *
 from .state import *
 from .app import App, main, parse_args
 
@@ -130,6 +131,12 @@ __all__ = (
     "DbOperationEvent",
     "DbOperationFinished",
     "DbOperationProgress",
+    "DatabaseWorker",
+    "DbCommandHandle",
+    "DbSessionState",
+    "DbWorkerEvent",
+    "DbWorkerFinished",
+    "DbWorkerProgress",
     "ERROR_LOCATION_PRIORITY_EXACT",
     "ERROR_LOCATION_PRIORITY_FALLBACK",
     "ERROR_LOCATION_PRIORITY_OFFSET",

{plsqlwks-0.1.2 → plsqlwks-0.1.3}/plsqlwks/ui/app.py

@@ -8,6 +8,7 @@ from ..config import AppConfig, load_config
 from ..db import OracleWorkspace, workspace_health
 from ..workspace import ensure_workspace, list_workspace_files
 from .keys import configure_utf8_locale, disable_extended_keyboard_reporting, enable_extended_keyboard_reporting
+from .db_worker import DatabaseWorker
 from .state import UIState
 from .app_render import AppRenderMixin
 from .app_db import AppDbMixin
@@ -77,7 +78,8 @@ class App(
 ):
     def __init__(self, screen: curses.window, config: AppConfig):
         self.screen = screen
-        self.state = UIState(config=config, db=OracleWorkspace(config))
+        self.db_worker = DatabaseWorker(OracleWorkspace(config))
+        self.state = UIState(config=config, db=self.db_worker.session_state)
         self.state.files = list_workspace_files(config)
         self.running = True
         self.message_lines: list[str] = []
@@ -115,16 +117,38 @@ class App(
                     self.handle_key(key)
                 self.poll_db_operation()
         finally:
-            self.wait_for_db_operation()
-            if extended_keyboard_enabled:
-                disable_extended_keyboard_reporting()
+            shutdown_timeout = 5.0 if self.state.db_operation is not None else None
             try:
-                curses.nl()
-            except curses.error:
-                pass
-            try:
-                curses.noraw()
-            except curses.error:
-                pass
-            self.close_all_result_continuations()
-            self.state.db.close()
+                try:
+                    if self.state.db_operation is not None:
+                        try:
+                            self.db_worker.cancel_current_operation(
+                                self.state.db_operation.handle.command_id
+                            )
+                        except Exception:
+                            pass
+                    if shutdown_timeout is None:
+                        self.wait_for_db_operation()
+                    else:
+                        self.wait_for_db_operation(timeout=shutdown_timeout)
+                finally:
+                    if extended_keyboard_enabled:
+                        disable_extended_keyboard_reporting()
+            finally:
+                try:
+                    try:
+                        curses.nl()
+                    except curses.error:
+                        pass
+                    try:
+                        curses.noraw()
+                    except curses.error:
+                        pass
+                finally:
+                    try:
+                        self.close_all_result_continuations()
+                    finally:
+                        if shutdown_timeout is None:
+                            self.shutdown_database_worker()
+                        else:
+                            self.shutdown_database_worker(timeout=shutdown_timeout)