sqlit-tui 1.2.7__tar.gz → 1.2.8__tar.gz

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlit-tui
-Version: 1.2.7
+Version: 1.2.8
 Summary: A terminal UI for SQL Server, PostgreSQL, MySQL, SQLite, Oracle, and more
 Project-URL: Homepage, https://github.com/Maxteabag/sqlit
 Project-URL: Repository, https://github.com/Maxteabag/sqlit

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/sqlit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2.7'
-__version_tuple__ = version_tuple = (1, 2, 7)
+__version__ = version = '1.2.8'
+__version_tuple__ = version_tuple = (1, 2, 8)
 
 __commit_id__ = commit_id = None

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/sqlit/domains/connections/providers/adapters/base.py

@@ -194,6 +194,11 @@ class DatabaseAdapter(ABC):
         """
         return False
 
+    @property
+    def supports_process_worker(self) -> bool:
+        """Whether this adapter supports running queries in a separate process."""
+        return True
+
     @property
     def test_query(self) -> str:
         """A simple query to test the connection.

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/sqlit/domains/connections/providers/duckdb/adapter.py

@@ -55,6 +55,11 @@ class DuckDBAdapter(DatabaseAdapter):
         """DuckDB supports sequences."""
         return True
 
+    @property
+    def supports_process_worker(self) -> bool:
+        """DuckDB file locking conflicts with multi-process connections."""
+        return False
+
     @property
     def default_schema(self) -> str:
         return "main"

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/sqlit/domains/explorer/ui/tree/loaders.py

@@ -66,6 +66,14 @@ def load_columns_async(host: TreeMixinHost, node: Any, data: TableNode | ViewNod
             use_worker = bool(getattr(runtime, "process_worker", False)) and not bool(
                 getattr(getattr(runtime, "mock", None), "enabled", False)
             )
+            if use_worker:
+                try:
+                    from sqlit.domains.process_worker.app.support import supports_process_worker
+                except Exception:
+                    pass
+                else:
+                    provider = getattr(host, "current_provider", None)
+                    use_worker = supports_process_worker(provider)
             if use_worker and hasattr(host, "_get_process_worker_client_async"):
                 client = await host._get_process_worker_client_async()  # type: ignore[attr-defined]
             else:
@@ -159,6 +167,14 @@ def load_folder_async(host: TreeMixinHost, node: Any, data: FolderNode) -> None:
             use_worker = bool(getattr(runtime, "process_worker", False)) and not bool(
                 getattr(getattr(runtime, "mock", None), "enabled", False)
             )
+            if use_worker:
+                try:
+                    from sqlit.domains.process_worker.app.support import supports_process_worker
+                except Exception:
+                    pass
+                else:
+                    provider = getattr(host, "current_provider", None)
+                    use_worker = supports_process_worker(provider)
             client = None
             if use_worker and hasattr(host, "_get_process_worker_client_async"):
                 client = await host._get_process_worker_client_async()  # type: ignore[attr-defined]

sqlit_tui-1.2.8/sqlit/domains/process_worker/app/support.py

@@ -0,0 +1,15 @@
+"""Helpers for deciding process worker availability."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def supports_process_worker(provider: Any) -> bool:
+    """Return False when a provider or adapter opts out of process workers."""
+    adapter = getattr(provider, "connection_factory", None)
+    for candidate in (adapter, provider):
+        value = getattr(candidate, "supports_process_worker", None)
+        if isinstance(value, bool):
+            return value
+    return True

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/sqlit/domains/process_worker/ui/mixins/process_worker_lifecycle.py

@@ -22,7 +22,11 @@ class ProcessWorkerLifecycleMixin(LifecycleHooksMixin):
             return False
         if bool(getattr(getattr(runtime, "mock", None), "enabled", False)):
             return False
-        return True
+        try:
+            from sqlit.domains.process_worker.app.support import supports_process_worker
+        except Exception:
+            return True
+        return supports_process_worker(provider)
 
     def _get_process_worker_client(self: QueryMixinHost) -> Any | None:
         client = getattr(self, "_process_worker_client", None)

{sqlit_tui-1.2.7 → sqlit_tui-1.2.8}/tests/test_duckdb.py

@@ -2,6 +2,11 @@
 
 from __future__ import annotations
 
+import sys
+from pathlib import Path
+
+import pytest
+
 from .test_database_base import BaseDatabaseTestsWithLimit, DatabaseTestConfig
 
 
@@ -128,3 +133,86 @@ class TestDuckDBIntegration(BaseDatabaseTestsWithLimit):
         )
         # Should fail gracefully
         assert result.returncode != 0 or "error" in result.stdout.lower() or "error" in result.stderr.lower()
+
+
+@pytest.mark.parametrize("use_worker", [True, False])
+def test_duckdb_process_worker_no_lock(duckdb_db, use_worker):
+    """Ensure DuckDB queries work with or without the process worker."""
+    if sys.platform.startswith("win"):
+        pytest.skip("DuckDB file-lock behavior differs on Windows")
+
+    from sqlit.domains.connections.app.session import ConnectionSession
+    from sqlit.domains.connections.domain.config import ConnectionConfig, FileEndpoint
+    from sqlit.domains.process_worker.app.process_worker_client import ProcessWorkerClient
+    from sqlit.domains.process_worker.app.support import supports_process_worker
+    from sqlit.domains.query.app.transaction import TransactionExecutor
+
+    config = ConnectionConfig(
+        name="duckdb_lock_test",
+        db_type="duckdb",
+        endpoint=FileEndpoint(path=str(duckdb_db)),
+    )
+
+    session = ConnectionSession.create(config)
+    try:
+        outcome = None
+        use_worker_effective = bool(use_worker and supports_process_worker(session.provider))
+        if use_worker_effective:
+            client = ProcessWorkerClient()
+            try:
+                outcome = client.execute("SELECT 1", config, max_rows=1)
+            finally:
+                client.close()
+        else:
+            executor = TransactionExecutor(config=config, provider=session.provider)
+            try:
+                executor.execute("SELECT 1", max_rows=1)
+            finally:
+                executor.close()
+    finally:
+        session.close()
+
+    if use_worker_effective:
+        assert outcome is not None
+        assert outcome.error is None, f"Unexpected error: {outcome.error}"
+
+
+def test_duckdb_schema_service_repo_file(tmp_path):
+    """Validate explorer schema service against the repo DuckDB fixture."""
+    if sys.platform.startswith("win"):
+        pytest.skip("DuckDB file-lock behavior differs on Windows")
+
+    from sqlit.domains.connections.app.session import ConnectionSession
+    from sqlit.domains.connections.domain.config import ConnectionConfig, FileEndpoint
+    from sqlit.domains.explorer.app.schema_service import ExplorerSchemaService
+    try:
+        import duckdb  # type: ignore
+    except Exception:
+        pytest.skip("duckdb is not installed")
+
+    db_path = Path(tmp_path) / "cats.duckdb"
+    conn = duckdb.connect(str(db_path))
+    conn.execute("CREATE TABLE cats (id INTEGER, name VARCHAR, motto VARCHAR)")
+    conn.execute("INSERT INTO cats VALUES (1, 'Mochi', 'Nap hard, snack harder')")
+    conn.execute("INSERT INTO cats VALUES (2, 'Nimbus', 'Gravity is optional')")
+    conn.close()
+
+    config = ConnectionConfig(
+        name="duckdb_repo_fixture",
+        db_type="duckdb",
+        endpoint=FileEndpoint(path=str(db_path)),
+    )
+
+    session = ConnectionSession.create(config)
+    try:
+        service = ExplorerSchemaService(session=session, object_cache={})
+        tables = service.list_folder_items("tables", None)
+        table_names = {name for kind, _, name in tables if kind == "table"}
+        assert "cats" in table_names
+
+        schema = session.provider.capabilities.default_schema or "main"
+        columns = service.list_columns(None, schema, "cats")
+        column_names = {col.name for col in columns}
+        assert {"id", "name", "motto"}.issubset(column_names)
+    finally:
+        session.close()