dataframe-textual 0.3.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

dataframe_textual/data_frame_table.py

@@ -1,15 +1,19 @@
 """DataFrameTable widget for displaying and interacting with Polars DataFrames."""
 
 import sys
-from collections import deque
+from collections import defaultdict, deque
 from dataclasses import dataclass
 from pathlib import Path
 from textwrap import dedent
+from typing import Any
 
 import polars as pl
 from rich.text import Text
+from textual import work
 from textual.coordinate import Coordinate
-from textual.widgets import DataTable
+from textual.events import Click
+from textual.render import measure
+from textual.widgets import DataTable, TabPane
 from textual.widgets._data_table import (
     CellDoesNotExist,
     CellKey,
@@ -19,26 +23,45 @@ from textual.widgets._data_table import (
 )
 
 from .common import (
-    BATCH_SIZE,
-    BOOLS,
     CURSOR_TYPES,
-    INITIAL_BATCH_SIZE,
+    NULL,
+    NULL_DISPLAY,
+    RIDX,
     SUBSCRIPT_DIGITS,
     DtypeConfig,
-    _format_row,
-    _next,
-    _rindex,
+    format_row,
+    get_next_item,
+    parse_placeholders,
+    rindex,
+    sleep_async,
+    tentative_expr,
+    validate_expr,
 )
-from .table_screen import FrequencyScreen, RowDetailScreen
+from .sql_screen import AdvancedSqlScreen, SimpleSqlScreen
+from .table_screen import FrequencyScreen, RowDetailScreen, StatisticsScreen
 from .yes_no_screen import (
+    AddColumnScreen,
+    AddLinkScreen,
     ConfirmScreen,
     EditCellScreen,
+    EditColumnScreen,
     FilterScreen,
+    FindReplaceScreen,
     FreezeScreen,
+    RenameColumnScreen,
     SaveFileScreen,
     SearchScreen,
 )
 
+# Color for highlighting selections and matches
+HIGHLIGHT_COLOR = "red"
+
+# Warning threshold for loading rows
+WARN_ROWS_THRESHOLD = 50_000
+
+# Maximum width for string columns before truncation
+STRING_WIDTH_CAP = 35
+
 
 @dataclass
 class History:
@@ -49,11 +72,33 @@ class History:
     filename: str
     loaded_rows: int
     sorted_columns: dict[str, bool]
+    hidden_columns: set[str]
     selected_rows: list[bool]
     visible_rows: list[bool]
     fixed_rows: int
     fixed_columns: int
     cursor_coordinate: Coordinate
+    matches: dict[int, set[int]]
+
+
+@dataclass
+class ReplaceState:
+    """Class to track state during interactive replace operations."""
+
+    term_find: str
+    term_replace: str
+    match_nocase: bool
+    match_whole: bool
+    cidx: int  # Column index to search in, could be None for all columns
+    rows: list[int]  # List of row indices
+    cols_per_row: list[list[int]]  # List of list of column indices per row
+    current_rpos: int  # Current row position index in rows
+    current_cpos: int  # Current column position index within current row's cols
+    current_occurrence: int  # Current occurrence count (for display)
+    total_occurrence: int  # Total number of occurrences
+    replaced_occurrence: int  # Number of occurrences already replaced
+    skipped_occurrence: int  # Number of occurrences skipped
+    done: bool = False  # Whether the replace operation is complete
 
 
 class DataFrameTable(DataTable):
@@ -67,123 +112,350 @@ class DataFrameTable(DataTable):
         - **↑↓←→** - 🎯 Move cursor (cell/row/column)
         - **g** - ⬆️ Jump to first row
         - **G** - ⬇️ Jump to last row
+        - **Ctrl+F** - 📜 Page down
+        - **Ctrl+B** - 📜 Page up
         - **PgUp/PgDn** - 📜 Page up/down
 
         ## 👁️ View & Display
         - **Enter** - 📋 Show row details in modal
         - **F** - 📊 Show frequency distribution
-        - **C** - 🔄 Cycle cursor (cell → row → column → cell)
-        - **#** - 🏷️ Toggle row labels
+        - **s** - 📈 Show statistics for current column
+        - **S** - 📊 Show statistics for entire dataframe
+        - **h** - 👁️ Hide current column
+        - **H** - 👀 Show all hidden rows/columns
+        - **_** - 📏 Expand column to full width
+        - **z** - 📌 Freeze rows and columns
+        - **~** - 🏷️ Toggle row labels
+        - **,** - 🔢 Toggle thousand separator for numeric display
+        - **K** - 🔄 Cycle cursor (cell → row → column → cell)
 
         ## ↕️ Sorting
         - **[** - 🔼 Sort column ascending
         - **]** - 🔽 Sort column descending
         - *(Multi-column sort supported)*
 
-        ## 🔍 Search
-        - **|** - 🔎 Search in current column
-        - **/** - 🌐 Global search (all columns)
-        - **\\\\** - 🔍 Search using current cell value
-
-        ## 🔧 Filter & Select
-        - **s** - ✓️ Select/deselect current row
+        ## 🔍 Search & Filter
+        - **|** - 🔎 Search in current column with expression
+        - **\\\\** - 🔎 Search in current column using cursor value
+        - **/** - 🔎 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
+        - **V** - 🔧 View/filter rows by expression
+        - *(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 & Filtering
+        - **'** - ✓️ Select/deselect current row
         - **t** - 💡 Toggle row selection (invert all)
-        - **"** - 📍 Filter to selected rows only
-        - **T** - 🧹 Clear all selections
-        - **v** - 🎯 Filter by selected rows or current cell value
-        - **V** - 🔧 Filter by Polars expression
+        - **{** - ⬆️ Go to previous selected row
+        - **}** - ⬇️ Go to next selected row
+        - **"** - 📍 Filter to show only selected rows
+        - **T** - 🧹 Clear all selections and matches
+
+        ## 🔍 SQL Interface
+        - **l** - 💬 Open simple SQL interface (select columns & WHERE clause)
+        - **L** - 🔎 Open advanced SQL interface (full SQL queries)
 
         ## ✏️ Edit & Modify
+        - **Double-click** - ✍️ Edit cell or rename column header
         - **e** - ✍️ Edit current cell
-        - **d** - 🗑️ Delete current row
+        - **E** - 📊 Edit entire column with expression
+        - **a** - ➕ Add empty column after current
+        - **A** - ➕ Add column with name and optional expression
+        - **x** - ❌ Delete current row
+        - **X** - ❌ Delete row and those below
+        - **Ctrl+X** - ❌ Delete row and those above
+        - **delete** - ❌ Clear current cell (set to NULL)
         - **-** - ❌ Delete current column
+        - **d** - 📋 Duplicate current column
+        - **D** - 📋 Duplicate current row
 
         ## 🎯 Reorder
         - **Shift+↑↓** - ⬆️⬇️ Move row up/down
         - **Shift+←→** - ⬅️➡️ Move column left/right
 
+        ## 🎨 Type Conversion
+        - **#** - 🔢 Cast column to integer
+        - **%** - 🔢 Cast column to float
+        - **!** - ✅ Cast column to boolean
+        - **$** - 📝 Cast column to string
+
+        ## 🔗 URL Handling
+        - **@** - 🔗 Add a new link column from template expression (e.g., `https://example.com/$_`)
+
         ## 💾 Data Management
-        - **f** - 📌 Freeze rows/columns
         - **c** - 📋 Copy cell to clipboard
-        - **Ctrl+S** - 💾 Save current tabto file
+        - **Ctrl+c** - 📊 Copy column to clipboard
+        - **Ctrl+r** - 📝 Copy row to clipboard (tab-separated)
+        - **Ctrl+s** - 💾 Save current tab to file
         - **u** - ↩️ Undo last action
-        - **U** - 🔄 Reset to original data
-
-        *Use `?` to see app-level controls*
+        - **U** - 🔄 Redo last undone action
+        - **Ctrl+U** - 🔁 Reset to initial state
     """).strip()
 
-    def __init__(
-        self,
-        df: pl.DataFrame,
-        filename: str = "",
-        tabname: str = "",
-        **kwargs,
-    ):
+    # fmt: off
+    BINDINGS = [
+        # Navigation
+        ("g", "jump_top", "Jump to top"),
+        ("G", "jump_bottom", "Jump to bottom"),
+        ("ctrl+f", "forward_page", "Page down"),
+        ("ctrl+b", "backward_page", "Page up"),
+        # Display
+        ("h", "hide_column", "Hide column"),
+        ("H", "show_hidden_rows_columns", "Show hidden rows/columns"),
+        ("tilde", "toggle_row_labels", "Toggle row labels"),  # `~`
+        ("K", "cycle_cursor_type", "Cycle cursor mode"),  # `K`
+        ("z", "freeze_row_column", "Freeze rows/columns"),
+        ("comma", "show_thousand_separator", "Toggle thousand separator"),  # `,`
+        ("underscore", "expand_column", "Expand column to full width"),  # `_`
+        # Copy
+        ("c", "copy_cell", "Copy cell to clipboard"),
+        ("ctrl+c", "copy_column", "Copy column to clipboard"),
+        ("ctrl+r", "copy_row", "Copy row to clipboard"),
+        # Save
+        ("ctrl+s", "save_to_file", "Save to file"),
+        # Detail, Frequency, and Statistics
+        ("enter", "view_row_detail", "View row details"),
+        ("F", "show_frequency", "Show frequency"),
+        ("s", "show_statistics", "Show statistics for column"),
+        ("S", "show_statistics('dataframe')", "Show statistics for dataframe"),
+        # Sort
+        ("left_square_bracket", "sort_ascending", "Sort ascending"),  # `[`
+        ("right_square_bracket", "sort_descending", "Sort descending"),  # `]`
+        # View & Filter
+        ("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"),  # `|`
+        ("right_curly_bracket", "next_selected_row", "Go to next selected row"),  # `}`
+        ("left_curly_bracket", "previous_selected_row", "Go to previous selected row"),  # `{`
+        # Find
+        ("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"),  # `-`
+        ("x", "delete_row", "Delete row"),
+        ("X", "delete_row_and_below", "Delete row and those below"),
+        ("ctrl+x", "delete_row_and_up", "Delete row and those up"),
+        # Duplicate
+        ("d", "duplicate_column", "Duplicate column"),
+        ("D", "duplicate_row", "Duplicate row"),
+        # Edit
+        ("e", "edit_cell", "Edit cell"),
+        ("E", "edit_column", "Edit column"),
+        # Add
+        ("a", "add_column", "Add column"),
+        ("A", "add_column_expr", "Add column with expression"),
+        ("at", "add_link_column", "Add a link column"),  # `@`
+        # Reorder
+        ("shift+left", "move_column_left", "Move column left"),
+        ("shift+right", "move_column_right", "Move column right"),
+        ("shift+up", "move_row_up", "Move row up"),
+        ("shift+down", "move_row_down", "Move row down"),
+        # Type Conversion
+        ("number_sign", "cast_column_dtype('pl.Int64')", "Cast column dtype to integer"),  # `#`
+        ("percent_sign", "cast_column_dtype('pl.Float64')", "Cast column dtype to float"),  # `%`
+        ("exclamation_mark", "cast_column_dtype('pl.Boolean')", "Cast column dtype to bool"),  # `!`
+        ("dollar_sign", "cast_column_dtype('pl.String')", "Cast column dtype to string"),  # `$`
+        # Sql
+        ("l", "simple_sql", "Simple SQL interface"),
+        ("L", "advanced_sql", "Advanced SQL interface"),
+        # Undo/Redo
+        ("u", "undo", "Undo"),
+        ("U", "redo", "Redo"),
+        ("ctrl+u", "reset", "Reset to initial state"),
+    ]
+    # fmt: on
+
+    def __init__(self, df: pl.DataFrame, filename: str = "", name: str = "", **kwargs) -> None:
         """Initialize the DataFrameTable with a dataframe and manage all state.
 
+        Sets up the table widget with display configuration, loads the dataframe, and
+        initializes all state tracking variables for row/column operations.
+
         Args:
-            df: The Polars DataFrame to display
-            filename: Optional filename of the source CSV
-            kwargs: Additional keyword arguments for DataTable
+            df: The Polars DataFrame to display and edit.
+            filename: Optional source filename for the data (used in save operations). Defaults to "".
+            name: Optional display name for the table tab. Defaults to "" (uses filename stem).
+            **kwargs: Additional keyword arguments passed to the parent DataTable widget.
+
+        Returns:
+            None
         """
-        super().__init__(**kwargs)
+        super().__init__(name=(name or Path(filename).stem), **kwargs)
 
         # DataFrame state
         self.dataframe = df  # Original dataframe
         self.df = df  # Internal/working dataframe
         self.filename = filename  # Current filename
-        self.tabname = tabname or Path(filename).stem  # Current tab name
 
         # Pagination & Loading
+        self.INITIAL_BATCH_SIZE = (self.app.size.height // 100 + 1) * 100
+        self.BATCH_SIZE = self.INITIAL_BATCH_SIZE // 2
         self.loaded_rows = 0  # Track how many rows are currently loaded
 
         # State tracking (all 0-based indexing)
         self.sorted_columns: dict[str, bool] = {}  # col_name -> descending
-        self.selected_rows: list[bool] = [False] * len(df)  # Track selected rows
-        self.visible_rows: list[bool] = [True] * len(
-            df
-        )  # Track visible rows (for filtering)
+        self.hidden_columns: set[str] = set()  # Set of hidden column names
+        self.selected_rows: list[bool] = [False] * len(self.df)  # Track selected rows
+        self.visible_rows: list[bool] = [True] * len(self.df)  # Track visible rows (for filtering)
+        self.matches: dict[int, set[int]] = defaultdict(set)  # Track search matches: row_idx -> set of col_idx
 
         # Freezing
         self.fixed_rows = 0  # Number of fixed rows
         self.fixed_columns = 0  # Number of fixed columns
 
-        # History stack for undo/redo
+        # History stack for undo
         self.histories: deque[History] = deque()
+        # Current history state for redo
+        self.history: History = None
 
         # Pending filename for save operations
         self._pending_filename = ""
 
+        # Whether to use thousand separator for numeric display
+        self.thousand_separator = False
+
     @property
     def cursor_key(self) -> CellKey:
-        """Get the current cursor position as a CellKey."""
+        """Get the current cursor position as a CellKey.
+
+        Returns:
+            CellKey: A CellKey object representing the current cursor position.
+        """
         return self.coordinate_to_cell_key(self.cursor_coordinate)
 
     @property
     def cursor_row_key(self) -> RowKey:
-        """Get the current cursor row as a CellKey."""
+        """Get the current cursor row as a RowKey.
+
+        Returns:
+            RowKey: The row key for the row containing the cursor.
+        """
         return self.cursor_key.row_key
 
     @property
-    def cursor_column_key(self) -> ColumnKey:
-        """Get the current cursor column as a ColumnKey."""
+    def cursor_col_key(self) -> ColumnKey:
+        """Get the current cursor column as a ColumnKey.
+
+        Returns:
+            ColumnKey: The column key for the column containing the cursor.
+        """
         return self.cursor_key.column_key
 
     @property
-    def cursor_row_index(self) -> int:
-        """Get the current cursor row index (0-based)."""
-        return int(self.cursor_row_key.value) - 1
+    def cursor_row_idx(self) -> int:
+        """Get the current cursor row index (0-based) as in dataframe.
 
-    def on_mount(self) -> None:
-        """Initialize table display when widget is mounted."""
-        self._setup_table()
+        Returns:
+            int: The 0-based row index of the cursor position.
+
+        Raises:
+            AssertionError: If the cursor row index is out of bounds.
+        """
+        ridx = int(self.cursor_row_key.value)
+        assert 0 <= ridx < len(self.df), "Cursor row index is out of bounds"
+        return ridx
+
+    @property
+    def cursor_col_idx(self) -> int:
+        """Get the current cursor column index (0-based) as in dataframe.
+
+        Returns:
+            int: The 0-based column index of the cursor position.
+
+        Raises:
+            AssertionError: If the cursor column index is out of bounds.
+        """
+        cidx = self.df.columns.index(self.cursor_col_key.value)
+        assert 0 <= cidx < len(self.df.columns), "Cursor column index is out of bounds"
+        return cidx
+
+    @property
+    def cursor_col_name(self) -> str:
+        """Get the current cursor column name as in dataframe.
+
+        Returns:
+            str: The name of the column containing the cursor.
+        """
+        return self.cursor_col_key.value
+
+    @property
+    def cursor_value(self) -> Any:
+        """Get the current cursor cell value.
+
+        Returns:
+            Any: The value of the cell at the cursor position.
+        """
+        return self.df.item(self.cursor_row_idx, self.cursor_col_idx)
+
+    @property
+    def ordered_selected_rows(self) -> list[int]:
+        """Get the list of selected row indices in order.
+
+        Returns:
+            list[int]: A list of 0-based row indices that are currently selected.
+        """
+        return [ridx for ridx, selected in enumerate(self.selected_rows) if selected]
+
+    @property
+    def ordered_matches(self) -> list[tuple[int, int]]:
+        """Get the list of matched cell coordinates in order.
+
+        Returns:
+            list[tuple[int, int]]: A list of (row_idx, col_idx) tuples for matched cells.
+        """
+        matches = []
+        for ridx in sorted(self.matches.keys()):
+            for cidx in sorted(self.matches[ridx]):
+                matches.append((ridx, cidx))
+        return matches
+
+    def get_row_key(self, row_idx: int) -> RowKey:
+        """Get the row key for a given table row index.
+
+        Args:
+            row_idx: Row index in the table display.
+
+        Returns:
+            Corresponding row key as string.
+        """
+        return self._row_locations.get_key(row_idx)
+
+    def get_column_key(self, col_idx: int) -> ColumnKey:
+        """Get the column key for a given table column index.
+
+        Args:
+            col_idx: Column index in the table display.
 
-    def _should_highlight(
-        self,
-        cursor: Coordinate,
-        target_cell: Coordinate,
-        type_of_cursor: CursorType,
-    ) -> bool:
+        Returns:
+            Corresponding column key as string.
+        """
+        return self._column_locations.get_key(col_idx)
+
+    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"
@@ -192,10 +464,10 @@ class DataFrameTable(DataTable):
         Args:
             cursor: The current position of the cursor.
             target_cell: The cell we're checking for the need to highlight.
-            type_of_cursor: The type of cursor that is currently active.
+            type_of_cursor: The type of cursor that is currently active ("cell", "row", or "column").
 
         Returns:
-            Whether or not the given cell should be highlighted.
+            bool: True if the target cell should be highlighted, False otherwise.
         """
         if type_of_cursor == "cell":
             # Return true if the cursor is over the target cell
@@ -216,15 +488,19 @@ class DataFrameTable(DataTable):
         else:
             return False
 
-    def watch_cursor_coordinate(
-        self, old_coordinate: Coordinate, new_coordinate: Coordinate
-    ) -> None:
-        """Refresh highlighting when cursor coordinate changes.
+    def watch_cursor_coordinate(self, old_coordinate: Coordinate, new_coordinate: Coordinate) -> None:
+        """Handle cursor position changes and refresh highlighting.
+
+        This method is called by Textual whenever the cursor moves. It refreshes cells that need
+        to change their highlight state. Also emits CellSelected message when cursor type is "cell"
+        for keyboard navigation only (mouse clicks already trigger it).
 
-        This explicitly refreshes cells that need to change their highlight state
-        to fix the delay issue with column label highlighting. Also emits CellSelected
-        message when cursor type is "cell" for keyboard navigation only (mouse clicks
-        already trigger the parent class's CellSelected message).
+        Args:
+            old_coordinate: The previous cursor coordinate.
+            new_coordinate: The new cursor coordinate.
+
+        Returns:
+            None
         """
         if old_coordinate != new_coordinate:
             # Emit CellSelected message for cell cursor type (keyboard navigation only)
@@ -251,10 +527,10 @@ class DataFrameTable(DataTable):
                 self.refresh_row(new_row)
             elif self.cursor_type == "row":
                 self.refresh_row(old_coordinate.row)
-                self.refresh_row(new_coordinate.row)
+                self._highlight_row(new_coordinate.row)
             elif self.cursor_type == "column":
                 self.refresh_column(old_coordinate.column)
-                self.refresh_column(new_coordinate.column)
+                self._highlight_column(new_coordinate.column)
 
             # Handle scrolling if needed
             if self._require_update_dimensions:
@@ -262,94 +538,360 @@ class DataFrameTable(DataTable):
             else:
                 self._scroll_cursor_into_view()
 
+    def move_cursor_to(self, ridx: int, cidx: int) -> None:
+        """Move cursor based on the dataframe indices.
+
+        Args:
+            ridx: Row index (0-based) in the dataframe.
+            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)
+
+        row_key = str(ridx)
+        col_key = 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)
+
+    def on_mount(self) -> None:
+        """Initialize table display when the widget is mounted.
+
+        Called by Textual when the widget is first added to the display tree.
+        Currently a placeholder as table setup is deferred until first use.
+
+        Returns:
+            None
+        """
+        # self._setup_table()
+        pass
+
     def on_key(self, event) -> None:
-        """Handle keyboard events for table operations and navigation."""
-        if event.key == "g":
-            # Jump to top
-            self.move_cursor(row=0)
-        elif event.key == "G":
-            # Load all remaining rows before jumping to end
-            self._load_rows()
-            self.move_cursor(row=self.row_count - 1)
-        elif event.key in ("pagedown", "down"):
+        """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.
+
+        Returns:
+            None
+        """
+        if event.key in ("pagedown", "down"):
             # Let the table handle the navigation first
             self._check_and_load_more()
-        elif event.key == "enter":
-            # Open row detail modal
-            self._view_row_detail()
-        elif event.key == "minus":
-            # Remove the current column
-            self._delete_column()
-        elif event.key == "left_square_bracket":  # '['
-            # Sort by current column in ascending order
-            self._sort_by_column(descending=False)
-        elif event.key == "right_square_bracket":  # ']'
-            # Sort by current column in descending order
-            self._sort_by_column(descending=True)
-        elif event.key == "ctrl+s":
-            # Save dataframe to CSV
-            self._save_to_file()
-        elif event.key == "F":  # shift+f
-            # Open frequency modal for current column
-            self._show_frequency()
-        elif event.key == "v":
-            # Filter by current cell value
-            self._filter_rows()
-        elif event.key == "V":  # shift+v
-            # Open filter screen for current column
-            self._open_filter_screen()
-        elif event.key == "e":
-            # Open edit modal for current cell
-            self._edit_cell()
-        elif event.key == "backslash":  # '\' key
-            # Search with current cell value and highlight matched rows
-            self._search_with_cell_value()
-        elif event.key == "vertical_line":  # '|' key
-            # Open search modal for current column
-            self._search_column()
-        elif event.key == "slash":  # '/' key
-            # Open search modal for all columns
-            self._search_column(all_columns=True)
-        elif event.key == "s":
-            # Toggle selection for current row
-            self._toggle_selected_rows(current_row=True)
-        elif event.key == "t":
-            # Toggle selected rows highlighting
-            self._toggle_selected_rows()
-        elif event.key == "quotation_mark":  # '"' key
-            # Display selected rows only
-            self._filter_selected_rows()
-        elif event.key == "d":
-            # Delete the current row
-            self._delete_row()
-        elif event.key == "u":
-            # Undo last action
-            self._undo()
-        elif event.key == "U":
-            # Undo all changes and restore original dataframe
-            self._setup_table(reset=True)
-            self.app.notify("Restored original display", title="Reset")
-        elif event.key == "shift+left":  # shift + left arrow
-            # Move current column to the left
-            self._move_column("left")
-        elif event.key == "shift+right":  # shift + right arrow
-            # Move current column to the right
-            self._move_column("right")
-        elif event.key == "shift+up":  # shift + up arrow
-            # Move current row up
-            self._move_row("up")
-        elif event.key == "shift+down":  # shift + down arrow
-            # Move current row down
-            self._move_row("down")
-        elif event.key == "T":  # shift+t
-            # Clear all selected rows
-            self._clear_selected_rows()
-        elif event.key == "C":  # shift+c
-            # Cycle through cursor types
-            self._cycle_cursor_type()
-        elif event.key == "f":
-            # Open pin screen to set fixed rows and columns
-            self._open_freeze_screen()
+
+    def on_click(self, event: Click) -> None:
+        """Handle mouse click events on the table.
+
+        Supports double-click editing of cells and renaming of column headers.
+
+        Args:
+            event: The click event containing row and column information.
+
+        Returns:
+            None
+        """
+        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"]
+            except (KeyError, TypeError):
+                return  # Unable to get row/column info
+
+            # header row
+            if row_idx == -1:
+                self._rename_column()
+            else:
+                self._edit_cell()
+
+    # Action handlers for BINDINGS
+    def action_jump_top(self) -> None:
+        """Jump to the top of the table."""
+        self.move_cursor(row=0)
+
+    def action_jump_bottom(self) -> None:
+        """Jump to the bottom of the table."""
+        self._load_rows(move_to_end=True)
+
+    def action_forward_page(self) -> None:
+        """Scroll down one page."""
+        super().action_page_down()
+        self._check_and_load_more()
+
+    def action_backward_page(self) -> None:
+        """Scroll up one page."""
+        super().action_page_up()
+
+    def action_view_row_detail(self) -> None:
+        """View details of the current row."""
+        self._view_row_detail()
+
+    def action_delete_column(self) -> None:
+        """Delete the current column."""
+        self._delete_column()
+
+    def action_hide_column(self) -> None:
+        """Hide the current column."""
+        self._hide_column()
+
+    def action_expand_column(self) -> None:
+        """Expand the current column to its full width."""
+        self._expand_column()
+
+    def action_show_hidden_rows_columns(self) -> None:
+        """Show all hidden rows/columns."""
+        self._show_hidden_rows_columns()
+
+    def action_sort_ascending(self) -> None:
+        """Sort by current column in ascending order."""
+        self._sort_by_column(descending=False)
+
+    def action_sort_descending(self) -> None:
+        """Sort by current column in descending order."""
+        self._sort_by_column(descending=True)
+
+    def action_save_to_file(self) -> None:
+        """Save the current dataframe to a file."""
+        self._save_to_file()
+
+    def action_show_frequency(self) -> None:
+        """Show frequency distribution for the current column."""
+        self._show_frequency()
+
+    def action_show_statistics(self, scope: str = "column") -> None:
+        """Show statistics for the current column or entire dataframe.
+
+        Args:
+            scope: Either "column" for current column stats or "dataframe" for all columns.
+        """
+        self._show_statistics(scope)
+
+    def action_view_rows(self) -> None:
+        """View rows by current cell value."""
+        self._view_rows()
+
+    def action_view_rows_expr(self) -> None:
+        """Open the advanced filter screen."""
+        self._view_rows_expr()
+
+    def action_edit_cell(self) -> None:
+        """Edit the current cell."""
+        self._edit_cell()
+
+    def action_edit_column(self) -> None:
+        """Edit the entire current column with an expression."""
+        self._edit_column()
+
+    def action_add_column(self) -> None:
+        """Add an empty column after the current column."""
+        self._add_column()
+
+    def action_add_column_expr(self) -> None:
+        """Add a new column with optional expression after the current column."""
+        self._add_column_expr()
+
+    def action_add_link_column(self) -> None:
+        """Open AddLinkScreen to create a new link column from a Polars expression."""
+        self._add_link_column()
+
+    def action_rename_column(self) -> None:
+        """Rename the current column."""
+        self._rename_column()
+
+    def action_clear_cell(self) -> None:
+        """Clear the current cell (set to None)."""
+        self._clear_cell()
+
+    def action_search_cursor_value(self) -> None:
+        """Search cursor value in the current column."""
+        self._search_cursor_value()
+
+    def action_search_expr(self) -> None:
+        """Search by expression in the current column."""
+        self._search_expr()
+
+    def action_find_cursor_value(self, scope="column") -> None:
+        """Find by cursor value.
+
+        Args:
+            scope: "column" to find in current column, "global" to find across all columns.
+        """
+        self._find_cursor_value(scope=scope)
+
+    def action_find_expr(self, scope="column") -> None:
+        """Find by expression.
+
+        Args:
+            scope: "column" to find in current column, "global" to find across all columns.
+        """
+        self._find_expr(scope=scope)
+
+    def action_replace(self) -> None:
+        """Replace values in current column."""
+        self._replace()
+
+    def action_replace_global(self) -> None:
+        """Replace values across all columns."""
+        self._replace_global()
+
+    def action_toggle_row_selection(self) -> None:
+        """Toggle selection for the current row."""
+        self._toggle_row_selection()
+
+    def action_toggle_selections(self) -> None:
+        """Toggle all row selections."""
+        self._toggle_selections()
+
+    def action_filter_rows(self) -> None:
+        """Filter to show only selected rows."""
+        self._filter_rows()
+
+    def action_delete_row(self) -> None:
+        """Delete the current row."""
+        self._delete_row()
+
+    def action_delete_row_and_below(self) -> None:
+        """Delete the current row and those below."""
+        self._delete_row(more="below")
+
+    def action_delete_row_and_up(self) -> None:
+        """Delete the current row and those above."""
+        self._delete_row(more="above")
+
+    def action_duplicate_column(self) -> None:
+        """Duplicate the current column."""
+        self._duplicate_column()
+
+    def action_duplicate_row(self) -> None:
+        """Duplicate the current row."""
+        self._duplicate_row()
+
+    def action_undo(self) -> None:
+        """Undo the last action."""
+        self._undo()
+
+    def action_redo(self) -> None:
+        """Redo the last undone action."""
+        self._redo()
+
+    def action_reset(self) -> None:
+        """Reset to the initial state."""
+        self._setup_table(reset=True)
+        self.notify("Restored initial state", title="Reset")
+
+    def action_move_column_left(self) -> None:
+        """Move the current column to the left."""
+        self._move_column("left")
+
+    def action_move_column_right(self) -> None:
+        """Move the current column to the right."""
+        self._move_column("right")
+
+    def action_move_row_up(self) -> None:
+        """Move the current row up."""
+        self._move_row("up")
+
+    def action_move_row_down(self) -> None:
+        """Move the current row down."""
+        self._move_row("down")
+
+    def action_clear_selections_and_matches(self) -> None:
+        """Clear all row selections and matches."""
+        self._clear_selections_and_matches()
+
+    def action_cycle_cursor_type(self) -> None:
+        """Cycle through cursor types."""
+        self._cycle_cursor_type()
+
+    def action_freeze_row_column(self) -> None:
+        """Open the freeze screen."""
+        self._freeze_row_column()
+
+    def action_toggle_row_labels(self) -> None:
+        """Toggle row labels visibility."""
+        self.show_row_labels = not self.show_row_labels
+        # status = "shown" if self.show_row_labels else "hidden"
+        # self.notify(f"Row labels {status}", title="Labels")
+
+    def action_cast_column_dtype(self, dtype: str | pl.DataType) -> None:
+        """Cast the current column to a different data type."""
+        self._cast_column_dtype(dtype)
+
+    def action_copy_cell(self) -> None:
+        """Copy the current cell to clipboard."""
+        ridx = self.cursor_row_idx
+        cidx = self.cursor_col_idx
+
+        try:
+            cell_str = str(self.df.item(ridx, cidx))
+            self._copy_to_clipboard(cell_str, f"Copied: [$success]{cell_str[:50]}[/]")
+        except IndexError:
+            self.notify("Error copying cell", title="Clipboard", severity="error")
+
+    def action_copy_column(self) -> None:
+        """Copy the current column to clipboard (one value per line)."""
+        col_name = self.cursor_col_name
+
+        try:
+            # Get all values in the column and join with newlines
+            col_values = [str(val) for val in self.df[col_name].to_list()]
+            col_str = "\n".join(col_values)
+
+            self._copy_to_clipboard(
+                col_str,
+                f"Copied [$accent]{len(col_values)}[/] values from column [$success]{col_name}[/]",
+            )
+        except (FileNotFoundError, IndexError):
+            self.notify("Error copying column", title="Clipboard", severity="error")
+
+    def action_copy_row(self) -> None:
+        """Copy the current row to clipboard (values separated by tabs)."""
+        ridx = self.cursor_row_idx
+
+        try:
+            # Get all values in the row and join with tabs
+            row_values = [str(val) for val in self.df.row(ridx)]
+            row_str = "\t".join(row_values)
+
+            self._copy_to_clipboard(
+                row_str,
+                f"Copied row [$accent]{ridx + 1}[/] with [$success]{len(row_values)}[/] values",
+            )
+        except (FileNotFoundError, IndexError):
+            self.notify("Error copying row", title="Clipboard", severity="error")
+
+    def action_show_thousand_separator(self) -> None:
+        """Toggle thousand separator for numeric display."""
+        self.thousand_separator = not self.thousand_separator
+        self._setup_table()
+        # status = "enabled" if self.thousand_separator else "disabled"
+        # self.notify(f"Thousand separator {status}", title="Display")
+
+    def action_next_match(self) -> None:
+        """Go to the next matched cell."""
+        self._next_match()
+
+    def action_previous_match(self) -> None:
+        """Go to the previous matched cell."""
+        self._previous_match()
+
+    def action_next_selected_row(self) -> None:
+        """Go to the next selected row."""
+        self._next_selected_row()
+
+    def action_previous_selected_row(self) -> None:
+        """Go to the previous selected row."""
+        self._previous_selected_row()
+
+    def action_simple_sql(self) -> None:
+        """Open the SQL interface screen."""
+        self._simple_sql()
+
+    def action_advanced_sql(self) -> None:
+        """Open the advanced SQL interface screen."""
+        self._advanced_sql()
 
     def on_mouse_scroll_down(self, event) -> None:
         """Load more rows when scrolling down with mouse."""
@@ -357,215 +899,453 @@ class DataFrameTable(DataTable):
 
     # Setup & Loading
     def _setup_table(self, reset: bool = False) -> None:
-        """Setup the table for display."""
+        """Setup the table for display.
+
+        Row keys are 0-based indices, which map directly to dataframe row indices.
+        Column keys are header names from the dataframe.
+        """
+        self.loaded_rows = 0
+        self.show_row_labels = True
+
         # Reset to original dataframe
         if reset:
             self.df = self.dataframe
             self.loaded_rows = 0
             self.sorted_columns = {}
+            self.hidden_columns = set()
             self.selected_rows = [False] * len(self.df)
             self.visible_rows = [True] * len(self.df)
             self.fixed_rows = 0
             self.fixed_columns = 0
+            self.matches = defaultdict(set)
 
         # Lazy load up to INITIAL_BATCH_SIZE visible rows
-        stop, visible_count = len(self.df), 0
+        stop, visible_count = self.INITIAL_BATCH_SIZE, 0
         for row_idx, visible in enumerate(self.visible_rows):
             if not visible:
                 continue
             visible_count += 1
-            if visible_count >= INITIAL_BATCH_SIZE:
-                stop = row_idx + 1
+            if visible_count > self.INITIAL_BATCH_SIZE:
+                stop = row_idx + self.BATCH_SIZE
                 break
+        else:
+            stop = row_idx + self.BATCH_SIZE
+
+        # # 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)
+
+        # Save current cursor position before clearing
+        row_idx, col_idx = self.cursor_coordinate
 
         self._setup_columns()
         self._load_rows(stop)
-        self._highlight_rows()
 
         # Restore cursor position
-        row_idx, col_idx = self.cursor_coordinate
         if row_idx < len(self.rows) and col_idx < len(self.columns):
             self.move_cursor(row=row_idx, column=col_idx)
 
+    def _determine_column_widths(self) -> dict[str, int]:
+        """Determine optimal width for each column based on data type and content.
+
+        For String columns:
+        - Minimum width: length of column label
+        - Ideal width: maximum width of all cells in the column
+        - If space constrained: find appropriate width smaller than maximum
+
+        For non-String columns:
+        - Return None to let Textual auto-determine width
+
+        Returns:
+            dict[str, int]: Mapping of column name to width (None for auto-sizing columns).
+        """
+        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
+
+        # 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]
+
+        # No string columns, let TextualDataTable auto-size all columns
+        if not string_cols:
+            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_lf = self.df.lazy().slice(0, sample_size)
+
+        # Determine widths for each column
+        for col, dtype in zip(self.df.columns, self.df.dtypes):
+            if col in self.hidden_columns:
+                continue
+
+            # Get column label width
+            # Add padding for sort indicators if any
+            label_width = measure(self.app.console, col, 1) + 2
+
+            try:
+                # Get sample values from the column
+                sample_values = sample_lf.select(col).collect().get_column(col).to_list()
+                if any(val.startswith(("https://", "http://")) for val in sample_values):
+                    continue  # Skip link columns so they can auto-size and be clickable
+
+                # Find maximum width in sample
+                max_cell_width = max(
+                    (measure(self.app.console, str(val), 1) for val in sample_values if val),
+                    default=label_width,
+                )
+
+                # Set column width to max of label and sampled data (capped at reasonable max)
+                max_width = max(label_width, max_cell_width)
+            except Exception:
+                # If any error, let Textual auto-size
+                max_width = label_width
+
+            if dtype == pl.String:
+                column_widths[col] = max_width
+
+            available_width -= max_width
+
+        # If there's no more available width, auto-size remaining columns
+        if available_width < 0:
+            for col in column_widths:
+                if column_widths[col] > STRING_WIDTH_CAP:
+                    column_widths[col] = STRING_WIDTH_CAP  # Cap string columns
+
+        return column_widths
+
     def _setup_columns(self) -> None:
-        """Clear table and setup columns."""
-        self.loaded_rows = 0
+        """Clear table and setup columns.
+
+        Column keys are header names from the dataframe.
+        Column labels contain column names from the dataframe, with sort indicators if applicable.
+        """
         self.clear(columns=True)
-        self.show_row_labels = True
+
+        # Get optimal column widths
+        column_widths = self._determine_column_widths()
 
         # Add columns with justified headers
         for col, dtype in zip(self.df.columns, self.df.dtypes):
+            if col in self.hidden_columns:
+                continue  # Skip hidden columns
             for idx, c in enumerate(self.sorted_columns, 1):
                 if c == col:
                     # Add sort indicator to column header
                     descending = self.sorted_columns[col]
                     sort_indicator = (
-                        f" ▼{SUBSCRIPT_DIGITS.get(idx, '')}"
-                        if descending
-                        else f" ▲{SUBSCRIPT_DIGITS.get(idx, '')}"
+                        f" ▼{SUBSCRIPT_DIGITS.get(idx, '')}" if descending else f" ▲{SUBSCRIPT_DIGITS.get(idx, '')}"
                     )
-                    header_text = col + sort_indicator
-                    self.add_column(
-                        Text(header_text, justify=DtypeConfig(dtype).justify), key=col
-                    )
-
+                    cell_value = col + sort_indicator
                     break
             else:  # No break occurred, so column is not sorted
-                self.add_column(Text(col, justify=DtypeConfig(dtype).justify), key=col)
-
-    def _check_and_load_more(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
+                cell_value = col
 
-        visible_row_count = self.size.height - self.header_height
-        bottom_visible_row = self.scroll_y + visible_row_count
+            # Get the width for this column (None means auto-size)
+            width = column_widths.get(col)
 
-        # 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 + BATCH_SIZE)
+            self.add_column(Text(cell_value, justify=DtypeConfig(dtype).justify), key=col, width=width)
 
-    def _load_rows(self, stop: int | None = None) -> None:
-        """Load a batch of rows into the table.
+    def _load_rows(self, stop: int | None = None, move_to_end: bool = False) -> None:
+        """Load a batch of rows into the table (synchronous wrapper).
 
         Args:
-            stop: Stop loading rows when this index is reached. If None, load until the end of the dataframe.
+            stop: Stop loading rows when this index is reached.
+                  If None, load until the end of the dataframe.
         """
         if stop is None or stop > len(self.df):
             stop = len(self.df)
 
+        # If already loaded enough rows, just move cursor if needed
         if stop <= self.loaded_rows:
+            if move_to_end:
+                self.move_cursor(row=self.row_count - 1)
+
             return
 
-        start = self.loaded_rows
-        df_slice = self.df.slice(start, stop - start)
-
-        for row_idx, row in enumerate(df_slice.rows(), start):
-            if not self.visible_rows[row_idx]:
-                continue  # Skip hidden rows
-            vals, dtypes = [], []
-            for val, dtype in zip(row, self.df.dtypes):
-                vals.append(val)
-                dtypes.append(dtype)
-            formatted_row = _format_row(vals, dtypes)
-            # Always add labels so they can be shown/hidden via CSS
-            self.add_row(*formatted_row, key=str(row_idx + 1), label=str(row_idx + 1))
-
-        # Update loaded rows count
-        self.loaded_rows = stop
-
-        self.app.notify(
-            f"Loaded [$accent]{self.loaded_rows}/{len(self.df)}[/] rows from [on $primary]{self.tabname}[/]",
-            title="Load",
-        )
+        # Warn user if loading a large number of rows
+        elif (nrows := stop - self.loaded_rows) >= WARN_ROWS_THRESHOLD:
 
-    def _highlight_rows(self, clear: bool = False) -> None:
-        """Update all rows, highlighting selected ones in red and restoring others to default.
+            def _continue(result: bool) -> None:
+                if result:
+                    self._load_rows_async(stop, move_to_end=move_to_end)
 
-        Args:
-            clear: If True, clear all highlights.
-        """
-        if True not in self.selected_rows:
-            return
+            self.app.push_screen(
+                ConfirmScreen(
+                    f"Load {nrows} Rows",
+                    label="Loading a large number of rows may cause the application to become unresponsive. Do you want to continue?",
+                ),
+                callback=_continue,
+            )
 
-        if clear:
-            self.selected_rows = [False] * len(self.df)
+            return
 
-        # Ensure all highlighted rows are loaded
-        stop = _rindex(self.selected_rows, True) + 1
-        self._load_rows(stop)
+        # Load rows asynchronously
+        self._load_rows_async(stop, move_to_end=move_to_end)
 
-        # Update all rows based on selected state
-        for row in self.ordered_rows:
-            row_idx = int(row.key.value) - 1  # Convert to 0-based index
-            is_selected = self.selected_rows[row_idx]
+    @work(exclusive=True, description="Loading rows...")
+    async def _load_rows_async(self, stop: int, move_to_end: bool = False) -> None:
+        """Perform loading with async to avoid blocking.
 
-            # Update all cells in this row
-            for col_idx, col in enumerate(self.ordered_columns):
-                cell_text: Text = self.get_cell(row.key, col.key)
-                dtype = self.df.dtypes[col_idx]
+        Args:
+            stop: Stop loading rows when this index is reached.
+            move_to_end: If True, move cursor to the last loaded row after loading completes.
+        """
+        # Load rows in smaller chunks to avoid blocking
+        if stop > self.loaded_rows:
+            self.log(f"Async loading up to row {self.loaded_rows = }, {stop = }")
+            # Load incrementally to avoid one big block
+            # 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)
+
+            # If there's more to load, yield to event loop with delay
+            if next_stop < stop:
+                await sleep_async(0.05)  # 50ms delay to allow UI updates
+                self._load_rows_async(stop, move_to_end=move_to_end)
+                return
 
-                # Get style config based on dtype
-                dc = DtypeConfig(dtype)
+        # After loading completes, move cursor to end if requested
+        if move_to_end:
+            self.call_after_refresh(lambda: self.move_cursor(row=self.row_count - 1))
 
-                # Use red for selected rows, default style for others
-                style = "red" if is_selected else dc.style
-                cell_text.style = style
+    def _load_rows_batch(self, stop: int) -> None:
+        """Load a batch of rows into the table.
 
-                # Update the cell in the table
-                self.update_cell(row.key, col.key, cell_text)
+        Row keys are 0-based indices as strings, which map directly to dataframe row indices.
+        Row labels are 1-based indices as strings.
 
-    # History & Undo
-    def _add_history(self, description: str) -> None:
-        """Add the current state to the history stack.
+        Args:
+            stop: Stop loading rows when this index is reached.
+        """
+        try:
+            start = self.loaded_rows
+            df_slice = self.df.slice(start, stop - start)
+
+            for ridx, row in enumerate(df_slice.rows(), 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)
+
+                # Always add labels so they can be shown/hidden via CSS
+                self.add_row(*formatted_row, key=str(ridx), label=str(ridx + 1))
+
+            # Update loaded rows count
+            self.loaded_rows = 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}`")
+
+        except Exception as e:
+            self.notify("Error loading rows", title="Load", severity="error")
+            self.log(f"Error loading rows: {str(e)}")
+
+    def _check_and_load_more(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
+
+        # 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)
+
+    # Highlighting
+    def _do_highlight(self, force: bool = False) -> None:
+        """Update all rows, highlighting selected ones and restoring others to default.
 
         Args:
-            description: Description of the action for this history entry.
+            force: If True, clear all highlights and restore default styles.
         """
-        history = History(
+        # Ensure all selected rows or matches are loaded
+        stop = rindex(self.selected_rows, True) + 1
+        stop = max(stop, max(self.matches.keys(), default=0) + 1)
+
+        self._load_rows(stop)
+        self._highlight_table(force)
+
+    def _highlight_table(self, force: bool = False) -> None:
+        """Highlight selected rows/cells in red."""
+        if not force and not any(self.selected_rows) and not self.matches:
+            return  # Nothing to highlight
+
+        # Update all rows based on selected state
+        for row in self.ordered_rows:
+            ridx = int(row.key.value)  # 0-based index
+            is_selected = self.selected_rows[ridx]
+            match_cols = self.matches.get(ridx, set())
+
+            if not force and not is_selected and not match_cols:
+                continue  # No highlight needed for this row
+
+            # Update all cells in this row
+            for col_idx, col in enumerate(self.ordered_columns):
+                if not force and not is_selected and col_idx not in match_cols:
+                    continue  # No highlight needed for this cell
+
+                cell_text: Text = self.get_cell(row.key, col.key)
+                need_update = False
+
+                if is_selected or col_idx in match_cols:
+                    cell_text.style = HIGHLIGHT_COLOR
+                    need_update = True
+                elif force:
+                    # Restore original style based on dtype
+                    dtype = self.df.schema[col.key.value]
+                    dc = DtypeConfig(dtype)
+                    cell_text.style = dc.style
+                    need_update = True
+
+                # Update the cell in the table
+                if need_update:
+                    self.update_cell(row.key, col.key, cell_text)
+
+    # History & Undo
+    def _create_history(self, description: str) -> None:
+        """Create the initial history state."""
+        return History(
             description=description,
             df=self.df,
             filename=self.filename,
             loaded_rows=self.loaded_rows,
             sorted_columns=self.sorted_columns.copy(),
+            hidden_columns=self.hidden_columns.copy(),
             selected_rows=self.selected_rows.copy(),
             visible_rows=self.visible_rows.copy(),
             fixed_rows=self.fixed_rows,
             fixed_columns=self.fixed_columns,
             cursor_coordinate=self.cursor_coordinate,
+            matches={k: v.copy() for k, v in self.matches.items()},
         )
-        self.histories.append(history)
 
-    def _undo(self) -> None:
-        """Undo the last action."""
-        if not self.histories:
-            self.app.notify("No actions to undo", title="Undo", severity="warning")
+    def _apply_history(self, history: History) -> None:
+        """Apply the current history state to the table."""
+        if history is None:
             return
 
-        history = self.histories.pop()
-
         # Restore state
         self.df = history.df
         self.filename = history.filename
         self.loaded_rows = history.loaded_rows
         self.sorted_columns = history.sorted_columns.copy()
+        self.hidden_columns = history.hidden_columns.copy()
         self.selected_rows = history.selected_rows.copy()
         self.visible_rows = history.visible_rows.copy()
         self.fixed_rows = history.fixed_rows
         self.fixed_columns = history.fixed_columns
         self.cursor_coordinate = history.cursor_coordinate
+        self.matches = {k: v.copy() for k, v in history.matches.items()} if history.matches else defaultdict(set)
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
-        self.app.notify(f"Reverted: {history.description}", title="Undo")
+    def _add_history(self, description: str) -> None:
+        """Add the current state to the history stack.
+
+        Args:
+            description: Description of the action for this history entry.
+        """
+        history = self._create_history(description)
+        self.histories.append(history)
+
+    def _undo(self) -> None:
+        """Undo the last action."""
+        if not self.histories:
+            self.notify("No actions to undo", title="Undo", severity="warning")
+            return
+
+        # Pop the last history state for undo
+        history = self.histories.pop()
+
+        # Save current state for redo
+        self.history = self._create_history(history.description)
+
+        # Restore state
+        self._apply_history(history)
+
+        self.notify(f"Reverted: {history.description}", title="Undo")
+
+    def _redo(self) -> None:
+        """Redo the last undone action."""
+        if self.history is None:
+            self.notify("No actions to redo", title="Redo", severity="warning")
+            return
+
+        description = self.history.description
+
+        # Save current state for undo
+        self._add_history(description)
+
+        # Restore state
+        self._apply_history(self.history)
+
+        # Clear redo state
+        self.history = None
+
+        self.notify(f"Reapplied: {description}", title="Redo")
+
+    # Display
+    def _cycle_cursor_type(self) -> None:
+        """Cycle through cursor types: cell -> row -> column -> cell."""
+        next_type = get_next_item(CURSOR_TYPES, self.cursor_type)
+        self.cursor_type = next_type
+
+        # self.notify(f"Changed cursor type to [$success]{next_type}[/]", title="Cursor")
 
-    # View
     def _view_row_detail(self) -> None:
         """Open a modal screen to view the selected row's details."""
-        row_idx = self.cursor_row
-        if row_idx >= len(self.df):
-            return
+        ridx = self.cursor_row_idx
 
         # Push the modal screen
-        self.app.push_screen(RowDetailScreen(row_idx, self))
+        self.app.push_screen(RowDetailScreen(ridx, self))
 
     def _show_frequency(self) -> None:
         """Show frequency distribution for the current column."""
-        col_idx = self.cursor_column
-        if col_idx >= len(self.df.columns):
-            return
+        cidx = self.cursor_col_idx
 
         # Push the frequency modal screen
-        self.app.push_screen(FrequencyScreen(col_idx, self))
+        self.app.push_screen(FrequencyScreen(cidx, self))
+
+    def _show_statistics(self, scope: str = "column") -> None:
+        """Show statistics for the current column or entire dataframe.
+
+        Args:
+            scope: Either "column" for current column stats or "dataframe" for all columns.
+        """
+        if scope == "dataframe":
+            # Show statistics for entire dataframe
+            self.app.push_screen(StatisticsScreen(self, col_idx=None))
+        else:
+            # Show statistics for current column
+            cidx = self.cursor_col_idx
+            self.app.push_screen(StatisticsScreen(self, col_idx=cidx))
 
-    def _open_freeze_screen(self) -> None:
+    def _freeze_row_column(self) -> None:
         """Open the freeze screen to set fixed rows and columns."""
         self.app.push_screen(FreezeScreen(), callback=self._do_freeze)
 
     def _do_freeze(self, result: tuple[int, int] | None) -> None:
-        """Handle result from FreezeScreen.
+        """Handle result from PinScreen.
 
         Args:
             result: Tuple of (fixed_rows, fixed_columns) or None if cancelled.
@@ -576,101 +1356,311 @@ class DataFrameTable(DataTable):
         fixed_rows, fixed_columns = result
 
         # Add to history
-        self._add_history(
-            f"Pinned [$accent]{fixed_rows}[/] rows and [$accent]{fixed_columns}[/] columns"
-        )
+        self._add_history(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns")
 
         # Apply the pin settings to the table
-        if fixed_rows > 0:
+        if fixed_rows >= 0:
             self.fixed_rows = fixed_rows
-        if fixed_columns > 0:
+        if fixed_columns >= 0:
             self.fixed_columns = fixed_columns
 
-        self.app.notify(
-            f"Pinned [$accent]{fixed_rows}[/] rows and [$accent]{fixed_columns}[/] columns",
-            title="Pin",
+        # self.notify(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns", title="Pin")
+
+    def _hide_column(self) -> None:
+        """Hide the currently selected column from the table display."""
+        col_key = self.cursor_col_key
+        col_name = col_key.value
+        col_idx = self.cursor_column
+
+        # Add to history
+        self._add_history(f"Hid column [$success]{col_name}[/]")
+
+        # Remove the column from the table display (but keep in dataframe)
+        self.remove_column(col_key)
+
+        # Track hidden columns
+        self.hidden_columns.add(col_name)
+
+        # Move cursor left if we hid the last column
+        if col_idx >= len(self.columns):
+            self.move_cursor(column=len(self.columns) - 1)
+
+        # self.notify(f"Hid column [$accent]{col_name}[/]. Press [$success]H[/] to show hidden columns", title="Hide")
+
+    def _expand_column(self) -> None:
+        """Expand the current column to show the widest cell in the loaded data."""
+        col_idx = self.cursor_col_idx
+        col_key = self.cursor_col_key
+        col_name = col_key.value
+        dtype = self.df.dtypes[col_idx]
+
+        # Only expand string columns
+        if dtype != pl.String:
+            return
+
+        # Calculate the maximum width across all loaded rows
+        max_width = len(col_name) + 2  # Start with column name width + padding
+
+        try:
+            # Scan through all loaded rows that are visible to find max width
+            for row_idx in range(self.loaded_rows):
+                if not self.visible_rows[row_idx]:
+                    continue  # Skip hidden rows
+                cell_value = str(self.df.item(row_idx, col_idx))
+                cell_width = measure(self.app.console, cell_value, 1)
+                max_width = max(max_width, cell_width)
+
+            # Update the column width
+            col = self.columns[col_key]
+            col.width = max_width
+
+            # Force a refresh
+            self._update_count += 1
+            self._require_update_dimensions = True
+            self.refresh(layout=True)
+
+            # self.notify(f"Expanded column [$success]{col_name}[/] to width [$accent]{max_width}[/]", title="Expand")
+        except Exception as e:
+            self.notify("Error expanding column", title="Expand", severity="error")
+            self.log(f"Error expanding column `{col_name}`: {str(e)}")
+
+    def _show_hidden_rows_columns(self) -> None:
+        """Show all hidden rows/columns by recreating the table."""
+        # Get currently visible columns
+        visible_cols = set(col.key for col in self.ordered_columns)
+
+        hidden_row_count = sum(0 if visible else 1 for visible in self.visible_rows)
+        hidden_col_count = sum(0 if col in visible_cols else 1 for col in self.df.columns)
+
+        if not hidden_row_count and not hidden_col_count:
+            self.notify("No hidden columns or rows to show", title="Show", severity="warning")
+            return
+
+        # Add to history
+        self._add_history("Showed hidden rows/columns")
+
+        # Clear hidden rows/columns tracking
+        self.visible_rows = [True] * len(self.df)
+        self.hidden_columns.clear()
+
+        # Recreate table for display
+        self._setup_table()
+
+        self.notify(
+            f"Showed [$accent]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] column(s)",
+            title="Show",
         )
 
     # Delete & Move
-    def _delete_column(self) -> None:
+    def _delete_column(self, more: str = None) -> None:
         """Remove the currently selected column from the table."""
+        # Get the column to remove
         col_idx = self.cursor_column
-        if col_idx >= len(self.df.columns):
-            return
+        col_name = self.cursor_col_name
+        col_key = self.cursor_col_key
+
+        col_names_to_remove = []
+        col_keys_to_remove = []
+
+        # 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_names_to_remove.append(col_key.value)
+                col_keys_to_remove.append(col_key)
+
+            message = f"Removed column [$success]{col_name}[/] and all columns before"
 
-        # Get the column name to remove
-        col_to_remove = self.df.columns[col_idx]
+        # 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_names_to_remove.append(col_key.value)
+                col_keys_to_remove.append(col_key)
+
+            message = f"Removed column [$success]{col_name}[/] and all columns after"
+
+        # Remove only the current column
+        else:
+            col_names_to_remove.append(col_name)
+            col_keys_to_remove.append(col_key)
+            message = f"Removed column [$success]{col_name}[/]"
 
         # Add to history
-        self._add_history(f"Removed column [on $primary]{col_to_remove}[/]")
+        self._add_history(message)
 
-        # Remove the column from the table display using the column name as key
-        self.remove_column(col_to_remove)
+        # Remove the columns from the table display using the column names as keys
+        for ck in col_keys_to_remove:
+            self.remove_column(ck)
 
-        # Move cursor left if we deleted the last column
-        if col_idx >= len(self.columns):
-            self.move_cursor(column=len(self.columns) - 1)
+        # Move cursor left if we deleted the last column(s)
+        last_col_idx = len(self.columns) - 1
+        if col_idx > last_col_idx:
+            self.move_cursor(column=last_col_idx)
 
         # Remove from sorted columns if present
-        if col_to_remove in self.sorted_columns:
-            del self.sorted_columns[col_to_remove]
+        for col_name in col_names_to_remove:
+            if col_name in self.sorted_columns:
+                del self.sorted_columns[col_name]
+
+        # Remove from matches
+        col_indices_to_remove = set(self.df.columns.index(name) for name in col_names_to_remove)
+        for row_idx in list(self.matches.keys()):
+            self.matches[row_idx].difference_update(col_indices_to_remove)
+            # Remove empty entries
+            if not self.matches[row_idx]:
+                del self.matches[row_idx]
 
         # Remove from dataframe
-        self.df = self.df.drop(col_to_remove)
+        self.df = self.df.drop(col_names_to_remove)
+
+        self.notify(message, title="Delete")
+
+    def _duplicate_column(self) -> None:
+        """Duplicate the currently selected column, inserting it right after the current column."""
+        cidx = self.cursor_col_idx
+        col_name = self.cursor_col_name
+
+        col_idx = self.cursor_column
+        new_col_name = f"{col_name}_copy"
+
+        # Add to history
+        self._add_history(f"Duplicated column [$success]{col_name}[/]")
+
+        # Create new column and reorder columns to insert after current column
+        cols_before = self.df.columns[: cidx + 1]
+        cols_after = self.df.columns[cidx + 1 :]
 
-        self.app.notify(
-            f"Removed column [on $primary]{col_to_remove}[/] from display",
-            title="Column",
+        # Add the new column and reorder columns for insertion after current column
+        self.df = self.df.with_columns(pl.col(col_name).alias(new_col_name)).select(
+            list(cols_before) + [new_col_name] + list(cols_after)
         )
 
-    def _delete_row(self) -> None:
+        # Update matches to account for new column
+        new_matches = defaultdict(set)
+        for row_idx, cols in self.matches.items():
+            new_cols = set()
+            for col_idx_in_set in cols:
+                if col_idx_in_set <= cidx:
+                    new_cols.add(col_idx_in_set)
+                else:
+                    new_cols.add(col_idx_in_set + 1)
+            new_matches[row_idx] = new_cols
+        self.matches = new_matches
+
+        # Recreate table for display
+        self._setup_table()
+
+        # Move cursor to the new duplicated column
+        self.move_cursor(column=col_idx + 1)
+
+        # self.notify(f"Duplicated column [$accent]{col_name}[/] as [$success]{new_col_name}[/]", title="Duplicate")
+
+    def _delete_row(self, more: str = None) -> None:
         """Delete rows from the table and dataframe.
 
         Supports deleting multiple selected rows. If no rows are selected, deletes the row at the cursor.
         """
         old_count = len(self.df)
-        filter_expr = [True] * len(self.df)
+        predicates = [True] * len(self.df)
 
         # Delete all selected rows
         if selected_count := self.selected_rows.count(True):
             history_desc = f"Deleted {selected_count} selected row(s)"
 
-            for i, is_selected in enumerate(self.selected_rows):
-                if is_selected:
-                    filter_expr[i] = False
+            for ridx, selected in enumerate(self.selected_rows):
+                if selected:
+                    predicates[ridx] = False
+
+        # Delete current row and those above
+        elif more == "above":
+            ridx = self.cursor_row_idx
+            history_desc = f"Deleted current row [$success]{ridx + 1}[/] and those above"
+            for i in range(ridx + 1):
+                predicates[i] = False
+
+        # Delete current row and those below
+        elif more == "below":
+            ridx = self.cursor_row_idx
+            history_desc = f"Deleted current row [$success]{ridx + 1}[/] and those below"
+            for i in range(ridx, len(self.df)):
+                if self.visible_rows[i]:
+                    predicates[i] = False
+
         # Delete the row at the cursor
         else:
-            row_key = self.cursor_row_key
-            i = int(row_key.value) - 1  # Convert to 0-based index
-
-            filter_expr[i] = False
-            history_desc = f"Deleted row [on $primary]{row_key.value}[/]"
+            ridx = self.cursor_row_idx
+            history_desc = f"Deleted row [$success]{ridx + 1}[/]"
+            if self.visible_rows[ridx]:
+                predicates[ridx] = False
 
         # Add to history
         self._add_history(history_desc)
 
         # Apply the filter to remove rows
-        df = self.df.with_row_index("__rid__").filter(filter_expr)
-        self.df = df.drop("__rid__")
+        try:
+            df = self.df.with_row_index(RIDX).filter(predicates)
+        except Exception as e:
+            self.notify(f"Error deleting row(s): {e}", title="Delete", severity="error")
+            self.histories.pop()  # Remove last history entry
+            return
+
+        self.df = df.drop(RIDX)
 
         # Update selected and visible rows tracking
-        old_row_indices = set(df["__rid__"].to_list())
-        self.selected_rows = [
-            selected
-            for i, selected in enumerate(self.selected_rows)
-            if i in old_row_indices
-        ]
-        self.visible_rows = [
-            visible
-            for i, visible in enumerate(self.visible_rows)
-            if i in old_row_indices
-        ]
+        old_row_indices = set(df[RIDX].to_list())
+        self.selected_rows = [selected for i, selected in enumerate(self.selected_rows) if i in old_row_indices]
+        self.visible_rows = [visible for i, visible in enumerate(self.visible_rows) if i in old_row_indices]
 
-        # Recreate the table display
+        # Clear all matches since row indices have changed
+        self.matches = defaultdict(set)
+
+        # Recreate table for display
         self._setup_table()
 
         deleted_count = old_count - len(self.df)
-        self.app.notify(f"Deleted {deleted_count} row(s)", title="Delete")
+        if deleted_count > 0:
+            self.notify(f"Deleted [$accent]{deleted_count}[/] row(s)", title="Delete")
+
+    def _duplicate_row(self) -> None:
+        """Duplicate the currently selected row, inserting it right after the current row."""
+        ridx = self.cursor_row_idx
+
+        # Get the row to duplicate
+        row_to_duplicate = self.df.slice(ridx, 1)
+
+        # Add to history
+        self._add_history(f"Duplicated row [$success]{ridx + 1}[/]")
+
+        # Concatenate: rows before + duplicated row + rows after
+        df_before = self.df.slice(0, ridx + 1)
+        df_after = self.df.slice(ridx + 1)
+
+        # Combine the parts
+        self.df = pl.concat([df_before, row_to_duplicate, df_after])
+
+        # Update selected and visible rows tracking to account for new row
+        new_selected_rows = self.selected_rows[: ridx + 1] + [self.selected_rows[ridx]] + self.selected_rows[ridx + 1 :]
+        new_visible_rows = self.visible_rows[: ridx + 1] + [self.visible_rows[ridx]] + self.visible_rows[ridx + 1 :]
+        self.selected_rows = new_selected_rows
+        self.visible_rows = new_visible_rows
+
+        # Update matches to account for new row
+        new_matches = defaultdict(set)
+        for row_idx, cols in self.matches.items():
+            if row_idx <= ridx:
+                new_matches[row_idx] = cols
+            else:
+                new_matches[row_idx + 1] = cols
+        self.matches = new_matches
+
+        # Recreate table for display
+        self._setup_table()
+
+        # Move cursor to the new duplicated row
+        self.move_cursor(row=ridx + 1)
+
+        # self.notify(f"Duplicated row [$success]{ridx + 1}[/]", title="Row")
 
     def _move_column(self, direction: str) -> None:
         """Move the current column left or right.
@@ -679,36 +1669,32 @@ class DataFrameTable(DataTable):
             direction: "left" to move left, "right" to move right.
         """
         row_idx, col_idx = self.cursor_coordinate
-        col_key = self.cursor_column_key
+        col_key = self.cursor_col_key
+        col_name = col_key.value
+        cidx = self.cursor_col_idx
 
         # Validate move is possible
         if direction == "left":
             if col_idx <= 0:
-                self.app.notify(
-                    "Cannot move column left", title="Move", severity="warning"
-                )
+                self.notify("Cannot move column left", title="Move", severity="warning")
                 return
             swap_idx = col_idx - 1
         elif direction == "right":
             if col_idx >= len(self.columns) - 1:
-                self.app.notify(
-                    "Cannot move column right", title="Move", severity="warning"
-                )
+                self.notify("Cannot move column right", title="Move", severity="warning")
                 return
             swap_idx = col_idx + 1
 
-        # Get column names to swap
-        col_name = self.df.columns[col_idx]
-        swap_name = self.df.columns[swap_idx]
+        # Get column to swap
+        _, swap_key = self.coordinate_to_cell_key(Coordinate(row_idx, swap_idx))
+        swap_name = swap_key.value
+        swap_cidx = self.df.columns.index(swap_name)
 
         # Add to history
-        self._add_history(
-            f"Moved column [on $primary]{col_name}[/] {direction} (swapped with [on $primary]{swap_name}[/])"
-        )
+        self._add_history(f"Moved column [$success]{col_name}[/] {direction} (swapped with [$success]{swap_name}[/])")
 
         # Swap columns in the table's internal column locations
         self.check_idle()
-        swap_key = self.df.columns[swap_idx]  # str as column key
 
         (
             self._column_locations[col_key],
@@ -726,13 +1712,10 @@ class DataFrameTable(DataTable):
 
         # Update the dataframe column order
         cols = list(self.df.columns)
-        cols[col_idx], cols[swap_idx] = cols[swap_idx], cols[col_idx]
+        cols[cidx], cols[swap_cidx] = cols[swap_cidx], cols[cidx]
         self.df = self.df.select(cols)
 
-        self.app.notify(
-            f"Moved column [on $primary]{col_name}[/] {direction}",
-            title="Move",
-        )
+        # self.notify(f"Moved column [$success]{col_name}[/] {direction}", title="Move")
 
     def _move_row(self, direction: str) -> None:
         """Move the current row up or down.
@@ -745,20 +1728,16 @@ class DataFrameTable(DataTable):
         # Validate move is possible
         if direction == "up":
             if row_idx <= 0:
-                self.app.notify("Cannot move row up", title="Move", severity="warning")
+                self.notify("Cannot move row up", title="Move", severity="warning")
                 return
             swap_idx = row_idx - 1
         elif direction == "down":
             if row_idx >= len(self.rows) - 1:
-                self.app.notify(
-                    "Cannot move row down", title="Move", severity="warning"
-                )
+                self.notify("Cannot move row down", title="Move", severity="warning")
                 return
             swap_idx = row_idx + 1
         else:
-            self.app.notify(
-                f"Invalid direction: {direction}", title="Move", severity="error"
-            )
+            # Invalid direction
             return
 
         row_key = self.coordinate_to_cell_key((row_idx, 0)).row_key
@@ -766,7 +1745,7 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self._add_history(
-            f"Moved row [on $primary]{row_key.value}[/] {direction} (swapped with row [on $primary]{swap_key.value}[/])"
+            f"Moved row [$success]{row_key.value}[/] {direction} (swapped with row [$success]{swap_key.value}[/])"
         )
 
         # Swap rows in the table's internal row locations
@@ -787,9 +1766,9 @@ class DataFrameTable(DataTable):
         self.move_cursor(row=swap_idx, column=col_idx)
 
         # Swap rows in the dataframe
-        rid = int(row_key.value) - 1  # 0-based
-        swap_rid = int(swap_key.value) - 1  # 0-based
-        first, second = sorted([rid, swap_rid])
+        ridx = int(row_key.value)  # 0-based
+        swap_ridx = int(swap_key.value)  # 0-based
+        first, second = sorted([ridx, swap_ridx])
 
         self.df = pl.concat(
             [
@@ -801,9 +1780,7 @@ class DataFrameTable(DataTable):
             ]
         )
 
-        self.app.notify(
-            f"Moved row [on $primary]{row_key.value}[/] {direction}", title="Move"
-        )
+        # self.notify(f"Moved row [$success]{row_key.value}[/] {direction}", title="Move")
 
     # Sort
     def _sort_by_column(self, descending: bool = False) -> None:
@@ -816,71 +1793,60 @@ class DataFrameTable(DataTable):
         Args:
             descending: If True, sort in descending order. If False, ascending order.
         """
+        col_name = self.cursor_col_name
         col_idx = self.cursor_column
-        if col_idx >= len(self.df.columns):
-            return
-
-        col_to_sort = self.df.columns[col_idx]
 
         # Check if this column is already in the sort keys
-        old_desc = self.sorted_columns.get(col_to_sort)
-        if old_desc == descending:
-            # Same direction - remove this column from sort
-            self.app.notify(
-                f"Already sorted by [on $primary]{col_to_sort}[/] ({'desc' if descending else 'asc'})",
-                title="Sort",
-                severity="warning",
-            )
-            return
+        old_desc = self.sorted_columns.get(col_name)
 
         # Add to history
-        self._add_history(f"Sorted on column [on $primary]{col_to_sort}[/]")
+        self._add_history(f"Sorted on column [$success]{col_name}[/]")
         if old_desc is None:
             # Add new column to sort
-            self.sorted_columns[col_to_sort] = descending
+            self.sorted_columns[col_name] = descending
+        elif old_desc == descending:
+            # Same direction - remove from sort
+            del self.sorted_columns[col_name]
         else:
-            # Toggle direction and move to end of sort order
-            del self.sorted_columns[col_to_sort]
-            self.sorted_columns[col_to_sort] = descending
+            # Move to end of sort order
+            del self.sorted_columns[col_name]
+            self.sorted_columns[col_name] = descending
 
         # Apply multi-column sort
-        sort_cols = list(self.sorted_columns.keys())
-        descending_flags = list(self.sorted_columns.values())
-        df_sorted = self.df.with_row_index("__rid__").sort(
-            sort_cols, descending=descending_flags, nulls_last=True
-        )
+        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)
 
         # Updated selected_rows and visible_rows to match new order
-        old_row_indices = df_sorted["__rid__"].to_list()
+        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]
 
         # Update the dataframe
-        self.df = df_sorted.drop("__rid__")
+        self.df = df_sorted.drop(RIDX)
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
         # Restore cursor position on the sorted column
         self.move_cursor(column=col_idx, row=0)
 
     # Edit
-    def _edit_cell(self) -> None:
+    def _edit_cell(self, ridx: int = None, cidx: int = None) -> None:
         """Open modal to edit the selected cell."""
-        row_key = self.cursor_row_key
-        row_idx = int(row_key.value) - 1  # Convert to 0-based
-        col_idx = self.cursor_column
-
-        if row_idx >= len(self.df) or col_idx >= len(self.df.columns):
-            return
-        col_name = self.df.columns[col_idx]
+        ridx = self.cursor_row_idx if ridx is None else ridx
+        cidx = self.cursor_col_idx if cidx is None else cidx
+        col_name = self.df.columns[cidx]
 
-        # Save current state to history
-        self._add_history(f"Edited cell [on $primary]({row_idx + 1}, {col_name})[/]")
+        # Add to history
+        self._add_history(f"Edited cell [$success]({ridx + 1}, {col_name})[/]")
 
         # Push the edit modal screen
         self.app.push_screen(
-            EditCellScreen(row_key, col_idx, self.df),
+            EditCellScreen(ridx, cidx, self.df),
             callback=self._do_edit_cell,
         )
 
@@ -889,424 +1855,1271 @@ class DataFrameTable(DataTable):
         if result is None:
             return
 
-        row_key, col_idx, new_value = result
-        row_idx = int(row_key.value) - 1  # Convert to 0-based
-        col_name = self.df.columns[col_idx]
+        ridx, cidx, new_value = result
+        if new_value is None:
+            self.app.push_screen(
+                EditCellScreen(ridx, cidx, self.df),
+                callback=self._do_edit_cell,
+            )
+            return
+
+        col_name = self.df.columns[cidx]
 
         # Update the cell in the dataframe
         try:
             self.df = self.df.with_columns(
-                pl.when(pl.arange(0, len(self.df)) == row_idx)
+                pl.when(pl.arange(0, len(self.df)) == ridx)
                 .then(pl.lit(new_value))
                 .otherwise(pl.col(col_name))
                 .alias(col_name)
             )
 
             # Update the display
-            cell_value = self.df.item(row_idx, col_idx)
+            cell_value = self.df.item(ridx, cidx)
             if cell_value is None:
-                cell_value = "-"
-            dtype = self.df.dtypes[col_idx]
+                cell_value = NULL_DISPLAY
+            dtype = self.df.dtypes[cidx]
             dc = DtypeConfig(dtype)
             formatted_value = Text(str(cell_value), style=dc.style, justify=dc.justify)
 
-            row_key = str(row_idx + 1)
-            col_key = str(col_name)
-            self.update_cell(row_key, col_key, formatted_value)
+            # string as keys
+            row_key = str(ridx)
+            col_key = col_name
+            self.update_cell(row_key, col_key, formatted_value, update_width=True)
 
-            self.app.notify(
-                f"Cell updated to [on $primary]{cell_value}[/]", title="Edit"
-            )
+            # self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit")
         except Exception as e:
-            self.app.notify(
-                f"Failed to update cell: {str(e)}", title="Edit", severity="error"
-            )
-            raise e
-
-    def _copy_cell(self) -> None:
-        """Copy the current cell to clipboard."""
-        import subprocess
-
-        row_idx = self.cursor_row
-        col_idx = self.cursor_column
-
-        try:
-            cell_str = str(self.df.item(row_idx, col_idx))
-            subprocess.run(
-                [
-                    "pbcopy" if sys.platform == "darwin" else "xclip",
-                    "-selection",
-                    "clipboard",
-                ],
-                input=cell_str,
-                text=True,
-            )
-            self.app.notify(f"Copied: {cell_str[:50]}", title="Clipboard")
-        except (FileNotFoundError, IndexError):
-            self.app.notify("Error copying cell", title="Clipboard", severity="error")
-
-    def _search_column(self, all_columns: bool = False) -> None:
-        """Open modal to search in the selected column."""
-        row_idx, col_idx = self.cursor_coordinate
-        if col_idx >= len(self.df.columns):
-            self.app.notify("Invalid column selected", title="Search", severity="error")
-            return
+            self.notify("Error updating cell", title="Edit", severity="error")
+            self.log(f"Error updating cell: {str(e)}")
 
-        col_name = None if all_columns else self.df.columns[col_idx]
-        col_dtype = self.df.dtypes[col_idx]
+    def _edit_column(self) -> None:
+        """Open modal to edit the entire column with an expression."""
+        cidx = self.cursor_col_idx
 
-        # Get current cell value as default search term
-        term = self.df.item(row_idx, col_idx)
-        term = "NULL" if term is None else str(term)
-
-        # Push the search modal screen
+        # Push the edit column modal screen
         self.app.push_screen(
-            SearchScreen(term, col_dtype, col_name),
-            callback=self._do_search_column,
+            EditColumnScreen(cidx, self.df),
+            callback=self._do_edit_column,
         )
 
-    def _do_search_column(self, result) -> None:
-        """Handle result from SearchScreen."""
+    def _do_edit_column(self, result) -> None:
+        """Edit a column."""
         if result is None:
             return
+        term, cidx = result
 
-        term, col_dtype, col_name = result
-        if col_name:
-            # Perform search in the specified column
-            self._search_single_column(term, col_dtype, col_name)
-        else:
-            # Perform search in all columns
-            self._search_all_columns(term)
+        col_name = self.df.columns[cidx]
 
-    def _search_single_column(
-        self, term: str, col_dtype: pl.DataType, col_name: str
-    ) -> None:
-        """Search for a term in a single column and update selected rows.
+        # Null case
+        if term is None or term == NULL:
+            expr = pl.lit(None)
 
-        Args:
-            term: The search term to find
-            col_dtype: The data type of the column
-            col_name: The name of the column to search in
-        """
-        df_rid = self.df.with_row_index("__rid__")
-        if False in self.visible_rows:
-            df_rid = df_rid.filter(self.visible_rows)
+        # Check if term is a valid expression
+        elif tentative_expr(term):
+            try:
+                expr = validate_expr(term, self.df.columns, cidx)
+            except Exception as e:
+                self.notify(f"Error validating expression [$error]{term}[/]", title="Edit", severity="error")
+                self.log(f"Error validating expression `{term}`: {str(e)}")
+                return
 
-        # Perform type-aware search based on column dtype
-        if term.lower() == "null":
-            masks = df_rid[col_name].is_null()
-        elif col_dtype == pl.String:
-            masks = df_rid[col_name].str.contains(term)
-        elif col_dtype == pl.Boolean:
-            masks = df_rid[col_name] == BOOLS[term.lower()]
-        elif col_dtype in (pl.Int32, pl.Int64):
-            masks = df_rid[col_name] == int(term)
-        elif col_dtype in (pl.Float32, pl.Float64):
-            masks = df_rid[col_name] == float(term)
+        # Otherwise, treat term as a literal value
         else:
-            self.app.notify(
-                f"Search not yet supported for column type: [on $primary]{col_dtype}[/]",
-                title="Search",
-                severity="warning",
-            )
-            return
+            dtype = self.df.dtypes[cidx]
+            try:
+                value = DtypeConfig(dtype).convert(term)
+                expr = pl.lit(value)
+            except Exception:
+                self.notify(
+                    f"Error converting [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
+                    title="Edit",
+                    severity="error",
+                )
+                expr = pl.lit(str(term))
 
-        # Apply filter to get matched row indices
-        matches = set(df_rid.filter(masks)["__rid__"].to_list())
+        # Add to history
+        self._add_history(f"Edited column [$accent]{col_name}[/] with expression")
 
-        match_count = len(matches)
-        if match_count == 0:
-            self.app.notify(
-                f"No matches found for: [on $primary]{term}[/]",
-                title="Search",
-                severity="warning",
+        try:
+            # Apply the expression to the column
+            self.df = self.df.with_columns(expr.alias(col_name))
+        except Exception as e:
+            self.notify(
+                f"Error applying expression: [$error]{term}[/] to column [$accent]{col_name}[/]",
+                title="Edit",
+                severity="error",
             )
+            self.log(f"Error applying expression `{term}` to column `{col_name}`: {str(e)}")
             return
 
-        # Add to history
-        self._add_history(
-            f"Searched and highlighted [on $primary]{term}[/] in column [on $primary]{col_name}[/]"
-        )
+        # Recreate table for display
+        self._setup_table()
 
-        # Update selected rows to include new matches
-        for m in matches:
-            self.selected_rows[m] = True
+        # self.notify(f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]", title="Edit")
 
-        # Highlight selected rows
-        self._highlight_rows()
+    def _rename_column(self) -> None:
+        """Open modal to rename the selected column."""
+        col_name = self.cursor_col_name
+        col_idx = self.cursor_column
 
-        self.app.notify(
-            f"Found [on $primary]{match_count}[/] matches for [on $primary]{term}[/]",
-            title="Search",
+        # Push the rename column modal screen
+        self.app.push_screen(
+            RenameColumnScreen(col_idx, col_name, self.df.columns),
+            callback=self._do_rename_column,
         )
 
-    def _search_all_columns(self, term: str) -> None:
-        """Search for a term across all columns and highlight matching cells.
-
-        Args:
-            term: The search term to find
-        """
-        df_rid = self.df.with_row_index("__rid__")
-        if False in self.visible_rows:
-            df_rid = df_rid.filter(self.visible_rows)
-
-        matches: dict[int, set[int]] = {}
-        match_count = 0
-        if term.lower() == "null":
-            # Search for NULL values across all columns
-            for col_idx, col in enumerate(df_rid.columns[1:]):
-                masks = df_rid[col].is_null()
-                matched_rids = set(df_rid.filter(masks)["__rid__"].to_list())
-                for rid in matched_rids:
-                    if rid not in matches:
-                        matches[rid] = set()
-                    matches[rid].add(col_idx)
-                    match_count += 1
-        else:
-            # Search for the term in all columns
-            for col_idx, col in enumerate(df_rid.columns[1:]):
-                col_series = df_rid[col].cast(pl.String)
-                masks = col_series.str.contains(term)
-                matched_rids = set(df_rid.filter(masks)["__rid__"].to_list())
-                for rid in matched_rids:
-                    if rid not in matches:
-                        matches[rid] = set()
-                    matches[rid].add(col_idx)
-                    match_count += 1
+    def _do_rename_column(self, result) -> None:
+        """Handle result from RenameColumnScreen."""
+        if result is None:
+            return
 
-        if match_count == 0:
-            self.app.notify(
-                f"No matches found for: [on $primary]{term}[/] in any column",
-                title="Global Search",
-                severity="warning",
+        col_idx, col_name, new_name = result
+        if new_name is None:
+            self.app.push_screen(
+                RenameColumnScreen(col_idx, col_name, self.df.columns),
+                callback=self._do_rename_column,
             )
             return
 
-        # Ensure all matching rows are loaded
-        self._load_rows(max(matches.keys()) + 1)
-
         # Add to history
-        self._add_history(
-            f"Searched and highlighted [on $primary]{term}[/] across all columns"
-        )
+        self._add_history(f"Renamed column [$accent]{col_name}[/] to [$success]{new_name}[/]")
 
-        # Highlight matching cells directly
-        for row in self.ordered_rows:
-            row_idx = int(row.key.value) - 1  # Convert to 0-based index
-            if row_idx not in matches:
-                continue
+        # Rename the column in the dataframe
+        self.df = self.df.rename({col_name: new_name})
 
-            for col_idx in matches[row_idx]:
-                row_key = row.key
-                col_key = self.df.columns[col_idx]
+        # Update sorted_columns if this column was sorted
+        if col_name in self.sorted_columns:
+            self.sorted_columns[new_name] = self.sorted_columns.pop(col_name)
 
-                cell_text: Text = self.get_cell(row_key, col_key)
-                cell_text.style = "red"
+        # Update hidden_columns if this column was hidden
+        if col_name in self.hidden_columns:
+            self.hidden_columns.remove(col_name)
+            self.hidden_columns.add(new_name)
 
-                # Update the cell in the table
-                self.update_cell(row_key, col_key, cell_text)
+        # Recreate table for display
+        self._setup_table()
 
-        self.app.notify(
-            f"Found [$accent]{match_count}[/] matches for [on $primary]{term}[/] across all columns",
-            title="Global Search",
-        )
+        # Move cursor to the renamed column
+        self.move_cursor(column=col_idx)
 
-    def _search_with_cell_value(self) -> None:
-        """Search in the current column using the value of the currently selected cell."""
-        row_key = self.cursor_row_key
-        row_idx = int(row_key.value) - 1  # Convert to 0-based index
-        col_idx = self.cursor_column
+        # self.notify(f"Renamed column [$success]{col_name}[/] to [$success]{new_name}[/]", title="Column")
 
-        # Get the value of the currently selected cell
-        term = self.df.item(row_idx, col_idx)
-        term = "NULL" if term is None else str(term)
+    def _clear_cell(self) -> None:
+        """Clear the current cell by setting its value to None."""
+        row_key, col_key = self.cursor_key
+        ridx = self.cursor_row_idx
+        cidx = self.cursor_col_idx
+        col_name = self.cursor_col_name
 
-        col_dtype = self.df.dtypes[col_idx]
-        col_name = self.df.columns[col_idx]
-        self._do_search_column((term, col_dtype, col_name))
+        # Add to history
+        self._add_history(f"Cleared cell [$success]({ridx + 1}, {col_name})[/]")
 
-    def _toggle_selected_rows(self, current_row=False) -> None:
-        """Toggle selected rows highlighting on/off."""
-        # Save current state to history
-        self._add_history("Toggled row selection")
+        # Update the cell to None in the dataframe
+        try:
+            self.df = self.df.with_columns(
+                pl.when(pl.arange(0, len(self.df)) == ridx)
+                .then(pl.lit(None))
+                .otherwise(pl.col(col_name))
+                .alias(col_name)
+            )
+
+            # Update the display
+            dtype = self.df.dtypes[cidx]
+            dc = DtypeConfig(dtype)
+            formatted_value = Text(NULL_DISPLAY, style=dc.style, justify=dc.justify)
+
+            self.update_cell(row_key, col_key, formatted_value)
+
+            # self.notify(f"Cell cleared to [$success]{NULL_DISPLAY}[/]", title="Clear")
+        except Exception as e:
+            self.notify("Error clearing cell", title="Clear", severity="error")
+            self.log(f"Error clearing cell: {str(e)}")
+            raise e
 
-        # Select current row if no rows are currently selected
-        if current_row:
-            cursor_row_idx = int(self.cursor_row_key.value) - 1
-            self.selected_rows[cursor_row_idx] = not self.selected_rows[cursor_row_idx]
+    def _add_column(self, col_name: str = None, col_value: pl.Expr = None) -> None:
+        """Add acolumn after the current column."""
+        cidx = self.cursor_col_idx
+
+        if not col_name:
+            # Generate a unique column name
+            base_name = "new_col"
+            new_name = base_name
+            counter = 1
+            while new_name in self.df.columns:
+                new_name = f"{base_name}_{counter}"
+                counter += 1
         else:
-            # Invert all selected rows
-            self.selected_rows = [not match for match in self.selected_rows]
+            new_name = col_name
 
-        # Check if we're highlighting or un-highlighting
-        if new_selected_count := self.selected_rows.count(True):
-            self.app.notify(
-                f"Toggled selection - now showing [$accent]{new_selected_count}[/] rows",
-                title="Toggle",
+        # Add to history
+        self._add_history(f"Added column [$success]{new_name}[/] after column {cidx + 1}")
+
+        try:
+            # Create an empty column (all None values)
+            if isinstance(col_value, pl.Expr):
+                new_col = col_value.alias(new_name)
+            else:
+                new_col = pl.lit(col_value).alias(new_name)
+
+            # Get columns up to current, the new column, then remaining columns
+            cols = self.df.columns
+            cols_before = cols[: cidx + 1]
+            cols_after = cols[cidx + 1 :]
+
+            # Build the new dataframe with columns reordered
+            select_cols = cols_before + [new_name] + cols_after
+            self.df = self.df.with_columns(new_col).select(select_cols)
+
+            # Recreate table for display
+            self._setup_table()
+
+            # Move cursor to the new column
+            self.move_cursor(column=cidx + 1)
+
+            # self.notify(f"Added column [$success]{new_name}[/]", title="Add Column")
+        except Exception as e:
+            self.notify("Error adding column", title="Add Column", severity="error")
+            self.log(f"Error adding column: {str(e)}")
+            raise e
+
+    def _add_column_expr(self) -> None:
+        """Open screen to add a new column with optional expression."""
+        cidx = self.cursor_col_idx
+        self.app.push_screen(
+            AddColumnScreen(cidx, self.df),
+            self._do_add_column_expr,
+        )
+
+    def _do_add_column_expr(self, result: tuple[int, str, str, pl.Expr] | None) -> None:
+        """Add a new column with an expression."""
+        if result is None:
+            return
+
+        cidx, new_col_name, expr = result
+
+        # Add to history
+        self._add_history(f"Added column [$success]{new_col_name}[/] with expression {expr}.")
+
+        try:
+            # Create the column
+            new_col = expr.alias(new_col_name)
+
+            # Get columns up to current, the new column, then remaining columns
+            cols = self.df.columns
+            cols_before = cols[: cidx + 1]
+            cols_after = cols[cidx + 1 :]
+
+            # Build the new dataframe with columns reordered
+            select_cols = cols_before + [new_col_name] + cols_after
+            self.df = self.df.with_row_index(RIDX).with_columns(new_col).select(select_cols)
+
+            # Recreate table for display
+            self._setup_table()
+
+            # Move cursor to the new column
+            self.move_cursor(column=cidx + 1)
+
+            # self.notify(f"Added column [$success]{col_name}[/]", title="Add Column")
+        except Exception as e:
+            self.notify("Error adding column", title="Add Column", severity="error")
+            self.log(f"Error adding column `{new_col_name}`: {str(e)}")
+
+    def _add_link_column(self) -> None:
+        self.app.push_screen(
+            AddLinkScreen(self.cursor_col_idx, self.df),
+            callback=self._do_add_link_column,
+        )
+
+    def _do_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:
+        - `$_` - Current column (based on cursor position)
+        - `$1`, `$2`, etc. - Column by 1-based position index
+        - `$name` - Column by name (e.g., `$id`, `$product_name`)
+
+        The template is evaluated for each row using Polars expressions with vectorized
+        string concatenation. The new column is inserted after the current column.
+
+        Args:
+            result: Tuple of (cidx, new_col_name, link_template) or None if cancelled.
+
+        Returns:
+            None
+        """
+        if result is None:
+            return
+        cidx, new_col_name, link_template = result
+
+        self._add_history(f"Added link column [$success]{new_col_name}[/] with template {link_template}.")
+
+        try:
+            # Hack to support PubChem link
+            link_template = link_template.replace("PC", "https://pubchem.ncbi.nlm.nih.gov")
+
+            # Ensure link starts with http:// or https://
+            if not link_template.startswith(("https://", "http://")):
+                link_template = "https://" + link_template
+
+            # Parse template placeholders into Polars expressions
+            parts = parse_placeholders(link_template, self.df.columns, cidx)
+
+            # Build the concatenation expression
+            exprs = [part if isinstance(part, pl.Expr) else pl.lit(part) for part in parts]
+            new_col = pl.concat_str(exprs).alias(new_col_name)
+
+            # Get columns up to current, the new column, then remaining columns
+            cols = self.df.columns
+            cols_before = cols[: cidx + 1]
+            cols_after = cols[cidx + 1 :]
+
+            # Build the new dataframe with columns reordered
+            select_cols = cols_before + [new_col_name] + cols_after
+            self.df = self.df.with_columns(new_col).select(select_cols)
+
+            # Recreate table for display
+            self._setup_table()
+
+            # Move cursor to the new column
+            self.move_cursor(column=cidx + 1)
+
+            self.notify(f"Added link column [$success]{new_col_name}[/]. Use Ctrl/Cmd click to open.", title="Add Link")
+
+        except Exception as e:
+            self.notify(f"Error adding link column: {str(e)}", title="Add Link", severity="error")
+            self.log(f"Error adding link column: {str(e)}")  # Type Casting
+
+    def _cast_column_dtype(self, dtype: str) -> None:
+        """Cast the current column to a different data type.
+
+        Args:
+            dtype: Target data type (string representation, e.g., "pl.String", "pl.Int64")
+        """
+        cidx = self.cursor_col_idx
+        col_name = self.cursor_col_name
+        current_dtype = self.df.dtypes[cidx]
+
+        try:
+            target_dtype = eval(dtype)
+        except Exception:
+            self.notify(f"Invalid target data type: [$error]{dtype}[/]", title="Cast", severity="error")
+            return
+
+        if current_dtype == target_dtype:
+            self.notify(
+                f"Column [$accent]{col_name}[/] is already of type [$success]{target_dtype}[/]",
+                title="Cast",
+                severity="warning",
             )
+            return  # No change needed
 
-        # Refresh the highlighting (also restores default styles for unselected rows)
-        self._highlight_rows()
+        # Add to history
+        self._add_history(
+            f"Cast column [$accent]{col_name}[/] from [$success]{current_dtype}[/] to [$success]{target_dtype}[/]"
+        )
+
+        try:
+            # Cast the column using Polars
+            self.df = self.df.with_columns(pl.col(col_name).cast(target_dtype))
 
-    def _clear_selected_rows(self) -> None:
-        """Clear all selected rows without removing them from the dataframe."""
-        # Check if any rows are currently selected
-        selected_count = self.selected_rows.count(True)
-        if selected_count == 0:
-            self.app.notify(
-                "No rows selected to clear", title="Clear", severity="warning"
+            # Recreate table for display
+            self._setup_table()
+
+            self.notify(f"Cast column [$accent]{col_name}[/] to [$success]{target_dtype}[/]", title="Cast")
+        except Exception as e:
+            self.notify(
+                f"Error casting column [$accent]{col_name}[/] to [$error]{target_dtype}[/]",
+                title="Cast",
+                severity="error",
             )
+            self.log(f"Error casting column `{col_name}`: {str(e)}")
+
+    # Search
+    def _search_cursor_value(self) -> None:
+        """Search with cursor value in current column."""
+        cidx = self.cursor_col_idx
+
+        # Get the value of the currently selected cell
+        term = NULL if self.cursor_value is None else str(self.cursor_value)
+
+        self._do_search((term, cidx, False, True))
+
+    def _search_expr(self) -> None:
+        """Search by expression."""
+        cidx = self.cursor_col_idx
+
+        # Use current cell value as default search term
+        term = NULL if self.cursor_value is None else str(self.cursor_value)
+
+        # Push the search modal screen
+        self.app.push_screen(
+            SearchScreen("Search", term, self.df, cidx),
+            callback=self._do_search,
+        )
+
+    def _do_search(self, result) -> None:
+        """Search for a term."""
+        if result is None:
             return
 
-        # Save current state to history
-        self._add_history("Cleared all selected rows")
+        term, cidx, match_nocase, match_whole = result
+        col_name = self.df.columns[cidx]
+
+        if term == NULL:
+            expr = pl.col(col_name).is_null()
+
+        # Support for polars expressions
+        elif tentative_expr(term):
+            try:
+                expr = validate_expr(term, self.df.columns, cidx)
+            except Exception as e:
+                self.notify(f"Error validating expression [$error]{term}[/]", title="Search", severity="error")
+                self.log(f"Error validating expression `{term}`: {str(e)}")
+                return
+
+        # Perform type-aware search based on column dtype
+        else:
+            dtype = self.df.dtypes[cidx]
+            if dtype == pl.String:
+                if match_whole:
+                    term = f"^{term}$"
+                if match_nocase:
+                    term = f"(?i){term}"
+                expr = pl.col(col_name).str.contains(term)
+            else:
+                try:
+                    value = DtypeConfig(dtype).convert(term)
+                    expr = pl.col(col_name) == value
+                except Exception:
+                    if match_whole:
+                        term = f"^{term}$"
+                    if match_nocase:
+                        term = f"(?i){term}"
+                    expr = pl.col(col_name).cast(pl.String).str.contains(term)
+                    self.notify(
+                        f"Error converting [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
+                        title="Search",
+                        severity="warning",
+                    )
+
+        # Lazyframe for filtering
+        lf = self.df.lazy().with_row_index(RIDX)
+        if False in self.visible_rows:
+            lf = lf.filter(self.visible_rows)
+
+        # Apply filter to get matched row indices
+        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")
+            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 [$accent]{term}[/]. Try [$warning](?i)abc[/] for case-insensitive search.",
+                title="Search",
+                severity="warning",
+            )
+            return
+
+        # Add to history
+        self._add_history(f"Searched [$accent]{term}[/] in column [$success]{col_name}[/]")
+
+        # 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 [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Search")
+
+        # Recreate table for display
+        self._setup_table()
+
+    # Find
+    def _find_matches(
+        self, term: str, cidx: int | None = None, match_nocase: bool = False, match_whole: bool = False
+    ) -> dict[int, set[int]]:
+        """Find matches for a term in the dataframe.
+
+        Args:
+            term: The search term (can be NULL, expression, or plain text)
+            cidx: Column index for column-specific search. If None, searches all columns.
+
+        Returns:
+            Dictionary mapping row indices to sets of column indices containing matches.
+            For column-specific search, each matched row has a set with single cidx.
+            For global search, each matched row has a set of all matching cidxs in that row.
+
+        Raises:
+            Exception: If expression validation or filtering fails.
+        """
+        matches: dict[int, set[int]] = defaultdict(set)
+
+        # Lazyframe for filtering
+        lf = self.df.lazy().with_row_index(RIDX)
+        if False in self.visible_rows:
+            lf = lf.filter(self.visible_rows)
+
+        # Determine which columns to search: single column or all columns
+        if cidx is not None:
+            columns_to_search = [(cidx, self.df.columns[cidx])]
+        else:
+            columns_to_search = list(enumerate(self.df.columns))
+
+        # Search each column consistently
+        for col_idx, col_name in columns_to_search:
+            # Build expression based on term type
+            if term == NULL:
+                expr = pl.col(col_name).is_null()
+            elif tentative_expr(term):
+                try:
+                    expr = validate_expr(term, self.df.columns, col_idx)
+                except Exception as e:
+                    self.notify(f"Error validating expression [$error]{term}[/]", title="Find", severity="error")
+                    self.log(f"Error validating expression `{term}`: {str(e)}")
+                    return matches
+            else:
+                if match_whole:
+                    term = f"^{term}$"
+                if match_nocase:
+                    term = f"(?i){term}"
+                expr = pl.col(col_name).cast(pl.String).str.contains(term)
+
+            # Get matched row indices
+            try:
+                matched_ridxs = lf.filter(expr).select(RIDX).collect().to_series().to_list()
+            except Exception as e:
+                self.notify(f"Error applying filter: {expr}", title="Find", severity="error")
+                self.log(f"Error applying filter: {str(e)}")
+                return matches
+
+            for ridx in matched_ridxs:
+                matches[ridx].add(col_idx)
+
+        return matches
+
+    def _find_cursor_value(self, scope="column") -> None:
+        """Find by cursor value.
+
+        Args:
+            scope: "column" to find in current column, "global" to find across all columns.
+        """
+        # Get the value of the currently selected cell
+        term = NULL if self.cursor_value is None else str(self.cursor_value)
+
+        if scope == "column":
+            cidx = self.cursor_col_idx
+            self._do_find((term, cidx, False, True))
+        else:
+            self._do_find_global((term, None, False, True))
+
+    def _find_expr(self, scope="column") -> None:
+        """Open screen to find by expression.
 
-        # Clear all selections and refresh highlighting
-        self._highlight_rows(clear=True)
+        Args:
+            scope: "column" to find in current column, "global" to find across all columns.
+        """
+        # Use current cell value as default search term
+        term = NULL if self.cursor_value is None else str(self.cursor_value)
+        cidx = self.cursor_col_idx if scope == "column" else None
 
-        self.app.notify(
-            f"Cleared [$accent]{selected_count}[/] selected rows", title="Clear"
+        # Push the search modal screen
+        self.app.push_screen(
+            SearchScreen("Find", term, self.df, cidx),
+            callback=self._do_find if scope == "column" else self._do_find_global,
         )
 
-    def _filter_selected_rows(self) -> None:
-        """Display only the selected rows."""
-        selected_count = self.selected_rows.count(True)
-        if selected_count == 0:
-            self.app.notify(
-                "No rows selected to filter", title="Filter", severity="warning"
+    def _do_find(self, result) -> None:
+        """Find a term in current column."""
+        if result is None:
+            return
+        term, cidx, match_nocase, match_whole = result
+
+        col_name = self.df.columns[cidx]
+
+        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")
+            self.log(f"Error finding matches for `{term}`: {str(e)}")
+            return
+
+        if not matches:
+            self.notify(
+                f"No matches found for [$accent]{term}[/] in current column. Try [$warning](?i)abc[/] for case-insensitive search.",
+                title="Find",
+                severity="warning",
             )
             return
 
-        # Save current state to history
-        self._add_history("Filtered to selected rows")
+        # Add to history
+        self._add_history(f"Found [$accent]{term}[/] in column [$success]{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)
 
-        # Update dataframe to only include selected rows
-        self.df = self.df.filter(self.selected_rows)
-        self.selected_rows = [True] * len(self.df)
+        self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Find")
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
-        self.app.notify(
-            f"Removed unselected rows. Now showing [$accent]{selected_count}[/] rows",
-            title="Filter",
+    def _do_find_global(self, result) -> None:
+        """Global find a term across all columns."""
+        if result is None:
+            return
+        term, cidx, match_nocase, match_whole = result
+
+        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")
+            self.log(f"Error finding matches for `{term}`: {str(e)}")
+            return
+
+        if not matches:
+            self.notify(
+                f"No matches found for [$accent]{term}[/] in any column. Try [$warning](?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")
+
+        # 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 [$accent]{match_count}[/] matches for [$success]{term}[/] across all columns", title="Global Find"
         )
 
-    def _open_filter_screen(self) -> None:
-        """Open the filter screen to enter a filter expression."""
-        row_key = self.cursor_row_key
-        row_idx = int(row_key.value) - 1  # Convert to 0-based index
-        col_idx = self.cursor_column
+        # Recreate table for display
+        self._setup_table()
+
+    def _next_match(self) -> None:
+        """Move cursor to the next match."""
+        if not self.matches:
+            self.notify("No matches to navigate", title="Next Match", severity="warning")
+            return
+
+        # Get sorted list of matched coordinates
+        ordered_matches = self.ordered_matches
+
+        # Current cursor position
+        current_pos = (self.cursor_row_idx, self.cursor_col_idx)
+
+        # Find the next match after current position
+        for ridx, cidx in ordered_matches:
+            if (ridx, cidx) > current_pos:
+                self.move_cursor_to(ridx, cidx)
+                return
+
+        # If no next match, wrap around to the first match
+        first_ridx, first_cidx = ordered_matches[0]
+        self.move_cursor_to(first_ridx, first_cidx)
+
+    def _previous_match(self) -> None:
+        """Move cursor to the previous match."""
+        if not self.matches:
+            self.notify("No matches to navigate", title="Previous Match", severity="warning")
+            return
+
+        # Get sorted list of matched coordinates
+        ordered_matches = self.ordered_matches
+
+        # Current cursor position
+        current_pos = (self.cursor_row_idx, self.cursor_col_idx)
+
+        # Find the previous match before current position
+        for ridx, cidx in reversed(ordered_matches):
+            if (ridx, cidx) < current_pos:
+                row_key = str(ridx)
+                col_key = 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)
+                return
+
+        # If no previous match, wrap around to the last match
+        last_ridx, last_cidx = ordered_matches[-1]
+        row_key = str(last_ridx)
+        col_key = self.df.columns[last_cidx]
+        row_idx, col_idx = self.get_cell_coordinate(row_key, col_key)
+        self.move_cursor(row=row_idx, column=col_idx)
+
+    def _next_selected_row(self) -> None:
+        """Move cursor to the next selected row."""
+        if not any(self.selected_rows):
+            self.notify("No selected rows to navigate", title="Next Selected Row", severity="warning")
+            return
+
+        # Get list of selected row indices in order
+        selected_row_indices = self.ordered_selected_rows
+
+        # Current cursor row
+        current_ridx = self.cursor_row_idx
+
+        # Find the next selected row after current position
+        for ridx in selected_row_indices:
+            if ridx > current_ridx:
+                self.move_cursor_to(ridx, self.cursor_col_idx)
+                return
+
+        # If no next selected row, wrap around to the first selected row
+        first_ridx = selected_row_indices[0]
+        self.move_cursor_to(first_ridx, self.cursor_col_idx)
+
+    def _previous_selected_row(self) -> None:
+        """Move cursor to the previous selected row."""
+        if not any(self.selected_rows):
+            self.notify("No selected rows to navigate", title="Previous Selected Row", severity="warning")
+            return
+
+        # Get list of selected row indices in order
+        selected_row_indices = self.ordered_selected_rows
 
-        cell_value = self.df.item(row_idx, col_idx)
-        if self.df.dtypes[col_idx] == pl.String and cell_value is not None:
-            cell_value = repr(cell_value)
+        # Current cursor row
+        current_ridx = self.cursor_row_idx
+
+        # Find the previous selected row before current position
+        for ridx in reversed(selected_row_indices):
+            if ridx < current_ridx:
+                self.move_cursor_to(ridx, self.cursor_col_idx)
+                return
 
+        # If no previous selected row, wrap around to the last selected row
+        last_ridx = selected_row_indices[-1]
+        self.move_cursor_to(last_ridx, self.cursor_col_idx)
+
+    # Replace
+    def _replace(self) -> None:
+        """Open replace screen for current column."""
+        # Push the replace modal screen
         self.app.push_screen(
-            FilterScreen(
-                self.df, current_col_idx=col_idx, current_cell_value=cell_value
-            ),
-            callback=self._do_filter,
+            FindReplaceScreen(self, title="Find and Replace in Current Column"),
+            callback=self._do_replace,
         )
 
-    def _do_filter(self, result) -> None:
-        """Handle result from FilterScreen.
+    def _do_replace(self, result) -> None:
+        """Handle replace in current column."""
+        self._handle_replace(result, self.cursor_col_idx)
+
+    def _replace_global(self) -> None:
+        """Open replace screen for all columns."""
+        # Push the replace modal screen
+        self.app.push_screen(
+            FindReplaceScreen(self, title="Global Find and Replace"),
+            callback=self._do_replace_global,
+        )
+
+    def _do_replace_global(self, result) -> None:
+        """Handle replace across all columns."""
+        self._handle_replace(result, None)
+
+    def _handle_replace(self, result, cidx) -> None:
+        """Handle replace result from ReplaceScreen.
 
         Args:
-            expression: The filter expression or None if cancelled.
+            result: Result tuple from ReplaceScreen
+            cidx: Column index to perform replacement. If None, replace across all columns.
         """
         if result is None:
             return
-        expr, expr_str = result
+        term_find, term_replace, match_nocase, match_whole, replace_all = result
 
-        # Add a row index column to track original row indices
-        df_with_rid = self.df.with_row_index("__rid__")
+        if cidx is None:
+            col_name = "all columns"
+        else:
+            col_name = self.df.columns[cidx]
 
-        # Apply existing visibility filter first
-        if False in self.visible_rows:
-            df_with_rid = df_with_rid.filter(self.visible_rows)
+        # Find all matches
+        matches = self._find_matches(term_find, cidx, match_nocase, match_whole)
 
-        # Apply the filter expression
-        df_filtered = df_with_rid.filter(expr)
+        if not matches:
+            self.notify(f"No matches found for [$warning]{term_find}[/]", title="Replace", severity="warning")
+            return
 
-        matched_count = len(df_filtered)
-        if not matched_count:
-            self.app.notify(
-                f"No rows match the expression: [on $primary]{expr_str}[/]",
-                title="Filter",
-                severity="warning",
+        # Add to history
+        self._add_history(
+            f"Replaced [$accent]{term_find}[/] with [$success]{term_replace}[/] in column [$accent]{col_name}[/]"
+        )
+
+        # Update matches
+        self.matches = {ridx: col_idxs.copy() for ridx, col_idxs in matches.items()}
+
+        # Recreate table for display
+        self._setup_table()
+
+        # Store state for interactive replacement using dataclass
+        sorted_rows = sorted(self.matches.keys())
+        self._replace_state = ReplaceState(
+            term_find=term_find,
+            term_replace=term_replace,
+            match_nocase=match_nocase,
+            match_whole=match_whole,
+            cidx=cidx,
+            rows=sorted_rows,
+            cols_per_row=[sorted(self.matches[ridx]) for ridx in sorted_rows],
+            current_rpos=0,
+            current_cpos=0,
+            current_occurrence=0,
+            total_occurrence=sum(len(col_idxs) for col_idxs in self.matches.values()),
+            replaced_occurrence=0,
+            skipped_occurrence=0,
+            done=False,
+        )
+
+        try:
+            if replace_all:
+                # Replace all occurrences
+                self._do_replace_all(term_find, term_replace)
+            else:
+                # Replace with confirmation for each occurrence
+                self._do_replace_interactive(term_find, term_replace)
+
+        except Exception as e:
+            self.notify(
+                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
+                title="Replace",
+                severity="error",
+            )
+            self.log(f"Error replacing `{term_find}` with `{term_replace}`: {str(e)}")
+
+    def _do_replace_all(self, term_find: str, term_replace: str) -> None:
+        """Replace all occurrences."""
+        state = self._replace_state
+        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?",
+            ),
+            callback=self._handle_replace_all_confirmation,
+        )
+
+    def _handle_replace_all_confirmation(self, result) -> None:
+        """Handle user's confirmation for replace all."""
+        if result is None:
+            return
+
+        state = self._replace_state
+        rows = state.rows
+        cols_per_row = state.cols_per_row
+
+        # Batch replacements by column for efficiency
+        # Group row indices by column to minimize dataframe operations
+        cidxs_to_replace: dict[int, set[int]] = defaultdict(set)
+
+        # Single column replacement
+        if state.cidx is not None:
+            cidxs_to_replace[state.cidx].update(rows)
+        # Multiple columns replacement
+        else:
+            for ridx, cidxs in zip(rows, cols_per_row):
+                for cidx in cidxs:
+                    cidxs_to_replace[cidx].add(ridx)
+
+        # Apply replacements column by column (single operation per column)
+        for cidx, ridxs in cidxs_to_replace.items():
+            col_name = self.df.columns[cidx]
+            dtype = self.df.dtypes[cidx]
+
+            # Create a mask for rows to replace
+            mask = pl.arange(0, len(self.df)).is_in(ridxs)
+
+            # Only applicable to string columns for substring matches
+            if dtype == pl.String and not state.match_whole:
+                term_find = f"(?i){state.term_find}" if state.match_nocase else state.term_find
+                self.df = self.df.with_columns(
+                    pl.when(mask)
+                    .then(pl.col(col_name).str.replace_all(term_find, state.term_replace))
+                    .otherwise(pl.col(col_name))
+                    .alias(col_name)
+                )
+            else:
+                # Try to convert replacement value to column dtype
+                try:
+                    value = DtypeConfig(dtype).convert(state.term_replace)
+                except Exception:
+                    value = state.term_replace
+
+                self.df = self.df.with_columns(
+                    pl.when(mask).then(pl.lit(value)).otherwise(pl.col(col_name)).alias(col_name)
+                )
+
+            state.replaced_occurrence += len(ridxs)
+
+        # Recreate table for display
+        self._setup_table()
+
+        col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
+        self.notify(
+            f"Replaced [$accent]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$success]{col_name}[/]",
+            title="Replace",
+        )
+
+    def _do_replace_interactive(self, term_find: str, term_replace: str) -> None:
+        """Replace with user confirmation for each occurrence."""
+        try:
+            # Start with first match
+            self._show_next_replace_confirmation()
+        except Exception as e:
+            self.notify(
+                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
+                title="Replace",
+                severity="error",
             )
+            self.log(f"Error in interactive replace: {str(e)}")
+
+    def _show_next_replace_confirmation(self) -> None:
+        """Show confirmation for next replacement."""
+        state = self._replace_state
+        if state.done:
+            # All done - show final notification
+            col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
+            msg = f"Replaced [$accent]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$success]{col_name}[/]"
+            if state.skipped_occurrence > 0:
+                msg += f", [$warning]{state.skipped_occurrence}[/] skipped"
+            self.notify(msg, title="Replace")
+            return
+
+        # Move cursor to next match
+        ridx = state.rows[state.current_rpos]
+        cidx = state.cols_per_row[state.current_rpos][state.current_cpos]
+        self.move_cursor_to(ridx, cidx)
+
+        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})?"
+
+        self.app.push_screen(
+            ConfirmScreen("Replace", label=label, maybe="Skip"),
+            callback=self._handle_replace_confirmation,
+        )
+
+    def _handle_replace_confirmation(self, result) -> None:
+        """Handle user's confirmation response."""
+        state = self._replace_state
+        if state.done:
             return
 
+        ridx = state.rows[state.current_rpos]
+        cidx = state.cols_per_row[state.current_rpos][state.current_cpos]
+        col_name = self.df.columns[cidx]
+        dtype = self.df.dtypes[cidx]
+
+        # Replace
+        if result is True:
+            # Only applicable to string columns for substring matches
+            if dtype == pl.String and not state.match_whole:
+                term_find = f"(?i){state.term_find}" if state.match_nocase else state.term_find
+                self.df = self.df.with_columns(
+                    pl.when(pl.arange(0, len(self.df)) == ridx)
+                    .then(pl.col(col_name).str.replace_all(term_find, state.term_replace))
+                    .otherwise(pl.col(col_name))
+                    .alias(col_name)
+                )
+            else:
+                # try to convert replacement value to column dtype
+                try:
+                    value = DtypeConfig(dtype).convert(state.term_replace)
+                except Exception:
+                    value = state.term_replace
+
+                self.df = self.df.with_columns(
+                    pl.when(pl.arange(0, len(self.df)) == ridx)
+                    .then(pl.lit(value))
+                    .otherwise(pl.col(col_name))
+                    .alias(col_name)
+                )
+
+            state.replaced_occurrence += 1
+
+        # Skip
+        elif result is False:
+            state.skipped_occurrence += 1
+
+        # Cancel
+        else:
+            state.done = True
+            self._setup_table()
+            return
+
+        # Move to next
+        if state.current_cpos + 1 < len(state.cols_per_row[state.current_rpos]):
+            state.current_cpos += 1
+        else:
+            state.current_cpos = 0
+            state.current_rpos += 1
+
+        if state.current_rpos >= len(state.rows):
+            state.done = True
+
+        # Get the new value of the current cell after replacement
+        new_cell_value = self.df.item(ridx, cidx)
+        row_key = str(ridx)
+        col_key = col_name
+        self.update_cell(
+            row_key, col_key, Text(str(new_cell_value), style=HIGHLIGHT_COLOR, justify=DtypeConfig(dtype).justify)
+        )
+
+        # # Recreate table for display
+        # self._setup_table()
+
+        # Show next confirmation
+        self._show_next_replace_confirmation()
+
+    # Selection & Match
+    def _toggle_selections(self) -> None:
+        """Toggle selected rows highlighting on/off."""
         # Add to history
-        self._add_history(f"Filtered by expression [on $primary]{expr_str}[/]")
+        self._add_history("Toggled row selection")
 
-        # Mark unfiltered rows as invisible and unselected
-        filtered_row_indices = set(df_filtered["__rid__"].to_list())
-        if filtered_row_indices:
-            for rid in range(len(self.visible_rows)):
-                if rid not in filtered_row_indices:
-                    self.visible_rows[rid] = False
-                    self.selected_rows[rid] = False
+        if False in self.visible_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 [$accent]{new_selected_count}[/] rows", title="Toggle")
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
-        self.app.notify(
-            f"Filtered to [$accent]{matched_count}[/] matching rows",
-            title="Filter",
+    def _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 _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 [$accent]{row_count}[/] rows", title="Clear")
+
+    # Filter & View
     def _filter_rows(self) -> None:
-        """Filter rows.
+        """Keep only the rows with selections and matches, and remove others."""
+        if not any(self.selected_rows) and not self.matches:
+            self.notify("No rows to filter", title="Filter", severity="warning")
+            return
+
+        filter_expr = [
+            True if (selected or ridx in self.matches) else False for ridx, selected in enumerate(self.selected_rows)
+        ]
+
+        # Add to history
+        self._add_history("Filtered to selections and matches")
+
+        # Apply filter to dataframe with row indices
+        df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
+
+        # Update selections and matches
+        self.selected_rows = [self.selected_rows[ridx] for ridx in df_filtered[RIDX]]
+        self.matches = {
+            idx: self.matches[ridx].copy() for idx, ridx in enumerate(df_filtered[RIDX]) if ridx in self.matches
+        }
+
+        # Update dataframe
+        self.df = df_filtered.drop(RIDX)
+
+        # Recreate table for display
+        self._setup_table()
+
+        self.notify(
+            f"Removed rows without selections or matches. Now showing [$accent]{len(self.df)}[/] rows", title="Filter"
+        )
+
+    def _view_rows(self) -> None:
+        """View rows.
 
-        If there are selected rows, filter to those rows.
-        Otherwise, filter based on the value of the currently selected cell.
+        If there are selected rows or matches, view those rows.
+        Otherwise, view based on the value of the currently selected cell.
         """
 
-        if True in self.selected_rows:
-            expr = self.selected_rows
-            expr_str = "selected rows"
+        cidx = self.cursor_col_idx
+
+        # If there are rows with selections or matches, use those
+        if any(self.selected_rows) or self.matches:
+            term = [
+                True if (selected or idx in self.matches) else False for idx, selected in enumerate(self.selected_rows)
+            ]
+        # Otherwise, use the current cell value
         else:
-            row_key = self.cursor_row_key
-            row_idx = int(row_key.value) - 1  # Convert to 0-based index
-            col_idx = self.cursor_column
+            ridx = self.cursor_row_idx
+            term = str(self.df.item(ridx, cidx))
 
-            cell_value = self.df.item(row_idx, col_idx)
+        self._do_view_rows((term, cidx, False, True))
 
-            if cell_value is None:
-                expr = pl.col(self.df.columns[col_idx]).is_null()
-                expr_str = "NULL"
+    def _view_rows_expr(self) -> None:
+        """Open the filter screen to enter an expression."""
+        ridx = self.cursor_row_idx
+        cidx = self.cursor_col_idx
+        cursor_value = str(self.df.item(ridx, cidx))
+
+        self.app.push_screen(
+            FilterScreen(self.df, cidx, cursor_value),
+            callback=self._do_view_rows,
+        )
+
+    def _do_view_rows(self, result) -> None:
+        """Show only rows with selections or matches, and do hide others. Do not modify the dataframe."""
+        if result is None:
+            return
+        term, cidx, match_nocase, match_whole = result
+
+        col_name = self.df.columns[cidx]
+
+        if term == NULL:
+            expr = pl.col(col_name).is_null()
+        elif isinstance(term, (list, pl.Series)):
+            # Support for list of booleans (selected rows)
+            expr = term
+        elif tentative_expr(term):
+            # Support for polars expressions
+            try:
+                expr = validate_expr(term, self.df.columns, cidx)
+            except Exception as e:
+                self.notify(f"Error validating expression [$error]{term}[/]", title="Filter", severity="error")
+                self.log(f"Error validating expression `{term}`: {str(e)}")
+                return
+        else:
+            dtype = self.df.dtypes[cidx]
+            if dtype == pl.String:
+                if match_whole:
+                    term = f"^{term}$"
+                if match_nocase:
+                    term = f"(?i){term}"
+                expr = pl.col(col_name).str.contains(term)
             else:
-                expr = pl.col(self.df.columns[col_idx]) == cell_value
-                expr_str = f"$_ == {repr(cell_value)}"
+                try:
+                    value = DtypeConfig(dtype).convert(term)
+                    expr = pl.col(col_name) == value
+                except Exception:
+                    if match_whole:
+                        term = f"^{term}$"
+                    if match_nocase:
+                        term = f"(?i){term}"
+                    expr = pl.col(col_name).cast(pl.String).str.contains(term)
+                    self.notify(
+                        f"Unknown column type [$warning]{dtype}[/]. Cast to string.", title="Filter", severity="warning"
+                    )
 
-        self._do_filter((expr, expr_str))
+        # Lazyframe with row indices
+        lf = self.df.lazy().with_row_index(RIDX)
 
-    def _cycle_cursor_type(self) -> None:
-        """Cycle through cursor types: cell -> row -> column -> cell."""
-        next_type = _next(CURSOR_TYPES, self.cursor_type)
-        self.cursor_type = next_type
+        # Apply existing visibility filter first
+        if False in self.visible_rows:
+            lf = lf.filter(self.visible_rows)
 
-        self.app.notify(
-            f"Changed cursor type to [on $primary]{next_type}[/]", title="Cursor"
-        )
+        # Apply the filter expression
+        try:
+            df_filtered = lf.filter(expr).collect()
+        except Exception as e:
+            self.histories.pop()  # Remove last history entry
+            self.notify(f"Error applying filter [$error]{expr}[/]", title="Filter", severity="error")
+            self.log(f"Error applying filter `{expr}`: {str(e)}")
+            return
 
-    def _toggle_row_labels(self) -> None:
-        """Toggle row labels visibility."""
-        self.show_row_labels = not self.show_row_labels
-        status = "shown" if self.show_row_labels else "hidden"
-        self.app.notify(f"Row labels {status}", title="Labels")
+        matched_count = len(df_filtered)
+        if not matched_count:
+            self.notify(f"No rows match the expression: [$success]{expr}[/]", title="Filter", severity="warning")
+            return
+
+        # Add to history
+        self._add_history(f"Filtered by expression [$success]{expr}[/]")
+
+        # Mark unfiltered rows as invisible
+        filtered_row_indices = set(df_filtered[RIDX].to_list())
+        if filtered_row_indices:
+            for ridx in range(len(self.visible_rows)):
+                if ridx not in filtered_row_indices:
+                    self.visible_rows[ridx] = False
+
+        # Recreate table for display
+        self._setup_table()
+
+        self.notify(f"Filtered to [$accent]{matched_count}[/] matching rows", title="Filter")
+
+    # Copy & Save
+    def _copy_to_clipboard(self, content: str, message: str) -> None:
+        """Copy content to clipboard using pbcopy (macOS) or xclip (Linux).
+
+        Args:
+            content: The text content to copy to clipboard.
+            message: The notification message to display on success.
+        """
+        import subprocess
+
+        try:
+            subprocess.run(
+                [
+                    "pbcopy" if sys.platform == "darwin" else "xclip",
+                    "-selection",
+                    "clipboard",
+                ],
+                input=content,
+                text=True,
+            )
+            self.notify(message, title="Clipboard")
+        except FileNotFoundError:
+            self.notify("Error copying to clipboard", title="Clipboard", severity="error")
 
     def _save_to_file(self) -> None:
-        """Open save file dialog."""
-        self.app.push_screen(
-            SaveFileScreen(self.filename), callback=self._on_save_file_screen
-        )
+        """Open screen to save file."""
+        self.app.push_screen(SaveFileScreen(self.filename), callback=self._do_save_file)
 
-    def _on_save_file_screen(
-        self, filename: str | None, all_tabs: bool = False
-    ) -> None:
+    def _do_save_file(self, filename: str | None, all_tabs: bool = False) -> None:
         """Handle result from SaveFileScreen."""
         if filename is None:
             return
@@ -1336,7 +3149,7 @@ class DataFrameTable(DataTable):
             # Go back to SaveFileScreen to allow user to enter a different name
             self.app.push_screen(
                 SaveFileScreen(self._pending_filename),
-                callback=self._on_save_file_screen,
+                callback=self._do_save_file,
             )
 
     def _do_save(self, filename: str) -> None:
@@ -1344,6 +3157,9 @@ class DataFrameTable(DataTable):
         filepath = Path(filename)
         ext = filepath.suffix.lower()
 
+        # Add to history
+        self._add_history(f"Saved dataframe to [$success]{filename}[/]")
+
         try:
             if ext in (".xlsx", ".xls"):
                 self._do_save_excel(filename)
@@ -1359,13 +3175,11 @@ class DataFrameTable(DataTable):
             self.dataframe = self.df  # Update original dataframe
             self.filename = filename  # Update current filename
             if not self._all_tabs:
-                self.app.notify(
-                    f"Saved [$accent]{len(self.df)}[/] rows to [on $primary]{filename}[/]",
-                    title="Save",
-                )
+                extra = "current tab with " if len(self.app.tabs) > 1 else ""
+                self.notify(f"Saved {extra}[$accent]{len(self.df)}[/] rows to [$success]{filename}[/]", title="Save")
         except Exception as e:
-            self.app.notify(f"Failed to save: {str(e)}", title="Save", severity="error")
-            raise e
+            self.notify(f"Error saving [$error]{filename}[/]", title="Save", severity="error")
+            self.log(f"Error saving file `{filename}`: {str(e)}")
 
     def _do_save_excel(self, filename: str) -> None:
         """Save to an Excel file."""
@@ -1377,17 +3191,78 @@ class DataFrameTable(DataTable):
         else:
             # Multiple tabs - use xlsxwriter to create multiple sheets
             with xlsxwriter.Workbook(filename) as wb:
-                for table in self.app.tabs.values():
-                    table.df.write_excel(wb, worksheet=table.tabname[:31])
+                tabs: dict[TabPane, DataFrameTable] = self.app.tabs
+                for tab, table in tabs.items():
+                    worksheet = wb.add_worksheet(tab.name)
+                    table.df.write_excel(workbook=wb, worksheet=worksheet)
 
         # From ConfirmScreen callback, so notify accordingly
         if self._all_tabs is True:
-            self.app.notify(
-                f"Saved all tabs to [on $primary]{filename}[/]",
-                title="Save",
-            )
+            self.notify(f"Saved all tabs to [$success]{filename}[/]", title="Save")
         else:
-            self.app.notify(
-                f"Saved current tab with [$accent]{len(self.df)}[/] rows to [on $primary]{filename}[/]",
-                title="Save",
+            self.notify(
+                f"Saved current tab with [$accent]{len(self.df)}[/] rows to [$success]{filename}[/]", title="Save"
             )
+
+    # SQL Interface
+    def _simple_sql(self) -> None:
+        """Open the SQL interface screen."""
+        self.app.push_screen(
+            SimpleSqlScreen(self),
+            callback=self._do_simple_sql,
+        )
+
+    def _do_simple_sql(self, result) -> None:
+        """Handle SQL result result from SimpleSqlScreen."""
+        if result is None:
+            return
+        columns, where = result
+
+        sql = f"SELECT {columns} FROM self"
+        if where:
+            sql += f" WHERE {where}"
+
+        self._do_sql(sql)
+
+    def _advanced_sql(self) -> None:
+        """Open the advanced SQL interface screen."""
+        self.app.push_screen(
+            AdvancedSqlScreen(self),
+            callback=self._do_advanced_sql,
+        )
+
+    def _do_advanced_sql(self, result) -> None:
+        """Handle SQL result result from AdvancedSqlScreen."""
+        if result is None:
+            return
+
+        self._do_sql(result)
+
+    def _do_sql(self, sql: str) -> None:
+        """Execute a SQL query directly.
+
+        Args:
+            sql: The SQL query string to execute.
+        """
+        # Add to history
+        self._add_history(f"SQL Query:\n[$accent]{sql}[/]")
+
+        # Execute the SQL query
+        try:
+            self.df = self.df.sql(sql)
+        except Exception as e:
+            self.notify(f"Error executing SQL query [$error]{sql}[/]", title="SQL Query", severity="error")
+            self.log(f"Error executing SQL query `{sql}`: {str(e)}")
+            return
+
+        if not len(self.df):
+            self.notify(f"SQL query returned no results for [$warning]{sql}[/]", title="SQL Query", severity="warning")
+            return
+
+        # Recreate table for display
+        self._setup_table()
+
+        self.notify(
+            f"SQL query executed successfully. Now showing [$accent]{len(self.df)}[/] rows and [$accent]{len(self.df.columns)}[/] columns.",
+            title="SQL Query",
+        )