dataframe-textual 1.12.0__py3-none-any.whl → 1.16.2__py3-none-any.whl

dataframe_textual/data_frame_table.py

@@ -3,13 +3,15 @@
 import sys
 from collections import defaultdict, deque
 from dataclasses import dataclass
+from itertools import zip_longest
 from pathlib import Path
 from textwrap import dedent
 from typing import Any
 
 import polars as pl
-from rich.text import Text
+from rich.text import Text, TextType
 from textual import work
+from textual._two_way_dict import TwoWayDict
 from textual.coordinate import Coordinate
 from textual.events import Click
 from textual.reactive import reactive
@@ -18,8 +20,11 @@ from textual.widgets import DataTable, TabPane
 from textual.widgets._data_table import (
     CellDoesNotExist,
     CellKey,
+    CellType,
     ColumnKey,
     CursorType,
+    DuplicateKey,
+    Row,
     RowKey,
 )
 
@@ -34,12 +39,13 @@ from .common import (
     format_row,
     get_next_item,
     parse_placeholders,
+    round_to_nearest_hundreds,
     sleep_async,
     tentative_expr,
     validate_expr,
 )
 from .sql_screen import AdvancedSqlScreen, SimpleSqlScreen
-from .table_screen import FrequencyScreen, RowDetailScreen, StatisticsScreen
+from .table_screen import FrequencyScreen, MetaColumnScreen, MetaShape, RowDetailScreen, StatisticsScreen
 from .yes_no_screen import (
     AddColumnScreen,
     AddLinkScreen,
@@ -57,6 +63,9 @@ from .yes_no_screen import (
 # Color for highlighting selections and matches
 HIGHLIGHT_COLOR = "red"
 
+# Buffer size for loading rows
+BUFFER_SIZE = 5
+
 # Warning threshold for loading rows
 WARN_ROWS_THRESHOLD = 50_000
 
@@ -115,7 +124,7 @@ class DataFrameTable(DataTable):
         - **g** - ⬆️ Jump to first row
         - **G** - ⬇️ Jump to last row
         - **HOME/END** - 🎯 Jump to first/last column
-        - **Ctrl+HOME/END** - 🎯 Jump to page top/bottom
+        - **Ctrl+HOME/END** - 🎯 Jump to page top/top
         - **Ctrl+F** - 📜 Page down
         - **Ctrl+B** - 📜 Page up
         - **PgUp/PgDn** - 📜 Page up/down
@@ -125,11 +134,13 @@ class DataFrameTable(DataTable):
         - **U** - 🔄 Redo last undone action
         - **Ctrl+U** - 🔁 Reset to initial state
 
-        ## 👁️ Viewing & Display
+        ## 👁️ Display
         - **Enter** - 📋 Show row details in modal
         - **F** - 📊 Show frequency distribution
         - **s** - 📈 Show statistics for current column
         - **S** - 📊 Show statistics for entire dataframe
+        - **m** - 📐 Show dataframe metadata (row/column counts)
+        - **M** - 📋 Show column metadata (ID, name, type)
         - **h** - 👁️ Hide current column
         - **H** - 👀 Show all hidden rows/columns
         - **_** - 📏 Expand column to full width
@@ -143,31 +154,31 @@ class DataFrameTable(DataTable):
         - **]** - 🔽 Sort column descending
         - *(Multi-column sort supported)*
 
-        ## 🔍 Searching & Filtering
-        - **|** - 🔎 Search in current column with expression
-        - **\\\\** - 🔎 Search in current column using cursor value
+        ## ✅ Row Selection
+        - **\\\\** - ✅ Select rows in current column using cursor value
+        - **|** - ✅ Select rows with expression
+        - **'** - ✅ Select/deselect current row
+        - **t** - 💡 Toggle row selection (invert all)
+        - **T** - 🧹 Clear all selections and matches
+        - **{** - ⬆️ Go to previous selected row
+        - **}** - ⬇️ Go to next selected row
+        - *(Supports case-insensitive & whole-word matching)*
+
+        ## 🔎 Find & Replace
         - **/** - 🔎 Find in current column with cursor value
         - **?** - 🔎 Find in current column with expression
         - **;** - 🌐 Global find using cursor value
         - **:** - 🌐 Global find with expression
         - **n** - ⬇️ Go to next match
         - **N** - ⬆️ Go to previous match
-        - **v** - 👁️ View/filter rows by cell or selected rows and hide others
-        - **V** - 🔧 View/filter rows by expression and hide others
-        - *(All search/find support case-insensitive & whole-word matching)*
-
-        ## ✏️ Replace
         - **r** - 🔄 Replace in current column (interactive or all)
         - **R** - 🔄 Replace across all columns (interactive or all)
         - *(Supports case-insensitive & whole-word matching)*
 
-        ## ✅ Selection & Filter
-        - **'** - ✓️ Select/deselect current row
-        - **t** - 💡 Toggle row selection (invert all)
-        - **T** - 🧹 Clear all selections and matches
-        - **{** - ⬆️ Go to previous selected row
-        - **}** - ⬇️ Go to next selected row
-        - **"** - 📍 Filter selected rows and remove others
+        ## 👁️ View & Filter
+        - **"** - 📍 Filter selected rows (removes others)
+        - **v** - 👁️ View rows that are selected or contain matching cells (hide others)
+        - **V** - 🔧 View rows by expression (hides others)
 
         ## 🔍 SQL Interface
         - **l** - 💬 Open simple SQL interface (select columns & where clause)
@@ -212,6 +223,8 @@ class DataFrameTable(DataTable):
         ("G", "jump_bottom", "Jump to bottom"),
         ("ctrl+f", "forward_page", "Page down"),
         ("ctrl+b", "backward_page", "Page up"),
+        ("pageup", "page_up", "Page up"),
+        ("pagedown", "page_down", "Page down"),
         # Undo/Redo/Reset
         ("u", "undo", "Undo"),
         ("U", "redo", "Redo"),
@@ -230,7 +243,9 @@ class DataFrameTable(DataTable):
         ("ctrl+r", "copy_row", "Copy row to clipboard"),
         # Save
         ("ctrl+s", "save_to_file", "Save to file"),
-        # Detail, Frequency, and Statistics
+        # Metadata, Detail, Frequency, and Statistics
+        ("m", "metadata_shape", "Show metadata for row count and column count"),
+        ("M", "metadata_column", "Show metadata for column"),
         ("enter", "view_row_detail", "View row details"),
         ("F", "show_frequency", "Show frequency"),
         ("s", "show_statistics", "Show statistics for column"),
@@ -242,25 +257,23 @@ class DataFrameTable(DataTable):
         ("v", "view_rows", "View rows"),
         ("V", "view_rows_expr", "View rows by expression"),
         ("quotation_mark", "filter_rows", "Filter selected"),  # `"`
-        # Search
-        ("backslash", "search_cursor_value", "Search column with cursor value"),  # `\`
-        ("vertical_line", "search_expr", "Search column with expression"),  # `|`
+        # Row Selection
+        ("backslash", "select_row_cursor_value", "Select rows with cursor value in current column"),  # `\`
+        ("vertical_line", "select_row_expr", "Select rows with expression"),  # `|`
         ("right_curly_bracket", "next_selected_row", "Go to next selected row"),  # `}`
         ("left_curly_bracket", "previous_selected_row", "Go to previous selected row"),  # `{`
-        # Find
+        ("apostrophe", "toggle_row_selection", "Toggle row selection"),  # `'`
+        ("t", "toggle_selections", "Toggle all row selections"),
+        ("T", "clear_selections_and_matches", "Clear selections"),
+        # Find & Replace
         ("slash", "find_cursor_value", "Find in column with cursor value"),  # `/`
         ("question_mark", "find_expr", "Find in column with expression"),  # `?`
         ("semicolon", "find_cursor_value('global')", "Global find with cursor value"),  # `;`
         ("colon", "find_expr('global')", "Global find with expression"),  # `:`
         ("n", "next_match", "Go to next match"),  # `n`
         ("N", "previous_match", "Go to previous match"),  # `Shift+n`
-        # Replace
         ("r", "replace", "Replace in column"),  # `r`
         ("R", "replace_global", "Replace global"),  # `Shift+R`
-        # Selection
-        ("apostrophe", "toggle_row_selection", "Toggle row selection"),  # `'`
-        ("t", "toggle_selections", "Toggle all row selections"),
-        ("T", "clear_selections_and_matches", "Clear selections"),
         # Delete
         ("delete", "clear_cell", "Clear cell"),
         ("minus", "delete_column", "Delete column"),  # `-`
@@ -316,9 +329,9 @@ class DataFrameTable(DataTable):
         self.filename = filename or "untitled.csv"  # Current filename
         self.tabname = tabname or Path(filename).stem  # Tab name
         # Pagination & Loading
-        self.INITIAL_BATCH_SIZE = (self.app.size.height // 100 + 1) * 100
-        self.BATCH_SIZE = self.INITIAL_BATCH_SIZE // 2
+        self.BATCH_SIZE = max((self.app.size.height // 100 + 1) * 100, 100)
         self.loaded_rows = 0  # Track how many rows are currently loaded
+        self.loaded_ranges: list[tuple[int, int]] = []  # List of (start, end) row indices that are loaded
 
         # State tracking (all 0-based indexing)
         self.sorted_columns: dict[str, bool] = {}  # col_name -> descending
@@ -419,7 +432,7 @@ class DataFrameTable(DataTable):
         Returns:
             bool: True if there are hidden rows, False otherwise.
         """
-        return any(v for v in self.visible_rows if v is False)
+        return any(1 for v in self.visible_rows if v is False)
 
     @property
     def ordered_selected_rows(self) -> list[int]:
@@ -452,6 +465,22 @@ class DataFrameTable(DataTable):
         """
         return self.histories[-1] if self.histories else None
 
+    def _round_to_nearest_hundreds(self, num: int):
+        """Round a number to the nearest hundreds.
+
+        Args:
+            num: The number to round.
+        """
+        return round_to_nearest_hundreds(num, N=self.BATCH_SIZE)
+
+    def get_row_idx(self, row_key: RowKey) -> int:
+        """Get the row index for a given table row key.
+
+        Args:
+            row_key: Row key as string.
+        """
+        return super().get_row_index(row_key)
+
     def get_row_key(self, row_idx: int) -> RowKey:
         """Get the row key for a given table row index.
 
@@ -463,7 +492,18 @@ class DataFrameTable(DataTable):
         """
         return self._row_locations.get_key(row_idx)
 
-    def get_column_key(self, col_idx: int) -> ColumnKey:
+    def get_col_idx(self, col_key: ColumnKey) -> int:
+        """Get the column index for a given table column key.
+
+        Args:
+            col_key: Column key as string.
+
+        Returns:
+            Corresponding column index as int.
+        """
+        return super().get_column_index(col_key)
+
+    def get_col_key(self, col_idx: int) -> ColumnKey:
         """Get the column key for a given table column index.
 
         Args:
@@ -474,11 +514,11 @@ class DataFrameTable(DataTable):
         """
         return self._column_locations.get_key(col_idx)
 
-    def should_highlight(self, cursor: Coordinate, target_cell: Coordinate, type_of_cursor: CursorType) -> bool:
+    def _should_highlight(self, cursor: Coordinate, target_cell: Coordinate, type_of_cursor: CursorType) -> bool:
         """Determine if the given cell should be highlighted because of the cursor.
 
-        In "cell" mode, also highlights the row and column headers. In "row" and "column"
-        modes, highlights the entire row or column respectively.
+        In "cell" mode, also highlights the row and column headers. This overrides the default
+        behavior of DataTable which only highlights the exact cell under the cursor.
 
         Args:
             cursor: The current position of the cursor.
@@ -575,7 +615,7 @@ class DataFrameTable(DataTable):
             else:
                 content_tab.remove_class("dirty")
 
-    def move_cursor_to(self, ridx: int, cidx: int) -> None:
+    def move_cursor_to(self, ridx: int | None = None, cidx: int | None = None) -> None:
         """Move cursor based on the dataframe indices.
 
         Args:
@@ -583,11 +623,11 @@ class DataFrameTable(DataTable):
             cidx: Column index (0-based) in the dataframe.
         """
         # Ensure the target row is loaded
-        if ridx >= self.loaded_rows:
-            self.load_rows(stop=ridx + self.BATCH_SIZE)
+        start, stop = self._round_to_nearest_hundreds(ridx)
+        self.load_rows_range(start, stop)
 
-        row_key = str(ridx)
-        col_key = self.df.columns[cidx]
+        row_key = self.cursor_row_key if ridx is None else str(ridx)
+        col_key = self.cursor_col_key if cidx is None else self.df.columns[cidx]
         row_idx, col_idx = self.get_cell_coordinate(row_key, col_key)
         self.move_cursor(row=row_idx, column=col_idx)
 
@@ -603,15 +643,15 @@ class DataFrameTable(DataTable):
     def on_key(self, event) -> None:
         """Handle key press events for pagination.
 
-        Currently handles "pagedown" and "down" keys to trigger lazy loading of additional rows
-        when scrolling near the end of the loaded data.
-
         Args:
             event: The key event object.
         """
-        if event.key in ("pagedown", "down"):
+        if event.key == "up":
+            # Let the table handle the navigation first
+            self.load_rows_up()
+        elif event.key == "down":
             # Let the table handle the navigation first
-            self.check_and_load_more()
+            self.load_rows_down()
 
     def on_click(self, event: Click) -> None:
         """Handle mouse click events on the table.
@@ -624,13 +664,13 @@ class DataFrameTable(DataTable):
         if self.cursor_type == "cell" and event.chain > 1:  # only on double-click or more
             try:
                 row_idx = event.style.meta["row"]
-                # col_idx = event.style.meta["column"]
+                col_idx = event.style.meta["column"]
             except (KeyError, TypeError):
                 return  # Unable to get row/column info
 
             # header row
             if row_idx == -1:
-                self.do_rename_column()
+                self.do_rename_column(col_idx)
             else:
                 self.do_edit_cell()
 
@@ -641,16 +681,38 @@ class DataFrameTable(DataTable):
 
     def action_jump_bottom(self) -> None:
         """Jump to the bottom of the table."""
-        self.load_rows(move_to_end=True)
+        stop = len(self.df)
+        start = max(0, ((stop - self.BATCH_SIZE) // self.BATCH_SIZE + 1) * self.BATCH_SIZE)
+        self.load_rows_range(start, stop)
+        self.move_cursor(row=self.row_count - 1)
+
+    def action_page_up(self) -> None:
+        """Move the cursor one page up."""
+        self._set_hover_cursor(False)
+        if self.show_cursor and self.cursor_type in ("cell", "row"):
+            height = self.scrollable_content_region.height - (self.header_height if self.show_header else 0)
+
+            col_idx = self.cursor_column
+            ridx = self.cursor_row_idx
+            next_ridx = max(0, ridx - height - BUFFER_SIZE)
+            start, stop = self._round_to_nearest_hundreds(next_ridx)
+            self.load_rows_range(start, stop)
 
-    def action_forward_page(self) -> None:
-        """Scroll down one page."""
+            self.move_cursor(row=self.get_row_idx(str(next_ridx)), column=col_idx)
+        else:
+            super().action_page_up()
+
+    def action_page_down(self) -> None:
         super().action_page_down()
-        self.check_and_load_more()
+        self.load_rows_down()
 
     def action_backward_page(self) -> None:
         """Scroll up one page."""
-        super().action_page_up()
+        self.action_page_up()
+
+    def action_forward_page(self) -> None:
+        """Scroll down one page."""
+        self.action_page_down()
 
     def action_view_row_detail(self) -> None:
         """View details of the current row."""
@@ -696,6 +758,14 @@ class DataFrameTable(DataTable):
         """
         self.do_show_statistics(scope)
 
+    def action_metadata_shape(self) -> None:
+        """Show metadata about the dataframe (row and column counts)."""
+        self.do_metadata_shape()
+
+    def action_metadata_column(self) -> None:
+        """Show metadata for the current column."""
+        self.do_metadata_column()
+
     def action_view_rows(self) -> None:
         """View rows by current cell value."""
         self.do_view_rows()
@@ -732,13 +802,13 @@ class DataFrameTable(DataTable):
         """Clear the current cell (set to None)."""
         self.do_clear_cell()
 
-    def action_search_cursor_value(self) -> None:
-        """Search cursor value in the current column."""
-        self.do_search_cursor_value()
+    def action_select_row_cursor_value(self) -> None:
+        """Select rows with cursor value in the current column."""
+        self.do_select_row_cursor_value()
 
-    def action_search_expr(self) -> None:
-        """Search by expression in the current column."""
-        self.do_search_expr()
+    def action_select_row_expr(self) -> None:
+        """Select rows by expression."""
+        self.do_select_row_expr()
 
     def action_find_cursor_value(self, scope="column") -> None:
         """Find by cursor value.
@@ -925,9 +995,13 @@ class DataFrameTable(DataTable):
         """Open the advanced SQL interface screen."""
         self.do_advanced_sql()
 
+    def on_mouse_scroll_up(self, event) -> None:
+        """Load more rows when scrolling up with mouse."""
+        self.load_rows_up()
+
     def on_mouse_scroll_down(self, event) -> None:
         """Load more rows when scrolling down with mouse."""
-        self.check_and_load_more()
+        self.load_rows_down()
 
     # Setup & Loading
     def reset_df(self, new_df: pl.DataFrame, dirty: bool = True) -> None:
@@ -964,27 +1038,27 @@ class DataFrameTable(DataTable):
         if reset:
             self.reset_df(self.dataframe, dirty=False)
 
-        # Lazy load up to INITIAL_BATCH_SIZE visible rows
-        stop, visible_count, row_idx = self.INITIAL_BATCH_SIZE, 0, 0
+        # Lazy load up to BATCH_SIZE visible rows
+        stop, visible_count, row_idx = self.BATCH_SIZE, 0, 0
         for row_idx, visible in enumerate(self.visible_rows):
             if not visible:
                 continue
             visible_count += 1
-            if visible_count > self.INITIAL_BATCH_SIZE:
-                stop = row_idx + self.BATCH_SIZE
+            if visible_count > self.BATCH_SIZE:
+                stop = row_idx
                 break
         else:
-            stop = row_idx + self.BATCH_SIZE
+            stop = row_idx
 
-        # # Ensure all selected rows or matches are loaded
-        # stop = max(stop, rindex(self.selected_rows, True) + 1)
-        # stop = max(stop, max(self.matches.keys(), default=0) + 1)
+        # Round up to next hundreds
+        if stop % self.BATCH_SIZE != 0:
+            stop = (stop // self.BATCH_SIZE + 1) * self.BATCH_SIZE
 
         # Save current cursor position before clearing
         row_idx, col_idx = self.cursor_coordinate
 
         self.setup_columns()
-        self.load_rows(stop)
+        self.load_rows_range(0, stop)
 
         # Restore cursor position
         if row_idx < len(self.rows) and col_idx < len(self.columns):
@@ -1007,7 +1081,7 @@ class DataFrameTable(DataTable):
         column_widths = {}
 
         # Get available width for the table (with some padding for borders/scrollbar)
-        available_width = self.size.width - 4  # Account for borders and scrollbar
+        available_width = self.scrollable_content_region.width
 
         # Calculate how much width we need for string columns first
         string_cols = [col for col, dtype in zip(self.df.columns, self.df.dtypes) if dtype == pl.String]
@@ -1017,7 +1091,7 @@ class DataFrameTable(DataTable):
             return column_widths
 
         # Sample a reasonable number of rows to calculate widths (don't scan entire dataframe)
-        sample_size = min(self.INITIAL_BATCH_SIZE, len(self.df))
+        sample_size = min(self.BATCH_SIZE, len(self.df))
         sample_lf = self.df.lazy().slice(0, sample_size)
 
         # Determine widths for each column
@@ -1144,7 +1218,8 @@ class DataFrameTable(DataTable):
             # Load max BATCH_SIZE rows at a time
             chunk_size = min(self.BATCH_SIZE, stop - self.loaded_rows)
             next_stop = min(self.loaded_rows + chunk_size, stop)
-            self.load_rows_batch(next_stop)
+            self.load_rows_range(self.loaded_rows, next_stop)
+            self.loaded_rows = next_stop
 
             # If there's more to load, yield to event loop with delay
             if next_stop < stop:
@@ -1156,64 +1231,382 @@ class DataFrameTable(DataTable):
         if move_to_end:
             self.call_after_refresh(lambda: self.move_cursor(row=self.row_count - 1))
 
-    def load_rows_batch(self, stop: int) -> None:
-        """Load a batch of rows into the table.
+    def _calculate_load_range(self, start: int, stop: int) -> list[tuple[int, int]]:
+        """Calculate the actual ranges to load, accounting for already-loaded ranges.
 
-        Row keys are 0-based indices as strings, which map directly to dataframe row indices.
-        Row labels are 1-based indices as strings.
+        Handles complex cases where a loaded range is fully contained within the requested
+        range (creating head and tail segments to load). All overlapping/adjacent loaded
+        ranges are merged first to minimize gaps.
 
         Args:
-            stop: Stop loading rows when this index is reached.
+            start: Requested start index (0-based).
+            stop: Requested stop index (0-based, exclusive).
+
+        Returns:
+            List of (actual_start, actual_stop) tuples to load. Empty list if the entire
+            requested range is already loaded.
+
+        Example:
+            If loaded ranges are [(150, 250)] and requesting (100, 300):
+            - Returns [(100, 150), (250, 300)] to load head and tail
+            If loaded ranges are [(0, 100), (100, 200)] and requesting (50, 150):
+            - After merging, loaded_ranges becomes [(0, 200)]
+            - Returns [] (already fully loaded)
         """
-        try:
-            start = self.loaded_rows
-            df_slice = self.df.slice(start, stop - start)
+        if not self.loaded_ranges:
+            return [(start, stop)]
+
+        # Sort loaded ranges by start index
+        sorted_ranges = sorted(self.loaded_ranges)
+
+        # Merge overlapping/adjacent ranges
+        merged = []
+        for range_start, range_stop in sorted_ranges:
+            if merged and range_start <= merged[-1][1]:
+                # Overlapping or adjacent: merge
+                merged[-1] = (merged[-1][0], max(merged[-1][1], range_stop))
+            else:
+                merged.append((range_start, range_stop))
+
+        self.loaded_ranges = merged
+
+        # Calculate ranges to load by finding gaps in the merged ranges
+        ranges_to_load = []
+        current_pos = start
+
+        for range_start, range_stop in merged:
+            # If there's a gap before this loaded range, add it to load list
+            if current_pos < range_start and current_pos < stop:
+                gap_end = min(range_start, stop)
+                ranges_to_load.append((current_pos, gap_end))
+                current_pos = range_stop
+            elif current_pos >= range_stop:
+                # Already moved past this loaded range
+                continue
+            else:
+                # Current position is inside this loaded range, skip past it
+                current_pos = max(current_pos, range_stop)
 
-            for ridx, row in enumerate(df_slice.rows(), start):
-                if not self.visible_rows[ridx]:
-                    continue  # Skip hidden rows
+        # If there's remaining range after all loaded ranges, add it
+        if current_pos < stop:
+            ranges_to_load.append((current_pos, stop))
+
+        return ranges_to_load
+
+    def _merge_loaded_ranges(self) -> None:
+        """Merge adjacent and overlapping ranges in self.loaded_ranges.
+
+        Ranges like (0, 100) and (100, 200) are merged into (0, 200).
+        """
+        if len(self.loaded_ranges) <= 1:
+            return
+
+        # Sort by start index
+        sorted_ranges = sorted(self.loaded_ranges)
+
+        # Merge overlapping/adjacent ranges
+        merged = [sorted_ranges[0]]
+        for range_start, range_stop in sorted_ranges[1:]:
+            # Overlapping or adjacent: merge
+            if range_start <= merged[-1][1]:
+                merged[-1] = (merged[-1][0], max(merged[-1][1], range_stop))
+            else:
+                merged.append((range_start, range_stop))
+
+        self.loaded_ranges = merged
+
+    def _find_insert_position_for_row(self, ridx: int) -> int:
+        """Find the correct table position to insert a row with the given dataframe index.
+
+        In the table display, rows are ordered by their dataframe index, regardless of
+        the internal row keys. This method finds where a row should be inserted based on
+        its dataframe index and the indices of already-loaded rows.
+
+        Args:
+            ridx: The 0-based dataframe row index.
+
+        Returns:
+            The 0-based table position where the row should be inserted.
+        """
+        # Count how many already-loaded rows have lower dataframe indices
+        # Iterate through loaded rows instead of iterating 0..ridx for efficiency
+        insert_pos = 0
+        for row_key in self._row_locations:
+            loaded_ridx = int(row_key.value)
+            if loaded_ridx < ridx:
+                insert_pos += 1
+
+        return insert_pos
+
+    def load_rows_segment(self, segment_start: int, segment_stop: int) -> int:
+        """Load a single contiguous segment of rows into the table.
+
+        This is the core loading logic that inserts rows at correct positions,
+        respecting visibility and selection states. Used by load_rows_range()
+        to handle each segment independently.
+
+        Args:
+            segment_start: Start loading rows from this index (0-based).
+            segment_stop: Stop loading rows when this index is reached (0-based, exclusive).
+        """
+        # Record this range before loading
+        self.loaded_ranges.append((segment_start, segment_stop))
+
+        # Load the dataframe slice
+        df_slice = self.df.slice(segment_start, segment_stop - segment_start)
+
+        # Load each row at the correct position
+        for ridx, row in enumerate(df_slice.rows(), segment_start):
+            if not self.visible_rows[ridx]:
+                continue  # Skip hidden rows
+
+            is_selected = self.selected_rows[ridx]
+            match_cols = self.matches.get(ridx, set())
+
+            vals, dtypes, styles = [], [], []
+            for cidx, (val, col, dtype) in enumerate(zip(row, self.df.columns, self.df.dtypes)):
+                if col in self.hidden_columns:
+                    continue  # Skip hidden columns
+
+                vals.append(val)
+                dtypes.append(dtype)
+
+                # Highlight entire row with selection or cells with matches
+                styles.append(HIGHLIGHT_COLOR if is_selected or cidx in match_cols else None)
+
+            formatted_row = format_row(vals, dtypes, styles=styles, thousand_separator=self.thousand_separator)
 
-                is_selected = self.selected_rows[ridx]
-                match_cols = self.matches.get(ridx, set())
+            # Find correct insertion position and insert
+            insert_pos = self._find_insert_position_for_row(ridx)
+            self.insert_row(*formatted_row, key=str(ridx), label=str(ridx + 1), position=insert_pos)
 
-                vals, dtypes, styles = [], [], []
-                for cidx, (val, col, dtype) in enumerate(zip(row, self.df.columns, self.df.dtypes)):
-                    if col in self.hidden_columns:
-                        continue  # Skip hidden columns
+        # Number of rows loaded in this segment
+        segment_count = len(df_slice)
 
-                    vals.append(val)
-                    dtypes.append(dtype)
+        # Update loaded rows count
+        self.loaded_rows += segment_count
 
-                    # Highlight entire row with selection or cells with matches
-                    styles.append(HIGHLIGHT_COLOR if is_selected or cidx in match_cols else None)
+        return segment_count
 
-                formatted_row = format_row(vals, dtypes, styles=styles, thousand_separator=self.thousand_separator)
+    def load_rows_range(self, start: int, stop: int) -> int:
+        """Load a batch of rows into the table.
+
+        Row keys are 0-based indices as strings, which map directly to dataframe row indices.
+        Row labels are 1-based indices as strings.
+
+        Intelligently handles range loading:
+        1. Calculates which ranges actually need loading (avoiding reloading)
+        2. Handles complex cases where loaded ranges create "holes" (head and tail segments)
+        3. Inserts rows at correct positions in the table
+        4. Merges adjacent/overlapping ranges to optimize future loading
+
+        Args:
+            start: Start loading rows from this index (0-based).
+            stop: Stop loading rows when this index is reached (0-based, exclusive).
+        """
+        start = max(0, start)  # Clamp to non-negative
+        stop = min(stop, len(self.df))  # Clamp to dataframe length
+
+        try:
+            # Calculate actual ranges to load, accounting for already-loaded ranges
+            ranges_to_load = self._calculate_load_range(start, stop)
+
+            # If nothing needs loading, return early
+            if not ranges_to_load:
+                self.log(f"Range {start}-{stop} already loaded, skipping")
+                return 0
 
-                # Always add labels so they can be shown/hidden via CSS
-                self.add_row(*formatted_row, key=str(ridx), label=str(ridx + 1))
+            # Track the number of loaded rows in this range
+            range_count = 0
 
-            # Update loaded rows count
-            self.loaded_rows = stop
+            # Load each segment
+            for segment_start, segment_stop in ranges_to_load:
+                range_count += self.load_rows_segment(segment_start, segment_stop)
 
-            # self.notify(f"Loaded [$accent]{self.loaded_rows}/{len(self.df)}[/] rows from [$success]{self.name}[/]", title="Load")
-            self.log(f"Loaded {self.loaded_rows}/{len(self.df)} rows from `{self.filename or self.name}`")
+            # Merge adjacent/overlapping ranges to optimize storage
+            self._merge_loaded_ranges()
+
+            self.log(f"Loaded {range_count} rows for range {start}-{stop}/{len(self.df)}")
+            return range_count
 
         except Exception as e:
             self.notify("Error loading rows", title="Load", severity="error", timeout=10)
             self.log(f"Error loading rows: {str(e)}")
+            return 0
 
-    def check_and_load_more(self) -> None:
+    def load_rows_up(self) -> None:
         """Check if we need to load more rows and load them."""
         # If we've loaded everything, no need to check
         if self.loaded_rows >= len(self.df):
             return
 
-        visible_row_count = self.size.height - self.header_height
-        bottom_visible_row = self.scroll_y + visible_row_count
+        top_row_index = int(self.scroll_y) + BUFFER_SIZE
+        top_row_key = self.get_row_key(top_row_index)
+
+        if top_row_key:
+            top_ridx = int(top_row_key.value)
+        else:
+            top_ridx = 0
+            self.log(f"No top row key at index {top_row_index}, defaulting to 0")
+
+        # Load upward
+        start, stop = self._round_to_nearest_hundreds(top_ridx - BUFFER_SIZE * 2)
+        range_count = self.load_rows_range(start, stop)
+
+        # self.log(
+        #     "========",
+        #     f"{self.scrollable_content_region.height = },",
+        #     f"{self.header_height = },",
+        #     f"{self.scroll_y = },",
+        #     f"{top_row_index = },",
+        #     f"{top_ridx = },",
+        #     f"{start = },",
+        #     f"{stop = },",
+        #     f"{range_count = },",
+        #     f"{self.loaded_ranges = }",
+        # )
+
+        # Adjust scroll to maintain position if rows were loaded above
+        if range_count > 0:
+            self.move_cursor(row=top_row_index + range_count)
+            self.log(f"Loaded up: {range_count} rows in range {start}-{stop}/{len(self.df)}")
+
+    def load_rows_down(self) -> None:
+        """Check if we need to load more rows and load them."""
+        # If we've loaded everything, no need to check
+        if self.loaded_rows >= len(self.df):
+            return
+
+        visible_row_count = self.scrollable_content_region.height - self.header_height
+        bottom_row_index = self.scroll_y + visible_row_count - BUFFER_SIZE
+
+        bottom_row_key = self.get_row_key(bottom_row_index)
+        if bottom_row_key:
+            bottom_ridx = int(bottom_row_key.value)
+        else:
+            bottom_ridx = 0
+            self.log(f"No bottom row key at index {bottom_row_index}, defaulting to 0")
+
+        # Load downward
+        start, stop = self._round_to_nearest_hundreds(bottom_ridx + BUFFER_SIZE * 2)
+        range_count = self.load_rows_range(start, stop)
+
+        # self.log(
+        #     "========",
+        #     f"{self.scrollable_content_region.height = },",
+        #     f"{self.header_height = },",
+        #     f"{self.scroll_y = },",
+        #     f"{bottom_row_index = },",
+        #     f"{bottom_ridx = },",
+        #     f"{start = },",
+        #     f"{stop = },",
+        #     f"{range_count = },",
+        #     f"{self.loaded_ranges = }",
+        # )
+
+        if range_count > 0:
+            self.log(f"Loaded down: {range_count} rows in range {start}-{stop}/{len(self.df)}")
+
+    def insert_row(
+        self,
+        *cells: CellType,
+        height: int | None = 1,
+        key: str | None = None,
+        label: TextType | None = None,
+        position: int | None = None,
+    ) -> RowKey:
+        """Insert a row at a specific position in the DataTable.
+
+        When inserting, all rows at and after the insertion position are shifted down,
+        and their entries in self._row_locations are updated accordingly.
+
+        Args:
+            *cells: Positional arguments should contain cell data.
+            height: The height of a row (in lines). Use `None` to auto-detect the optimal
+                height.
+            key: A key which uniquely identifies this row. If None, it will be generated
+                for you and returned.
+            label: The label for the row. Will be displayed to the left if supplied.
+            position: The 0-based row index where the new row should be inserted.
+                If None, inserts at the end (same as add_row). If out of bounds,
+                inserts at the nearest valid position.
 
-        # If visible area is close to the end of loaded rows, load more
-        if bottom_visible_row >= self.loaded_rows - 10:
-            self.load_rows(self.loaded_rows + self.BATCH_SIZE)
+        Returns:
+            Unique identifier for this row. Can be used to retrieve this row regardless
+                of its current location in the DataTable (it could have moved after
+                being added due to sorting or insertion/deletion of other rows).
+
+        Raises:
+            DuplicateKey: If a row with the given key already exists.
+            ValueError: If more cells are provided than there are columns.
+        """
+        # Default to appending if position not specified or >= row_count
+        row_count = self.row_count
+        if position is None or position >= row_count:
+            return self.add_row(*cells, height=height, key=key, label=label)
+
+        # Clamp position to valid range [0, row_count)
+        position = max(0, position)
+
+        row_key = RowKey(key)
+        if row_key in self._row_locations:
+            raise DuplicateKey(f"The row key {row_key!r} already exists.")
+
+        if len(cells) > len(self.ordered_columns):
+            raise ValueError("More values provided than there are columns.")
+
+        # TC: Rebuild self._row_locations to shift rows at and after position down by 1
+        # Create a mapping of old index -> new index
+        old_to_new = {}
+        for old_idx in range(row_count):
+            if old_idx < position:
+                old_to_new[old_idx] = old_idx  # No change
+            else:
+                old_to_new[old_idx] = old_idx + 1  # Shift down by 1
+
+        # Update _row_locations with the new indices
+        new_row_locations = TwoWayDict({})
+        for row_key_item in self._row_locations:
+            old_idx = self.get_row_idx(row_key_item)
+            new_idx = old_to_new.get(old_idx, old_idx)
+            new_row_locations[row_key_item] = new_idx
+
+        # Update the internal mapping
+        self._row_locations = new_row_locations
+        # TC
+
+        row_index = position
+        # Map the key of this row to its current index
+        self._row_locations[row_key] = row_index
+        self._data[row_key] = {column.key: cell for column, cell in zip_longest(self.ordered_columns, cells)}
+
+        label = Text.from_markup(label, end="") if isinstance(label, str) else label
+
+        # Rows with auto-height get a height of 0 because 1) we need an integer height
+        # to do some intermediate computations and 2) because 0 doesn't impact the data
+        # table while we don't figure out how tall this row is.
+        self.rows[row_key] = Row(
+            row_key,
+            height or 0,
+            label,
+            height is None,
+        )
+        self._new_rows.add(row_key)
+        self._require_update_dimensions = True
+        self.cursor_coordinate = self.cursor_coordinate
+
+        # If a position has opened for the cursor to appear, where it previously
+        # could not (e.g. when there's no data in the table), then a highlighted
+        # event is posted, since there's now a highlighted cell when there wasn't
+        # before.
+        cell_now_available = self.row_count == 1 and len(self.columns) > 0
+        visible_cursor = self.show_cursor and self.cursor_type != "none"
+        if cell_now_available and visible_cursor:
+            self._highlight_cursor()
+
+        self._update_count += 1
+        self.check_idle()
+        return row_key
 
     # History & Undo
     def create_history(self, description: str) -> None:
@@ -1354,6 +1747,14 @@ class DataFrameTable(DataTable):
             cidx = self.cursor_col_idx
             self.app.push_screen(StatisticsScreen(self, col_idx=cidx))
 
+    def do_metadata_shape(self) -> None:
+        """Show metadata about the dataframe (row and column counts)."""
+        self.app.push_screen(MetaShape(self))
+
+    def do_metadata_column(self) -> None:
+        """Show metadata for all columns in the dataframe."""
+        self.app.push_screen(MetaColumnScreen(self))
+
     def do_freeze_row_column(self) -> None:
         """Open the freeze screen to set fixed rows and columns."""
         self.app.push_screen(FreezeScreen(), callback=self.freeze_row_column)
@@ -1486,6 +1887,7 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self.add_history(f"Sorted on column [$success]{col_name}[/]", dirty=True)
+
         if old_desc is None:
             # Add new column to sort
             self.sorted_columns[col_name] = descending
@@ -1497,18 +1899,27 @@ class DataFrameTable(DataTable):
             del self.sorted_columns[col_name]
             self.sorted_columns[col_name] = descending
 
+        lf = self.df.lazy().with_row_index(RIDX)
+
         # Apply multi-column sort
         if sort_cols := list(self.sorted_columns.keys()):
             descending_flags = list(self.sorted_columns.values())
-            df_sorted = self.df.with_row_index(RIDX).sort(sort_cols, descending=descending_flags, nulls_last=True)
-        else:
-            # No sort columns - restore original order
-            df_sorted = self.df.with_row_index(RIDX)
+            lf = lf.sort(sort_cols, descending=descending_flags, nulls_last=True)
+
+        df_sorted = lf.collect()
 
-        # Updated selected_rows and visible_rows to match new order
+        # Updated visible rows, selected rows, and cell matches to match new order
         old_row_indices = df_sorted[RIDX].to_list()
-        self.selected_rows = [self.selected_rows[i] for i in old_row_indices]
-        self.visible_rows = [self.visible_rows[i] for i in old_row_indices]
+        if self.has_hidden_rows:
+            self.visible_rows = [self.visible_rows[old_ridx] for old_ridx in old_row_indices]
+        if any(self.selected_rows):
+            self.selected_rows = [self.selected_rows[old_ridx] for old_ridx in old_row_indices]
+        if any(self.matches):
+            self.matches = {
+                new_ridx: self.matches[old_ridx]
+                for new_ridx, old_ridx in enumerate(old_row_indices)
+                if old_ridx in self.matches
+            }
 
         # Update the dataframe
         self.df = df_sorted.drop(RIDX)
@@ -1649,10 +2060,10 @@ class DataFrameTable(DataTable):
 
         # self.notify(f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]", title="Edit Column")
 
-    def do_rename_column(self) -> None:
+    def do_rename_column(self, col_idx: int | None) -> None:
         """Open modal to rename the selected column."""
-        col_name = self.cursor_col_name
-        col_idx = self.cursor_column
+        col_idx = self.cursor_column if col_idx is None else col_idx
+        col_name = self.get_col_key(col_idx).value
 
         # Push the rename column modal screen
         self.app.push_screen(
@@ -1832,10 +2243,10 @@ class DataFrameTable(DataTable):
     def add_link_column(self, result: tuple[str, str] | None) -> None:
         """Handle result from AddLinkScreen.
 
-        Creates a new link column in the dataframe with clickable links based on a
-        user-provided template. Supports multiple placeholder types:
+        Creates a new link column in the dataframe based on a user-provided template.
+        Supports multiple placeholder types:
         - `$_` - Current column (based on cursor position)
-        - `$1`, `$2`, etc. - Column by 1-based position index
+        - `$1`, `$2`, etc. - Column by index (1-based)
         - `$name` - Column by name (e.g., `$id`, `$product_name`)
 
         The template is evaluated for each row using Polars expressions with vectorized
@@ -1903,7 +2314,7 @@ class DataFrameTable(DataTable):
         # Remove all columns before the current column
         if more == "before":
             for i in range(col_idx + 1):
-                col_key = self.get_column_key(i)
+                col_key = self.get_col_key(i)
                 col_names_to_remove.append(col_key.value)
                 col_keys_to_remove.append(col_key)
 
@@ -1912,7 +2323,7 @@ class DataFrameTable(DataTable):
         # Remove all columns after the current column
         elif more == "after":
             for i in range(col_idx, len(self.columns)):
-                col_key = self.get_column_key(i)
+                col_key = self.get_col_key(i)
                 col_names_to_remove.append(col_key.value)
                 col_keys_to_remove.append(col_key)
 
@@ -2197,8 +2608,8 @@ class DataFrameTable(DataTable):
             self._row_locations[row_key],
             self._row_locations[swap_key],
         ) = (
-            self._row_locations.get(swap_key),
-            self._row_locations.get(row_key),
+            self.get_row_idx(swap_key),
+            self.get_row_idx(row_key),
         )
 
         self._update_count += 1
@@ -2272,18 +2683,23 @@ class DataFrameTable(DataTable):
             )
             self.log(f"Error casting column `{col_name}`: {str(e)}")
 
-    # Search
-    def do_search_cursor_value(self) -> None:
+    # Row selection
+    def do_select_row_cursor_value(self) -> None:
         """Search with cursor value in current column."""
         cidx = self.cursor_col_idx
+        col_name = self.cursor_col_name
 
         # Get the value of the currently selected cell
         term = NULL if self.cursor_value is None else str(self.cursor_value)
+        if self.cursor_value is None:
+            term = pl.col(col_name).is_null()
+        else:
+            term = pl.col(col_name) == self.cursor_value
 
-        self.search((term, cidx, False, True))
+        self.select_row((term, cidx, False, True))
 
-    def do_search_expr(self) -> None:
-        """Search by expression."""
+    def do_select_row_expr(self) -> None:
+        """Select rows by expression."""
         cidx = self.cursor_col_idx
 
         # Use current cell value as default search term
@@ -2292,21 +2708,26 @@ class DataFrameTable(DataTable):
         # Push the search modal screen
         self.app.push_screen(
             SearchScreen("Search", term, self.df, cidx),
-            callback=self.search,
+            callback=self.select_row,
         )
 
-    def search(self, result) -> None:
-        """Search for a term."""
+    def select_row(self, result) -> None:
+        """Select rows by value or expression."""
         if result is None:
             return
 
         term, cidx, match_nocase, match_whole = result
         col_name = self.df.columns[cidx]
 
-        if term == NULL:
+        # Already a Polars expression
+        if isinstance(term, pl.Expr):
+            expr = term
+
+        # Null case
+        elif term == NULL:
             expr = pl.col(col_name).is_null()
 
-        # Support for polars expressions
+        # Expression in string form
         elif tentative_expr(term):
             try:
                 expr = validate_expr(term, self.df.columns, cidx)
@@ -2351,33 +2772,107 @@ class DataFrameTable(DataTable):
         try:
             matches = set(lf.filter(expr).select(RIDX).collect().to_series().to_list())
         except Exception as e:
-            self.notify(f"Error applying search filter [$error]{term}[/]", title="Search", severity="error", timeout=10)
+            self.notify(
+                f"Error applying search filter `[$error]{term}[/]`", title="Search", severity="error", timeout=10
+            )
             self.log(f"Error applying search filter `{term}`: {str(e)}")
             return
 
         match_count = len(matches)
         if match_count == 0:
             self.notify(
-                f"No matches found for [$warning]{term}[/]. Try [$accent](?i)abc[/] for case-insensitive search.",
+                f"No matches found for `[$warning]{term}[/]`. Try [$accent](?i)abc[/] for case-insensitive search.",
                 title="Search",
                 severity="warning",
             )
             return
 
+        message = f"Found [$success]{match_count}[/] matching row(s) for `[$accent]{term}[/]`"
+
         # Add to history
-        self.add_history(f"Searched [$success]{term}[/] in column [$accent]{col_name}[/]")
+        self.add_history(message)
 
         # Update selected rows to include new matches
         for m in matches:
             self.selected_rows[m] = True
 
         # Show notification immediately, then start highlighting
-        self.notify(f"Found [$success]{match_count}[/] matches for [$accent]{term}[/]", title="Search")
+        self.notify(message, title="Select Row")
+
+        # Recreate table for display
+        self.setup_table()
+
+    def do_toggle_selections(self) -> None:
+        """Toggle selected rows highlighting on/off."""
+        # Add to history
+        self.add_history("Toggled row selection")
+
+        if self.has_hidden_rows:
+            # Some rows are hidden - invert only selected visible rows and clear selections for hidden rows
+            for i in range(len(self.selected_rows)):
+                if self.visible_rows[i]:
+                    self.selected_rows[i] = not self.selected_rows[i]
+                else:
+                    self.selected_rows[i] = False
+        else:
+            # Invert all selected rows
+            self.selected_rows = [not selected for selected in self.selected_rows]
+
+        # Check if we're highlighting or un-highlighting
+        if new_selected_count := self.selected_rows.count(True):
+            self.notify(f"Toggled selection for [$success]{new_selected_count}[/] rows", title="Toggle")
+
+        # Recreate table for display
+        self.setup_table()
+
+    def do_toggle_row_selection(self) -> None:
+        """Select/deselect current row."""
+        # Add to history
+        self.add_history("Toggled row selection")
+
+        ridx = self.cursor_row_idx
+        self.selected_rows[ridx] = not self.selected_rows[ridx]
+
+        row_key = str(ridx)
+        match_cols = self.matches.get(ridx, set())
+        for col_idx, col in enumerate(self.ordered_columns):
+            col_key = col.key
+            cell_text: Text = self.get_cell(row_key, col_key)
+
+            if self.selected_rows[ridx] or (col_idx in match_cols):
+                cell_text.style = HIGHLIGHT_COLOR
+            else:
+                # Reset to default style based on dtype
+                dtype = self.df.dtypes[col_idx]
+                dc = DtypeConfig(dtype)
+                cell_text.style = dc.style
+
+            self.update_cell(row_key, col_key, cell_text)
+
+    def do_clear_selections_and_matches(self) -> None:
+        """Clear all selected rows and matches without removing them from the dataframe."""
+        # Check if any selected rows or matches
+        if not any(self.selected_rows) and not self.matches:
+            self.notify("No selections to clear", title="Clear", severity="warning")
+            return
+
+        row_count = sum(
+            1 if (selected or idx in self.matches) else 0 for idx, selected in enumerate(self.selected_rows)
+        )
+
+        # Add to history
+        self.add_history("Cleared all selected rows")
+
+        # Clear all selections
+        self.selected_rows = [False] * len(self.df)
+        self.matches = defaultdict(set)
 
         # Recreate table for display
         self.setup_table()
 
-    # Find
+        self.notify(f"Cleared selections for [$success]{row_count}[/] rows", title="Clear")
+
+    # Find & Replace
     def find_matches(
         self, term: str, cidx: int | None = None, match_nocase: bool = False, match_whole: bool = False
     ) -> dict[int, set[int]]:
@@ -2386,6 +2881,8 @@ class DataFrameTable(DataTable):
         Args:
             term: The search term (can be NULL, expression, or plain text)
             cidx: Column index for column-specific search. If None, searches all columns.
+            match_nocase: Whether to perform case-insensitive matching (for string terms)
+            match_whole: Whether to match the whole cell content (for string terms)
 
         Returns:
             Dictionary mapping row indices to sets of column indices containing matches.
@@ -2484,27 +2981,27 @@ class DataFrameTable(DataTable):
         try:
             matches = self.find_matches(term, cidx, match_nocase, match_whole)
         except Exception as e:
-            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error", timeout=10)
+            self.notify(f"Error finding matches for `[$error]{term}[/]`", title="Find", severity="error", timeout=10)
             self.log(f"Error finding matches for `{term}`: {str(e)}")
             return
 
         if not matches:
             self.notify(
-                f"No matches found for [$warning]{term}[/] in current column. Try [$accent](?i)abc[/] for case-insensitive search.",
+                f"No matches found for `[$warning]{term}[/]` in current column. Try [$accent](?i)abc[/] for case-insensitive search.",
                 title="Find",
                 severity="warning",
             )
             return
 
         # Add to history
-        self.add_history(f"Found [$success]{term}[/] in column [$accent]{col_name}[/]")
+        self.add_history(f"Found `[$success]{term}[/]` in column [$accent]{col_name}[/]")
 
         # Add to matches and count total
         match_count = sum(len(col_idxs) for col_idxs in matches.values())
         for ridx, col_idxs in matches.items():
             self.matches[ridx].update(col_idxs)
 
-        self.notify(f"Found [$success]{match_count}[/] matches for [$accent]{term}[/]", title="Find")
+        self.notify(f"Found [$success]{match_count}[/] matches for `[$accent]{term}[/]`", title="Find")
 
         # Recreate table for display
         self.setup_table()
@@ -2518,20 +3015,20 @@ class DataFrameTable(DataTable):
         try:
             matches = self.find_matches(term, cidx=None, match_nocase=match_nocase, match_whole=match_whole)
         except Exception as e:
-            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error", timeout=10)
+            self.notify(f"Error finding matches for `[$error]{term}[/]`", title="Find", severity="error", timeout=10)
             self.log(f"Error finding matches for `{term}`: {str(e)}")
             return
 
         if not matches:
             self.notify(
-                f"No matches found for [$warning]{term}[/] in any column. Try [$accent](?i)abc[/] for case-insensitive search.",
+                f"No matches found for `[$warning]{term}[/]` in any column. Try [$accent](?i)abc[/] for case-insensitive search.",
                 title="Global Find",
                 severity="warning",
             )
             return
 
         # Add to history
-        self.add_history(f"Found [$success]{term}[/] across all columns")
+        self.add_history(f"Found `[$success]{term}[/]` across all columns")
 
         # Add to matches and count total
         match_count = sum(len(col_idxs) for col_idxs in matches.values())
@@ -2539,7 +3036,8 @@ class DataFrameTable(DataTable):
             self.matches[ridx].update(col_idxs)
 
         self.notify(
-            f"Found [$success]{match_count}[/] matches for [$accent]{term}[/] across all columns", title="Global Find"
+            f"Found [$success]{match_count}[/] matches for `[$accent]{term}[/]` across all columns",
+            title="Global Find",
         )
 
         # Recreate table for display
@@ -2639,7 +3137,6 @@ class DataFrameTable(DataTable):
         last_ridx = selected_row_indices[-1]
         self.move_cursor_to(last_ridx, self.cursor_col_idx)
 
-    # Replace
     def do_replace(self) -> None:
         """Open replace screen for current column."""
         # Push the replace modal screen
@@ -2740,7 +3237,7 @@ class DataFrameTable(DataTable):
         self.app.push_screen(
             ConfirmScreen(
                 "Replace All",
-                label=f"Replace [$success]{term_find}[/] with [$success]{term_replace or repr('')}[/] for all [$accent]{state.total_occurrence}[/] occurrences?",
+                label=f"Replace `[$success]{term_find}[/]` with `[$success]{term_replace}[/]` for all [$accent]{state.total_occurrence}[/] occurrences?",
             ),
             callback=self.handle_replace_all_confirmation,
         )
@@ -2848,7 +3345,7 @@ class DataFrameTable(DataTable):
         state.current_occurrence += 1
 
         # Show confirmation
-        label = f"Replace [$warning]{state.term_find}[/] with [$success]{state.term_replace}[/] ({state.current_occurrence} of {state.total_occurrence})?"
+        label = f"Replace `[$warning]{state.term_find}[/]` with `[$success]{state.term_replace}[/]` ({state.current_occurrence} of {state.total_occurrence})?"
 
         self.app.push_screen(
             ConfirmScreen("Replace", label=label, maybe="Skip"),
@@ -2923,112 +3420,7 @@ class DataFrameTable(DataTable):
         # Show next confirmation
         self.show_next_replace_confirmation()
 
-    # Selection & Match
-    def do_toggle_selections(self) -> None:
-        """Toggle selected rows highlighting on/off."""
-        # Add to history
-        self.add_history("Toggled row selection")
-
-        if self.has_hidden_rows:
-            # Some rows are hidden - invert only selected visible rows and clear selections for hidden rows
-            for i in range(len(self.selected_rows)):
-                if self.visible_rows[i]:
-                    self.selected_rows[i] = not self.selected_rows[i]
-                else:
-                    self.selected_rows[i] = False
-        else:
-            # Invert all selected rows
-            self.selected_rows = [not selected for selected in self.selected_rows]
-
-        # Check if we're highlighting or un-highlighting
-        if new_selected_count := self.selected_rows.count(True):
-            self.notify(f"Toggled selection for [$success]{new_selected_count}[/] rows", title="Toggle")
-
-        # Recreate table for display
-        self.setup_table()
-
-    def do_toggle_row_selection(self) -> None:
-        """Select/deselect current row."""
-        # Add to history
-        self.add_history("Toggled row selection")
-
-        ridx = self.cursor_row_idx
-        self.selected_rows[ridx] = not self.selected_rows[ridx]
-
-        row_key = str(ridx)
-        match_cols = self.matches.get(ridx, set())
-        for col_idx, col in enumerate(self.ordered_columns):
-            col_key = col.key
-            cell_text: Text = self.get_cell(row_key, col_key)
-
-            if self.selected_rows[ridx] or (col_idx in match_cols):
-                cell_text.style = HIGHLIGHT_COLOR
-            else:
-                # Reset to default style based on dtype
-                dtype = self.df.dtypes[col_idx]
-                dc = DtypeConfig(dtype)
-                cell_text.style = dc.style
-
-            self.update_cell(row_key, col_key, cell_text)
-
-    def do_clear_selections_and_matches(self) -> None:
-        """Clear all selected rows and matches without removing them from the dataframe."""
-        # Check if any selected rows or matches
-        if not any(self.selected_rows) and not self.matches:
-            self.notify("No selections to clear", title="Clear", severity="warning")
-            return
-
-        row_count = sum(
-            1 if (selected or idx in self.matches) else 0 for idx, selected in enumerate(self.selected_rows)
-        )
-
-        # Add to history
-        self.add_history("Cleared all selected rows")
-
-        # Clear all selections
-        self.selected_rows = [False] * len(self.df)
-        self.matches = defaultdict(set)
-
-        # Recreate table for display
-        self.setup_table()
-
-        self.notify(f"Cleared selections for [$success]{row_count}[/] rows", title="Clear")
-
-    # Filter & View
-    def do_filter_rows(self) -> None:
-        """Keep only the rows with selections and cell matches, and remove others."""
-        if any(self.selected_rows) or self.matches:
-            message = "Filter to rows with selection and cell matches (other rows removed)"
-            filter_expr = [
-                True if (selected or ridx in self.matches) else False
-                for ridx, selected in enumerate(self.selected_rows)
-            ]
-        else:  # Search cursor value in current column
-            message = "Filter to rows matching cursor value (other rows removed)"
-            ridx = self.cursor_row_idx
-            cidx = self.cursor_col_idx
-            value = self.df.item(ridx, cidx)
-
-            col_name = self.df.columns[cidx]
-            if value is None:
-                filter_expr = pl.col(col_name).is_null()
-            else:
-                filter_expr = pl.col(col_name) == value
-
-        # Add to history
-        self.add_history(message, dirty=True)
-
-        # Apply filter to dataframe with row indices
-        df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
-
-        # Update dataframe
-        self.reset_df(df_filtered.drop(RIDX))
-
-        # Recreate table for display
-        self.setup_table()
-
-        self.notify(f"{message}. Now showing [$success]{len(self.df)}[/] rows", title="Filter")
-
+    # View & Filter
     def do_view_rows(self) -> None:
         """View rows.
 
@@ -3150,6 +3542,49 @@ class DataFrameTable(DataTable):
 
         self.notify(f"Filtered to [$success]{matched_count}[/] matching rows", title="Filter")
 
+    def do_filter_rows(self) -> None:
+        """Keep only the rows with selections and cell matches, and remove others."""
+        if any(self.selected_rows) or self.matches:
+            message = "Filtered to rows with selection and cell matches (other rows removed)"
+            filter_expr = [
+                True if (selected or ridx in self.matches) else False
+                for ridx, selected in enumerate(self.selected_rows)
+            ]
+        else:  # Search cursor value in current column
+            message = "Filtered to rows matching cursor value (other rows removed)"
+            cidx = self.cursor_col_idx
+            col_name = self.df.columns[cidx]
+            value = self.cursor_value
+
+            if value is None:
+                filter_expr = pl.col(col_name).is_null()
+            else:
+                filter_expr = pl.col(col_name) == value
+
+        # Add to history
+        self.add_history(message, dirty=True)
+
+        # Apply filter to dataframe with row indices
+        df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
+
+        # Update selected rows
+        selected_rows = [self.selected_rows[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))]
+
+        # Update matches
+        matches = {ridx: self.matches[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))}
+
+        # Update dataframe
+        self.reset_df(df_filtered.drop(RIDX))
+
+        # Restore selected rows and matches
+        self.selected_rows = selected_rows
+        self.matches = matches
+
+        # Recreate table for display
+        self.setup_table()
+
+        self.notify(f"{message}. Now showing [$success]{len(self.df)}[/] rows", title="Filter")
+
     # Copy & Save
     def do_copy_to_clipboard(self, content: str, message: str) -> None:
         """Copy content to clipboard using pbcopy (macOS) or xclip (Linux).
@@ -3195,13 +3630,13 @@ class DataFrameTable(DataTable):
         """Handle result from SaveFileScreen."""
         if result is None:
             return
-        filename, all_tabs = result
+        filename, all_tabs, overwrite_prompt = result
 
         # Whether to save all tabs (for Excel files)
         self._all_tabs = all_tabs
 
         # Check if file exists
-        if Path(filename).exists():
+        if overwrite_prompt and Path(filename).exists():
             self._pending_filename = filename
             self.app.push_screen(
                 ConfirmScreen("File already exists. Overwrite?"),
@@ -3267,10 +3702,11 @@ class DataFrameTable(DataTable):
             else:
                 self.dirty = False
 
-            if self._task_after_save == "close_tab":
-                self.app.do_close_tab()
-            elif self._task_after_save == "quit_app":
-                self.app.exit()
+            if hasattr(self, "_task_after_save"):
+                if self._task_after_save == "close_tab":
+                    self.app.do_close_tab()
+                elif self._task_after_save == "quit_app":
+                    self.app.exit()
 
             # From ConfirmScreen callback, so notify accordingly
             if self._all_tabs:
@@ -3374,9 +3810,18 @@ class DataFrameTable(DataTable):
                         col_name for col_name in self.df.columns if col_name not in filtered_col_names
                     }
             else:  # filter - modify the dataframe
-                self.df = df_filtered.drop(RIDX)
-                self.visible_rows = [True] * len(self.df)
-                self.hidden_columns.clear()
+                # Update selected rows
+                selected_rows = [self.selected_rows[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))]
+
+                # Update matches
+                matches = {ridx: self.matches[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))}
+
+                # Update dataframe
+                self.reset_df(df_filtered.drop(RIDX))
+
+                # Restore selected rows and matches
+                self.selected_rows = selected_rows
+                self.matches = matches
         except Exception as e:
             self.notify(f"Error executing SQL query [$error]{sql}[/]", title="SQL Query", severity="error", timeout=10)
             self.log(f"Error executing SQL query `{sql}`: {str(e)}")