From 76d5f02a16773c62dada3f4f4e447bba74daacb6 Mon Sep 17 00:00:00 2001 From: Peter Adams <18162810+Maxteabag@users.noreply.github.com> Date: Mon, 28 Sep 2026 10:13:08 +0200 Subject: [PATCH] feat(results): toggle compact column widths with w Sizes each result column to the average width of its values (sampled, never narrower than the header) instead of the widest value, so one long outlier no longer pushes the rest of the table off screen. The toggle is app-wide and applies to new results until turned off. --- sqlit/core/keymap.py | 1 + sqlit/domains/results/ui/mixins/results.py | 7 +++ sqlit/domains/shell/app/main.py | 1 + sqlit/domains/shell/state/machine.py | 4 ++ sqlit/domains/shell/state/main_screen.py | 1 + sqlit/domains/shell/ui/mixins/ui_leader.py | 3 + sqlit/shared/ui/protocols/results.py | 1 + sqlit/shared/ui/widgets_tables.py | 63 ++++++++++++++++++++ tests/ui/test_compact_columns.py | 68 ++++++++++++++++++++++ 9 files changed, 149 insertions(+) create mode 100644 tests/ui/test_compact_columns.py 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