Add max width on columns, improve cell result view

Author: Maxteabag

sqlit/app.py

@@ -48,6 +48,7 @@
 from .widgets import (
     AutocompleteDropdown,
     ContextFooter,
+    InlineValueView,
     ResultsFilterInput,
     SqlitDataTable,
     TreeFilterInput,
@@ -191,6 +192,15 @@ class SSMSTUI(
         height: 1fr;
     }
 
+    /* Hide results table when value view is visible */
+    #results-area.value-view-active DataTable {
+        display: none;
+    }
+
+    #results-area.value-view-active #results-filter {
+        display: none;
+    }
+
     /* FastDataTable header styling */
     DataTable > .datatable--header {
         background: $surface-lighten-1;
@@ -540,6 +550,7 @@ def compose(self) -> ComposeResult:
                     with Container(id="results-area"):
                         yield ResultsFilterInput(id="results-filter")
                         yield Lazy(SqlitDataTable(id="results-table", zebra_stripes=True, show_header=False))
+                        yield InlineValueView(id="value-view")
 
             yield Static("", id="idle-scheduler-bar")
             yield Static("Not connected", id="status-bar")

sqlit/cli.py

@@ -144,6 +144,11 @@ def main() -> int:
         metavar="COUNT",
         help="Generate fake data with COUNT rows for mock queries (requires --mock, uses Faker if installed).",
     )
+    parser.add_argument(
+        "--demo-long-text",
+        action="store_true",
+        help="Generate data with long varchar columns to test truncation (use with --mock).",
+    )
     parser.add_argument(
         "--max-rows",
         type=int,
@@ -287,6 +292,10 @@ def main() -> int:
         os.environ["SQLIT_DEMO_ROWS"] = str(args.demo_rows)
     else:
         os.environ.pop("SQLIT_DEMO_ROWS", None)
+    if args.demo_long_text:
+        os.environ["SQLIT_DEMO_LONG_TEXT"] = "1"
+    else:
+        os.environ.pop("SQLIT_DEMO_LONG_TEXT", None)
     if args.max_rows and args.max_rows > 0:
         os.environ["SQLIT_MAX_ROWS"] = str(args.max_rows)
     else:

sqlit/mocks.py

@@ -17,6 +17,14 @@
         sqlit --mock=perf-test --demo-rows=1000    # 1k rows
         sqlit --mock=perf-test --demo-rows=10000   # 10k rows
         sqlit --mock=sqlite-demo --demo-rows=5000  # Any profile works
+
+Long Text Testing:
+    Use --demo-long-text to generate data with long varchar columns.
+    Useful for testing how the UI handles text truncation.
+
+    Examples:
+        sqlit --mock=sqlite-demo --demo-long-text             # 10 rows with long text
+        sqlit --mock=sqlite-demo --demo-long-text --demo-rows=50  # 50 rows with long text
 """
 
 from __future__ import annotations
@@ -74,6 +82,45 @@ def _generate_fake_data(row_count: int) -> tuple[list[str], list[tuple]]:
         return columns, rows
 
 
+def _generate_long_text_data(row_count: int) -> tuple[list[str], list[tuple]]:
+    """Generate data with long varchar columns for testing truncation.
+
+    Creates columns with varying text lengths to test UI truncation behavior.
+    Useful for verifying how long text fields are displayed/truncated.
+
+    Args:
+        row_count: Number of rows to generate.
+
+    Returns:
+        Tuple of (columns, rows).
+    """
+    # Column lengths designed to test truncation boundaries
+    text_lengths = {
+        "short_text": 15,       # Short, no truncation expected
+        "medium_text": 50,      # Around typical column width
+        "long_text": 150,       # Definitely needs truncation
+        "very_long_text": 500,  # Very long content
+        "description": 300,     # Realistic long field
+    }
+
+    columns = ["id", "name"] + list(text_lengths.keys())
+    rows = []
+
+    for i in range(row_count):
+        row: list[object] = [i + 1, f"Row {i + 1}"]
+        for col_name, length in text_lengths.items():
+            # Generate text with visible pattern showing row number and column
+            base = f"[R{i + 1}:{col_name[:6]}]"
+            # Fill with Lorem-style content
+            filler = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
+            text = base + (filler * ((length // len(filler)) + 1))
+            text = text[:length]
+            row.append(text)
+        rows.append(tuple(row))
+
+    return columns, rows
+
+
 class MockConnection:
     """Mock database connection object."""
 
@@ -299,6 +346,18 @@ def execute_query(self, conn: Any, query: str, max_rows: int | None = None) -> t
         if self._query_delay > 0:
             time.sleep(self._query_delay)
 
+        # Check if demo long text mode is enabled (for testing truncation)
+        if os.environ.get("SQLIT_DEMO_LONG_TEXT"):
+            demo_rows_env = os.environ.get("SQLIT_DEMO_ROWS", "10")
+            try:
+                demo_row_count = int(demo_rows_env)
+            except ValueError:
+                demo_row_count = 10
+            cols, rows = _generate_long_text_data(demo_row_count)
+            if max_rows and len(rows) > max_rows:
+                return cols, rows[:max_rows], True
+            return cols, rows, False
+
         # Check if demo rows mode is enabled
         demo_rows_env = os.environ.get("SQLIT_DEMO_ROWS", "")
         if demo_rows_env:

sqlit/state_machine.py

@@ -867,6 +867,32 @@ def is_active(self, app: SSMSTUI) -> bool:
             return False
 
 
+class ValueViewActiveState(State):
+    """Inline value view is active (viewing a cell's full content)."""
+
+    help_category = "Value View"
+
+    def _setup_actions(self) -> None:
+        self.allows("close_value_view", key="escape", label="Close", help="Close value view")
+        self.allows("close_value_view", key="q", label="Close", help="Close value view")
+        self.allows("copy_value_view", key="y", label="Copy", help="Copy value")
+
+    def get_display_bindings(self, app: SSMSTUI) -> tuple[list[DisplayBinding], list[DisplayBinding]]:
+        left: list[DisplayBinding] = [
+            DisplayBinding(key="esc", label="Close", action="close_value_view"),
+            DisplayBinding(key="y", label="Copy", action="copy_value_view"),
+        ]
+        return left, []
+
+    def is_active(self, app: SSMSTUI) -> bool:
+        try:
+            from .widgets import InlineValueView
+            value_view = app.query_one("#value-view", InlineValueView)
+            return value_view.is_visible
+        except Exception:
+            return False
+
+
 class ResultsFocusedState(State):
     """Results table has focus."""
 
@@ -952,6 +978,7 @@ def __init__(self) -> None:
 
         self.results_focused = ResultsFocusedState(parent=self.main_screen)
         self.results_filter_active = ResultsFilterActiveState(parent=self.main_screen)
+        self.value_view_active = ValueViewActiveState(parent=self.main_screen)
 
         self._states = [
             self.modal_active,
@@ -969,6 +996,7 @@ def __init__(self) -> None:
             self.query_normal,
             self.query_focused,
             self.results_filter_active,  # Before results_focused (more specific when filter active)
+            self.value_view_active,  # Before results_focused (more specific when viewing cell)
             self.results_focused,
             self.main_screen,
             self.root,

sqlit/ui/mixins/query.py

@@ -21,6 +21,9 @@
 MAX_FETCH_ROWS = 100000
 MAX_RENDER_ROWS = 100000
 
+# Column content truncation (full value shown in tooltip and copied to clipboard)
+MAX_COLUMN_CONTENT_WIDTH = 100
+
 
 class QueryMixin:
     """Mixin providing query execution functionality.
@@ -217,7 +220,12 @@ def _replace_results_table(self: AppProtocol, columns: list[str], rows: list[tup
             arrow_columns = {col: [] for col in columns}
             arrow_table = pa.table(arrow_columns)
             backend = ArrowBackend(arrow_table)
-            new_table = SqlitDataTable(id=new_id, zebra_stripes=True, backend=backend)
+            new_table = SqlitDataTable(
+                id=new_id,
+                zebra_stripes=True,
+                backend=backend,
+                max_column_content_width=MAX_COLUMN_CONTENT_WIDTH,
+            )
             container.mount(new_table, after=old_table)
             old_table.remove()
             return
@@ -238,7 +246,12 @@ def _replace_results_table(self: AppProtocol, columns: list[str], rows: list[tup
         backend = ArrowBackend(arrow_table)
 
         # Create and mount new table, then remove old
-        new_table = SqlitDataTable(id=new_id, zebra_stripes=True, backend=backend)
+        new_table = SqlitDataTable(
+            id=new_id,
+            zebra_stripes=True,
+            backend=backend,
+            max_column_content_width=MAX_COLUMN_CONTENT_WIDTH,
+        )
         container.mount(new_table, after=old_table)
         old_table.remove()
 
@@ -266,7 +279,12 @@ def _replace_results_table_raw(self: AppProtocol, columns: list[str], rows: list
             arrow_columns = {col: [] for col in columns}
             arrow_table = pa.table(arrow_columns)
             backend = ArrowBackend(arrow_table)
-            new_table = SqlitDataTable(id=new_id, zebra_stripes=True, backend=backend)
+            new_table = SqlitDataTable(
+                id=new_id,
+                zebra_stripes=True,
+                backend=backend,
+                max_column_content_width=MAX_COLUMN_CONTENT_WIDTH,
+            )
             container.mount(new_table, after=old_table)
             old_table.remove()
             return
@@ -279,7 +297,12 @@ def _replace_results_table_raw(self: AppProtocol, columns: list[str], rows: list
         backend = ArrowBackend(arrow_table)
 
         # Create and mount new table, then remove old
-        new_table = SqlitDataTable(id=new_id, zebra_stripes=True, backend=backend)
+        new_table = SqlitDataTable(
+            id=new_id,
+            zebra_stripes=True,
+            backend=backend,
+            max_column_content_width=MAX_COLUMN_CONTENT_WIDTH,
+        )
         container.mount(new_table, after=old_table)
         old_table.remove()
 

sqlit/ui/mixins/results.py

@@ -74,18 +74,55 @@ def fmt(value: object) -> str:
         return "\n".join(lines)
 
     def action_view_cell(self: AppProtocol) -> None:
-        """View the full value of the selected cell."""
-        from ..screens import ValueViewScreen
+        """View the full value of the selected cell inline."""
+        from ...widgets import InlineValueView
 
         table = self.results_table
         if table.row_count <= 0:
             self.notify("No results", severity="warning")
             return
         try:
+            cursor_row, cursor_col = table.cursor_coordinate
             value = table.get_cell_at(table.cursor_coordinate)
         except Exception:
             return
-        self.push_screen(ValueViewScreen(str(value) if value is not None else "NULL", title="Cell Value"))
+
+        # Get column name if available
+        column_name = ""
+        if self._last_result_columns and cursor_col < len(self._last_result_columns):
+            column_name = self._last_result_columns[cursor_col]
+
+        # Show inline value view
+        try:
+            value_view = self.query_one("#value-view", InlineValueView)
+            value_view.set_value(str(value) if value is not None else "NULL", column_name)
+            value_view.show()
+        except Exception:
+            pass
+
+    def action_close_value_view(self: AppProtocol) -> None:
+        """Close the inline value view and return to results table."""
+        from ...widgets import InlineValueView
+
+        try:
+            value_view = self.query_one("#value-view", InlineValueView)
+            if value_view.is_visible:
+                value_view.hide()
+                self.results_table.focus()
+        except Exception:
+            pass
+
+    def action_copy_value_view(self: AppProtocol) -> None:
+        """Copy the value from the inline value view."""
+        from ...widgets import InlineValueView, flash_widget
+
+        try:
+            value_view = self.query_one("#value-view", InlineValueView)
+            if value_view.is_visible:
+                self._copy_text(value_view.value)
+                flash_widget(value_view)
+        except Exception:
+            pass
 
     def action_copy_cell(self: AppProtocol) -> None:
         """Copy the selected cell to clipboard (or internal clipboard)."""