diff --git a/sqlit/core/keymap.py b/sqlit/core/keymap.py index 522e4567..d7bfe2f1 100644 --- a/sqlit/core/keymap.py +++ b/sqlit/core/keymap.py @@ -192,6 +192,7 @@ def _build_leader_commands(self) -> list[LeaderCommandDef]: # View LeaderCommandDef("e", "toggle_explorer", "Toggle Explorer", "View"), LeaderCommandDef("f", "toggle_fullscreen", "Toggle Maximize", "View"), + LeaderCommandDef("w", "toggle_compact_columns", "Compact Columns", "View"), # Connection LeaderCommandDef("c", "show_connection_picker", "Connect", "Connection"), LeaderCommandDef("x", "disconnect", "Disconnect", "Connection", guard="has_connection"), diff --git a/sqlit/domains/results/ui/mixins/results.py b/sqlit/domains/results/ui/mixins/results.py index c7b34568..7ded656d 100644 --- a/sqlit/domains/results/ui/mixins/results.py +++ b/sqlit/domains/results/ui/mixins/results.py @@ -1341,6 +1341,13 @@ def handle_pick(index: int | None) -> None: self.push_screen(ColumnPickerScreen(labels), handle_pick) + def action_toggle_compact_columns(self: ResultsMixinHost) -> None: + """Toggle sizing result columns to their average value width instead of the widest.""" + enabled = not self.results_compact_columns + self.results_compact_columns = enabled + for table in self.results_area.query(SqlitDataTable): + table.set_compact_columns(enabled) + def action_clear_results(self: ResultsMixinHost) -> None: """Clear the results table.""" if self.results_area.has_class("stacked-mode"): diff --git a/sqlit/domains/shell/app/main.py b/sqlit/domains/shell/app/main.py index 2f85d91b..f42e8db8 100644 --- a/sqlit/domains/shell/app/main.py +++ b/sqlit/domains/shell/app/main.py @@ -153,6 +153,7 @@ def __init__( self._last_result_rows: list[tuple[Any, ...]] = [] self._last_result_row_count: int = 0 self._results_table_counter: int = 0 + self.results_compact_columns: bool = False self._internal_clipboard: str = "" # Undo/redo history for query editor self._undo_history: Any = None # Lazy init UndoHistory diff --git a/sqlit/domains/shell/state/machine.py b/sqlit/domains/shell/state/machine.py index cea1cb8c..86a8a5c9 100644 --- a/sqlit/domains/shell/state/machine.py +++ b/sqlit/domains/shell/state/machine.py @@ -209,6 +209,10 @@ def lk(action: str, menu: str, fallback: str) -> str: s.binding(f"{leader_key}{lk('change_theme', 'leader', 't')}", "Change theme") s.binding(f"{leader_key}{lk('toggle_fullscreen', 'leader', 'f')}", "Toggle fullscreen pane") s.binding(f"{leader_key}{lk('toggle_explorer', 'leader', 'e')}", "Toggle explorer visibility") + s.binding( + f"{leader_key}{lk('toggle_compact_columns', 'leader', 'w')}", + "Toggle compact result columns (average width)", + ) sections.append(s) # NAVIGATION diff --git a/sqlit/domains/shell/state/main_screen.py b/sqlit/domains/shell/state/main_screen.py index 608e3e52..287c679a 100644 --- a/sqlit/domains/shell/state/main_screen.py +++ b/sqlit/domains/shell/state/main_screen.py @@ -19,6 +19,7 @@ def _setup_actions(self) -> None: self.allows("show_connection_picker") self.allows("disconnect", guard=lambda app: app.has_connection) self.allows("toggle_fullscreen", help="Toggle fullscreen") + self.allows("toggle_compact_columns", help="Toggle compact result columns") self.allows("change_theme") self.allows("toggle_process_worker", help="Toggle process worker") self.allows("leader_key", key="", label="Commands") diff --git a/sqlit/domains/shell/ui/mixins/ui_leader.py b/sqlit/domains/shell/ui/mixins/ui_leader.py index 8ad69bdd..e00af6de 100644 --- a/sqlit/domains/shell/ui/mixins/ui_leader.py +++ b/sqlit/domains/shell/ui/mixins/ui_leader.py @@ -91,6 +91,9 @@ def action_leader_toggle_explorer(self: UINavigationMixinHost) -> None: def action_leader_toggle_fullscreen(self: UINavigationMixinHost) -> None: self._execute_leader_command("toggle_fullscreen") + def action_leader_toggle_compact_columns(self: UINavigationMixinHost) -> None: + self._execute_leader_command("toggle_compact_columns") + def action_leader_show_connection_picker(self: UINavigationMixinHost) -> None: self._execute_leader_command("show_connection_picker") diff --git a/sqlit/shared/ui/protocols/results.py b/sqlit/shared/ui/protocols/results.py index 66c71985..ac11dc06 100644 --- a/sqlit/shared/ui/protocols/results.py +++ b/sqlit/shared/ui/protocols/results.py @@ -18,6 +18,7 @@ class ResultsStateProtocol(Protocol): _last_query_table: dict[str, Any] | None _pending_result_table_info: dict[str, Any] | None _results_table_counter: int + results_compact_columns: bool _results_filter_visible: bool _results_filter_text: str _results_filter_matches: list[int] diff --git a/sqlit/shared/ui/widgets_tables.py b/sqlit/shared/ui/widgets_tables.py index ff4dcfc4..afec0599 100644 --- a/sqlit/shared/ui/widgets_tables.py +++ b/sqlit/shared/ui/widgets_tables.py @@ -2,6 +2,7 @@ from __future__ import annotations +import math from collections.abc import Iterable from datetime import date, datetime, time, timedelta from decimal import Decimal @@ -18,6 +19,7 @@ from textual.events import Key from textual.strip import Strip from textual_fastdatatable import DataTable as FastDataTable +from textual_fastdatatable.column import CELL_X_PADDING, Column def normalize_arrow_value(value: Any) -> Any: @@ -64,9 +66,70 @@ class SqlitDataTable(FastDataTable): # Track if a manual tooltip is being shown (via 'v' key) _manual_tooltip_active: bool = False + # Compact columns size each column to its average value width rather than + # its widest, sampling this many rows so large results toggle instantly. + COMPACT_SAMPLE_ROWS = 200 + COMPACT_MIN_WIDTH = 3 + + _compact_columns: bool = False + def __init__(self, *, data: Any | None = None, **kwargs: Any) -> None: super().__init__(data=_stringify_uuid_data(data), **kwargs) + def on_mount(self) -> None: + # The compact toggle is app-wide, so tables built for later queries + # pick it up too. + if getattr(self.app, "results_compact_columns", False): + self.set_compact_columns(True) + + @property + def ordered_columns(self) -> list[Column]: + fresh = self._ordered_columns is None + columns = super().ordered_columns + if fresh and self._compact_columns: + self._apply_compact_widths(columns) + return columns + + @property + def compact_columns(self) -> bool: + return self._compact_columns + + def set_compact_columns(self, enabled: bool) -> None: + """Switch between average-width (compact) and full-width columns.""" + if enabled == self._compact_columns: + return + self._compact_columns = enabled + # Columns are rebuilt from the backend on next access, which re-applies + # (or drops) the compact widths. + self._ordered_columns = None + self._clear_caches() + self._require_update_dimensions = True + self.refresh() + + def _apply_compact_widths(self, columns: list[Column]) -> None: + backend = self.backend + if backend is None or backend.row_count == 0: + return + row_count = backend.row_count + # Measure with Rich directly: DataTable._measure only exists in newer + # textual-fastdatatable releases. + console = self.app.console + options = console.options + + def measure(renderable: Any) -> int: + return console.measure(renderable, options=options).maximum + + step = max(1, row_count // self.COMPACT_SAMPLE_ROWS) + sample = range(0, row_count, step) + for index, column in enumerate(columns): + widths = [measure(self._format_cell(backend.get_cell_at(row, index), column)) for row in sample] + average = math.ceil(sum(widths) / len(widths)) + # Keep the header readable; only the data is squeezed to its average. + floor = max(self.COMPACT_MIN_WIDTH, measure(column.label)) + full_width = column.render_width - CELL_X_PADDING + column.width = min(full_width, max(floor, average)) + column.auto_width = False + def add_rows(self, rows: Iterable[Iterable[Any]]) -> list[int]: return super().add_rows(_stringify_uuid_rows(rows)) diff --git a/tests/ui/test_compact_columns.py b/tests/ui/test_compact_columns.py new file mode 100644 index 00000000..e246fd49 --- /dev/null +++ b/tests/ui/test_compact_columns.py @@ -0,0 +1,68 @@ +"""Leader+w sizes result columns to the average value width instead of the widest.""" + +from __future__ import annotations + +import pytest + +from sqlit.domains.shell.app.main import SSMSTUI + +from .mocks import ( + MockConnectionStore, + MockSettingsStore, + build_test_services, + create_test_connection, +) + +# One long outlier among short values: full width follows the outlier, +# compact width follows the typical value. +ROWS = [(i, "ab", "x" * 60 if i == 0 else "short") for i in range(10)] + + +def _widths(app: SSMSTUI) -> list[int]: + return [column.render_width for column in app.results_table.ordered_columns] + + +async def _show_results(app: SSMSTUI, pilot) -> None: + await app._display_query_results( + columns=["id", "code", "description"], rows=ROWS, row_count=len(ROWS), + truncated=False, elapsed_ms=0, + ) + await pilot.pause() + + +@pytest.mark.asyncio +async def test_leader_w_toggles_compact_columns_and_persists_for_new_results() -> None: + connection = create_test_connection("test-db", "sqlite") + services = build_test_services( + connection_store=MockConnectionStore([connection]), + settings_store=MockSettingsStore({"theme": "tokyo-night"}), + ) + app = SSMSTUI(services=services) + + async with app.run_test(size=(120, 40)) as pilot: + await pilot.pause() + await _show_results(app, pilot) + app.results_table.focus() + await pilot.pause() + full = _widths(app) + assert full[2] == 60 + 2 + + await pilot.press("space", "w") + await pilot.pause() + assert app.results_compact_columns + compact = _widths(app) + # description: (60 + 9 * 5) / 10 -> 11 cells; short data keeps its header readable. + assert compact[2] == 11 + 2 + assert compact[1] == len("code") + 2 + assert compact[0] == full[0] # never wider than its full width + assert app.results_table.virtual_size.width == sum(compact) + + # A new query result keeps the compact layout. + await _show_results(app, pilot) + assert _widths(app) == compact + + app.results_table.focus() + await pilot.press("space", "w") + await pilot.pause() + assert not app.results_compact_columns + assert _widths(app) == full