dataframe-textual 1.4.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

dataframe_textual/data_frame_table.py

@@ -12,6 +12,7 @@ from rich.text import Text
 from textual import work
 from textual.coordinate import Coordinate
 from textual.events import Click
+from textual.reactive import reactive
 from textual.render import measure
 from textual.widgets import DataTable, TabPane
 from textual.widgets._data_table import (
@@ -31,6 +32,7 @@ from .common import (
     DtypeConfig,
     format_row,
     get_next_item,
+    parse_placeholders,
     rindex,
     sleep_async,
     tentative_expr,
@@ -40,6 +42,7 @@ from .sql_screen import AdvancedSqlScreen, SimpleSqlScreen
 from .table_screen import FrequencyScreen, RowDetailScreen, StatisticsScreen
 from .yes_no_screen import (
     AddColumnScreen,
+    AddLinkScreen,
     ConfirmScreen,
     EditCellScreen,
     EditColumnScreen,
@@ -77,6 +80,7 @@ class History:
     fixed_columns: int
     cursor_coordinate: Coordinate
     matches: dict[int, set[int]]
+    dirty: bool = False  # Whether this history state has unsaved changes
 
 
 @dataclass
@@ -110,11 +114,18 @@ class DataFrameTable(DataTable):
         - **↑↓←→** - 🎯 Move cursor (cell/row/column)
         - **g** - ⬆️ Jump to first row
         - **G** - ⬇️ Jump to last row
+        - **HOME/END** - 🎯 Jump to first/last column
+        - **Ctrl+HOME/END** - 🎯 Jump to page top/bottom
         - **Ctrl+F** - 📜 Page down
         - **Ctrl+B** - 📜 Page up
         - **PgUp/PgDn** - 📜 Page up/down
 
-        ## 👁️ View & Display
+        ## ♻️ Undo/Redo/Reset
+        - **u** - ↩️ Undo last action
+        - **U** - 🔄 Redo last undone action
+        - **Ctrl+U** - 🔁 Reset to initial state
+
+        ## 👁️ Viewing & Display
         - **Enter** - 📋 Show row details in modal
         - **F** - 📊 Show frequency distribution
         - **s** - 📈 Show statistics for current column
@@ -132,7 +143,7 @@ class DataFrameTable(DataTable):
         - **]** - 🔽 Sort column descending
         - *(Multi-column sort supported)*
 
-        ## 🔍 Search & Filter
+        ## 🔍 Searching & Filtering
         - **|** - 🔎 Search in current column with expression
         - **\\\\** - 🔎 Search in current column using cursor value
         - **/** - 🔎 Find in current column with cursor value
@@ -141,8 +152,8 @@ class DataFrameTable(DataTable):
         - **:** - 🌐 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
+        - **v** - 👁️ View/filter rows by cell or selected rows and hide others
+        - **V** - 🔧 View/filter rows by expression and hide others
         - *(All search/find support case-insensitive & whole-word matching)*
 
         ## ✏️ Replace
@@ -150,24 +161,25 @@ class DataFrameTable(DataTable):
         - **R** - 🔄 Replace across all columns (interactive or all)
         - *(Supports case-insensitive & whole-word matching)*
 
-        ## ✅ Selection & Filtering
+        ## ✅ Selection & Filter
         - **'** - ✓️ Select/deselect current row
         - **t** - 💡 Toggle row selection (invert all)
+        - **T** - 🧹 Clear all selections and matches
         - **{** - ⬆️ Go to previous selected row
         - **}** - ⬇️ Go to next selected row
-        - **"** - 📍 Filter to show only selected rows
-        - **T** - 🧹 Clear all selections and matches
+        - **"** - 📍 Filter selected rows and remove others
 
         ## 🔍 SQL Interface
-        - **l** - 💬 Open simple SQL interface (select columns & WHERE clause)
+        - **l** - 💬 Open simple SQL interface (select columns & where clause)
         - **L** - 🔎 Open advanced SQL interface (full SQL queries)
 
-        ## ✏️ Edit & Modify
+        ## ✏️ Editing
         - **Double-click** - ✍️ Edit cell or rename column header
         - **e** - ✍️ Edit current cell
         - **E** - 📊 Edit entire column with expression
         - **a** - ➕ Add empty column after current
         - **A** - ➕ Add column with name and optional expression
+        - **@** - 🔗 Add a new link column from template
         - **x** - ❌ Delete current row
         - **X** - ❌ Delete row and those below
         - **Ctrl+X** - ❌ Delete row and those above
@@ -180,23 +192,17 @@ class DataFrameTable(DataTable):
         - **Shift+↑↓** - ⬆️⬇️ Move row up/down
         - **Shift+←→** - ⬅️➡️ Move column left/right
 
-        ## 🎨 Type Conversion
+        ## 🎨 Type Casting
         - **#** - 🔢 Cast column to integer
         - **%** - 🔢 Cast column to float
         - **!** - ✅ Cast column to boolean
         - **$** - 📝 Cast column to string
 
-        ## 🔗 URL Handling
-        - **@** - 🔗 Make URLs in current column clickable with Ctrl/Cmd
-
-        ## 💾 Data Management
+        ## 💾 Copy & Save
         - **c** - 📋 Copy cell to clipboard
         - **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** - 🔄 Redo last undone action
-        - **Ctrl+U** - 🔁 Reset to initial state
     """).strip()
 
     # fmt: off
@@ -206,6 +212,10 @@ class DataFrameTable(DataTable):
         ("G", "jump_bottom", "Jump to bottom"),
         ("ctrl+f", "forward_page", "Page down"),
         ("ctrl+b", "backward_page", "Page up"),
+        # Undo/Redo/Reset
+        ("u", "undo", "Undo"),
+        ("U", "redo", "Redo"),
+        ("ctrl+u", "reset", "Reset to initial state"),
         # Display
         ("h", "hide_column", "Hide column"),
         ("H", "show_hidden_rows_columns", "Show hidden rows/columns"),
@@ -266,28 +276,27 @@ class DataFrameTable(DataTable):
         # 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
+        # Type Casting
         ("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"),  # `$`
-        ("at", "make_cell_clickable", "Make cell clickable"),  # `@`
         # 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:
+    # Track if dataframe has unsaved changes
+    dirty: reactive[bool] = reactive(False)
+
+    def __init__(self, df: pl.DataFrame, filename: str = "", tabname: 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
@@ -296,19 +305,16 @@ class DataFrameTable(DataTable):
         Args:
             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).
+            tabname: Optional name for the tab displaying this dataframe. Defaults to "".
             **kwargs: Additional keyword arguments passed to the parent DataTable widget.
-
-        Returns:
-            None
         """
-        super().__init__(name=(name or Path(filename).stem), **kwargs)
+        super().__init__(**kwargs)
 
         # DataFrame state
         self.dataframe = df  # Original dataframe
         self.df = df  # Internal/working dataframe
-        self.filename = filename  # Current filename
-
+        self.filename = filename or "untitled.csv"  # Current filename
+        self.tabname = tabname or Path(filename).stem  # Tab name
         # Pagination & Loading
         self.INITIAL_BATCH_SIZE = (self.app.size.height // 100 + 1) * 100
         self.BATCH_SIZE = self.INITIAL_BATCH_SIZE // 2
@@ -330,9 +336,6 @@ class DataFrameTable(DataTable):
         # 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
 
@@ -431,6 +434,15 @@ class DataFrameTable(DataTable):
                 matches.append((ridx, cidx))
         return matches
 
+    @property
+    def last_history(self) -> History:
+        """Get the last history state.
+
+        Returns:
+            History: The most recent History object from the histories deque.
+        """
+        return self.histories[-1] if self.histories else None
+
     def get_row_key(self, row_idx: int) -> RowKey:
         """Get the row key for a given table row index.
 
@@ -453,7 +465,7 @@ class DataFrameTable(DataTable):
         """
         return self._column_locations.get_key(col_idx)
 
-    def _should_highlight(self, cursor: Coordinate, target_cell: Coordinate, type_of_cursor: CursorType) -> bool:
+    def should_highlight(self, cursor: Coordinate, target_cell: Coordinate, type_of_cursor: CursorType) -> bool:
         """Determine if the given cell should be highlighted because of the cursor.
 
         In "cell" mode, also highlights the row and column headers. In "row" and "column"
@@ -496,9 +508,6 @@ class DataFrameTable(DataTable):
         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)
@@ -536,6 +545,27 @@ class DataFrameTable(DataTable):
             else:
                 self._scroll_cursor_into_view()
 
+    def watch_dirty(self, old_dirty: bool, new_dirty: bool) -> None:
+        """Watch for changes to the dirty state and update tab title.
+
+        When new_dirty is True, set the tab color to red.
+        When new_dirty is False, remove the red color.
+
+        Args:
+            old_dirty: The old dirty state.
+            new_dirty: The new dirty state.
+        """
+        if old_dirty == new_dirty:
+            return  # No change
+
+        # Find the corresponding ContentTab
+        content_tab = self.app.query_one(f"#--content-tab-{self.id}")
+        if content_tab:
+            if new_dirty:
+                content_tab.add_class("dirty")
+            else:
+                content_tab.remove_class("dirty")
+
     def move_cursor_to(self, ridx: int, cidx: int) -> None:
         """Move cursor based on the dataframe indices.
 
@@ -545,7 +575,7 @@ class DataFrameTable(DataTable):
         """
         # Ensure the target row is loaded
         if ridx >= self.loaded_rows:
-            self._load_rows(stop=ridx + self.BATCH_SIZE)
+            self.load_rows(stop=ridx + self.BATCH_SIZE)
 
         row_key = str(ridx)
         col_key = self.df.columns[cidx]
@@ -557,11 +587,8 @@ class DataFrameTable(DataTable):
 
         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()
+        # self.setup_table()
         pass
 
     def on_key(self, event) -> None:
@@ -572,13 +599,10 @@ class DataFrameTable(DataTable):
 
         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()
+            self.check_and_load_more()
 
     def on_click(self, event: Click) -> None:
         """Handle mouse click events on the table.
@@ -587,9 +611,6 @@ class DataFrameTable(DataTable):
 
         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:
@@ -600,9 +621,9 @@ class DataFrameTable(DataTable):
 
             # header row
             if row_idx == -1:
-                self._rename_column()
+                self.do_rename_column()
             else:
-                self._edit_cell()
+                self.do_edit_cell()
 
     # Action handlers for BINDINGS
     def action_jump_top(self) -> None:
@@ -611,12 +632,12 @@ class DataFrameTable(DataTable):
 
     def action_jump_bottom(self) -> None:
         """Jump to the bottom of the table."""
-        self._load_rows(move_to_end=True)
+        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()
+        self.check_and_load_more()
 
     def action_backward_page(self) -> None:
         """Scroll up one page."""
@@ -624,39 +645,39 @@ class DataFrameTable(DataTable):
 
     def action_view_row_detail(self) -> None:
         """View details of the current row."""
-        self._view_row_detail()
+        self.do_view_row_detail()
 
     def action_delete_column(self) -> None:
         """Delete the current column."""
-        self._delete_column()
+        self.do_delete_column()
 
     def action_hide_column(self) -> None:
         """Hide the current column."""
-        self._hide_column()
+        self.do_hide_column()
 
     def action_expand_column(self) -> None:
         """Expand the current column to its full width."""
-        self._expand_column()
+        self.do_expand_column()
 
     def action_show_hidden_rows_columns(self) -> None:
         """Show all hidden rows/columns."""
-        self._show_hidden_rows_columns()
+        self.do_show_hidden_rows_columns()
 
     def action_sort_ascending(self) -> None:
         """Sort by current column in ascending order."""
-        self._sort_by_column(descending=False)
+        self.do_sort_by_column(descending=False)
 
     def action_sort_descending(self) -> None:
         """Sort by current column in descending order."""
-        self._sort_by_column(descending=True)
+        self.do_sort_by_column(descending=True)
 
     def action_save_to_file(self) -> None:
         """Save the current dataframe to a file."""
-        self._save_to_file()
+        self.do_save_to_file()
 
     def action_show_frequency(self) -> None:
         """Show frequency distribution for the current column."""
-        self._show_frequency()
+        self.do_show_frequency()
 
     def action_show_statistics(self, scope: str = "column") -> None:
         """Show statistics for the current column or entire dataframe.
@@ -664,47 +685,51 @@ class DataFrameTable(DataTable):
         Args:
             scope: Either "column" for current column stats or "dataframe" for all columns.
         """
-        self._show_statistics(scope)
+        self.do_show_statistics(scope)
 
     def action_view_rows(self) -> None:
         """View rows by current cell value."""
-        self._view_rows()
+        self.do_view_rows()
 
     def action_view_rows_expr(self) -> None:
         """Open the advanced filter screen."""
-        self._view_rows_expr()
+        self.do_view_rows_expr()
 
     def action_edit_cell(self) -> None:
         """Edit the current cell."""
-        self._edit_cell()
+        self.do_edit_cell()
 
     def action_edit_column(self) -> None:
         """Edit the entire current column with an expression."""
-        self._edit_column()
+        self.do_edit_column()
 
     def action_add_column(self) -> None:
         """Add an empty column after the current column."""
-        self._add_column()
+        self.do_add_column()
 
     def action_add_column_expr(self) -> None:
         """Add a new column with optional expression after the current column."""
-        self._add_column_expr()
+        self.do_add_column_expr()
+
+    def action_add_link_column(self) -> None:
+        """Open AddLinkScreen to create a new link column from a Polars expression."""
+        self.do_add_link_column()
 
     def action_rename_column(self) -> None:
         """Rename the current column."""
-        self._rename_column()
+        self.do_rename_column()
 
     def action_clear_cell(self) -> None:
         """Clear the current cell (set to None)."""
-        self._clear_cell()
+        self.do_clear_cell()
 
     def action_search_cursor_value(self) -> None:
         """Search cursor value in the current column."""
-        self._search_cursor_value()
+        self.do_search_cursor_value()
 
     def action_search_expr(self) -> None:
         """Search by expression in the current column."""
-        self._search_expr()
+        self.do_search_expr()
 
     def action_find_cursor_value(self, scope="column") -> None:
         """Find by cursor value.
@@ -712,7 +737,7 @@ class DataFrameTable(DataTable):
         Args:
             scope: "column" to find in current column, "global" to find across all columns.
         """
-        self._find_cursor_value(scope=scope)
+        self.do_find_cursor_value(scope=scope)
 
     def action_find_expr(self, scope="column") -> None:
         """Find by expression.
@@ -720,88 +745,87 @@ class DataFrameTable(DataTable):
         Args:
             scope: "column" to find in current column, "global" to find across all columns.
         """
-        self._find_expr(scope=scope)
+        self.do_find_expr(scope=scope)
 
     def action_replace(self) -> None:
         """Replace values in current column."""
-        self._replace()
+        self.do_replace()
 
     def action_replace_global(self) -> None:
         """Replace values across all columns."""
-        self._replace_global()
+        self.do_replace_global()
 
     def action_toggle_row_selection(self) -> None:
         """Toggle selection for the current row."""
-        self._toggle_row_selection()
+        self.do_toggle_row_selection()
 
     def action_toggle_selections(self) -> None:
         """Toggle all row selections."""
-        self._toggle_selections()
+        self.do_toggle_selections()
 
     def action_filter_rows(self) -> None:
         """Filter to show only selected rows."""
-        self._filter_rows()
+        self.do_filter_rows()
 
     def action_delete_row(self) -> None:
         """Delete the current row."""
-        self._delete_row()
+        self.do_delete_row()
 
     def action_delete_row_and_below(self) -> None:
         """Delete the current row and those below."""
-        self._delete_row(more="below")
+        self.do_delete_row(more="below")
 
     def action_delete_row_and_up(self) -> None:
         """Delete the current row and those above."""
-        self._delete_row(more="above")
+        self.do_delete_row(more="above")
 
     def action_duplicate_column(self) -> None:
         """Duplicate the current column."""
-        self._duplicate_column()
+        self.do_duplicate_column()
 
     def action_duplicate_row(self) -> None:
         """Duplicate the current row."""
-        self._duplicate_row()
+        self.do_duplicate_row()
 
     def action_undo(self) -> None:
         """Undo the last action."""
-        self._undo()
+        self.do_undo()
 
     def action_redo(self) -> None:
         """Redo the last undone action."""
-        self._redo()
+        self.do_redo()
 
     def action_reset(self) -> None:
         """Reset to the initial state."""
-        self._setup_table(reset=True)
-        self.notify("Restored initial state", title="Reset")
+        self.do_reset()
 
     def action_move_column_left(self) -> None:
         """Move the current column to the left."""
-        self._move_column("left")
+        self.do_move_column("left")
 
     def action_move_column_right(self) -> None:
         """Move the current column to the right."""
-        self._move_column("right")
+        self.do_move_column("right")
 
     def action_move_row_up(self) -> None:
         """Move the current row up."""
-        self._move_row("up")
+        self.do_move_row("up")
 
     def action_move_row_down(self) -> None:
         """Move the current row down."""
-        self._move_row("down")
+        self.do_move_row("down")
 
     def action_clear_selections_and_matches(self) -> None:
         """Clear all row selections and matches."""
-        self._clear_selections_and_matches()
+        self.do_clear_selections_and_matches()
 
     def action_cycle_cursor_type(self) -> None:
         """Cycle through cursor types."""
-        self._cycle_cursor_type()
+        self.do_cycle_cursor_type()
 
     def action_freeze_row_column(self) -> None:
         """Open the freeze screen."""
-        self._freeze_row_column()
+        self.do_freeze_row_column()
 
     def action_toggle_row_labels(self) -> None:
         """Toggle row labels visibility."""
@@ -811,7 +835,7 @@ class DataFrameTable(DataTable):
 
     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)
+        self.do_cast_column_dtype(dtype)
 
     def action_copy_cell(self) -> None:
         """Copy the current cell to clipboard."""
@@ -820,7 +844,7 @@ class DataFrameTable(DataTable):
 
         try:
             cell_str = str(self.df.item(ridx, cidx))
-            self._copy_to_clipboard(cell_str, f"Copied: [$success]{cell_str[:50]}[/]")
+            self.do_copy_to_clipboard(cell_str, f"Copied: [$success]{cell_str[:50]}[/]")
         except IndexError:
             self.notify("Error copying cell", title="Clipboard", severity="error")
 
@@ -833,7 +857,7 @@ class DataFrameTable(DataTable):
             col_values = [str(val) for val in self.df[col_name].to_list()]
             col_str = "\n".join(col_values)
 
-            self._copy_to_clipboard(
+            self.do_copy_to_clipboard(
                 col_str,
                 f"Copied [$accent]{len(col_values)}[/] values from column [$success]{col_name}[/]",
             )
@@ -849,54 +873,50 @@ class DataFrameTable(DataTable):
             row_values = [str(val) for val in self.df.row(ridx)]
             row_str = "\t".join(row_values)
 
-            self._copy_to_clipboard(
+            self.do_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_make_cell_clickable(self) -> None:
-        """Make cells with URLs in current column clickable."""
-        self._make_cell_clickable()
-
     def action_show_thousand_separator(self) -> None:
         """Toggle thousand separator for numeric display."""
         self.thousand_separator = not self.thousand_separator
-        self._setup_table()
+        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()
+        self.do_next_match()
 
     def action_previous_match(self) -> None:
         """Go to the previous matched cell."""
-        self._previous_match()
+        self.do_previous_match()
 
     def action_next_selected_row(self) -> None:
         """Go to the next selected row."""
-        self._next_selected_row()
+        self.do_next_selected_row()
 
     def action_previous_selected_row(self) -> None:
         """Go to the previous selected row."""
-        self._previous_selected_row()
+        self.do_previous_selected_row()
 
     def action_simple_sql(self) -> None:
         """Open the SQL interface screen."""
-        self._simple_sql()
+        self.do_simple_sql()
 
     def action_advanced_sql(self) -> None:
         """Open the advanced SQL interface screen."""
-        self._advanced_sql()
+        self.do_advanced_sql()
 
     def on_mouse_scroll_down(self, event) -> None:
         """Load more rows when scrolling down with mouse."""
-        self._check_and_load_more()
+        self.check_and_load_more()
 
     # Setup & Loading
-    def _setup_table(self, reset: bool = False) -> None:
+    def setup_table(self, reset: bool = False) -> None:
         """Setup the table for display.
 
         Row keys are 0-based indices, which map directly to dataframe row indices.
@@ -916,6 +936,9 @@ class DataFrameTable(DataTable):
             self.fixed_rows = 0
             self.fixed_columns = 0
             self.matches = defaultdict(set)
+            self.histories.clear()
+            self.history = None
+            self.dirty = False
 
         # Lazy load up to INITIAL_BATCH_SIZE visible rows
         stop, visible_count = self.INITIAL_BATCH_SIZE, 0
@@ -936,14 +959,14 @@ class DataFrameTable(DataTable):
         # Save current cursor position before clearing
         row_idx, col_idx = self.cursor_coordinate
 
-        self._setup_columns()
-        self._load_rows(stop)
+        self.setup_columns()
+        self.load_rows(stop)
 
         # Restore cursor position
         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]:
+    def determine_column_widths(self) -> dict[str, int]:
         """Determine optimal width for each column based on data type and content.
 
         For String columns:
@@ -985,6 +1008,8 @@ class DataFrameTable(DataTable):
             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(
@@ -1011,7 +1036,7 @@ class DataFrameTable(DataTable):
 
         return column_widths
 
-    def _setup_columns(self) -> None:
+    def setup_columns(self) -> None:
         """Clear table and setup columns.
 
         Column keys are header names from the dataframe.
@@ -1020,7 +1045,7 @@ class DataFrameTable(DataTable):
         self.clear(columns=True)
 
         # Get optimal column widths
-        column_widths = self._determine_column_widths()
+        column_widths = self.determine_column_widths()
 
         # Add columns with justified headers
         for col, dtype in zip(self.df.columns, self.df.dtypes):
@@ -1043,7 +1068,7 @@ class DataFrameTable(DataTable):
 
             self.add_column(Text(cell_value, justify=DtypeConfig(dtype).justify), key=col, width=width)
 
-    def _load_rows(self, stop: int | None = None, move_to_end: bool = False) -> None:
+    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:
@@ -1065,7 +1090,7 @@ class DataFrameTable(DataTable):
 
             def _continue(result: bool) -> None:
                 if result:
-                    self._load_rows_async(stop, move_to_end=move_to_end)
+                    self.load_rows_async(stop, move_to_end=move_to_end)
 
             self.app.push_screen(
                 ConfirmScreen(
@@ -1078,10 +1103,10 @@ class DataFrameTable(DataTable):
             return
 
         # Load rows asynchronously
-        self._load_rows_async(stop, move_to_end=move_to_end)
+        self.load_rows_async(stop, move_to_end=move_to_end)
 
     @work(exclusive=True, description="Loading rows...")
-    async def _load_rows_async(self, stop: int, move_to_end: bool = False) -> None:
+    async def load_rows_async(self, stop: int, move_to_end: bool = False) -> None:
         """Perform loading with async to avoid blocking.
 
         Args:
@@ -1095,19 +1120,19 @@ class DataFrameTable(DataTable):
             # Load max BATCH_SIZE rows at a time
             chunk_size = min(self.BATCH_SIZE, stop - self.loaded_rows)
             next_stop = min(self.loaded_rows + chunk_size, stop)
-            self._load_rows_batch(next_stop)
+            self.load_rows_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)
+                self.load_rows_async(stop, move_to_end=move_to_end)
                 return
 
         # 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))
 
-    def _load_rows_batch(self, stop: int) -> None:
+    def load_rows_batch(self, stop: int) -> None:
         """Load a batch of rows into the table.
 
         Row keys are 0-based indices as strings, which map directly to dataframe row indices.
@@ -1153,7 +1178,7 @@ class DataFrameTable(DataTable):
             self.notify("Error loading rows", title="Load", severity="error")
             self.log(f"Error loading rows: {str(e)}")
 
-    def _check_and_load_more(self) -> None:
+    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):
@@ -1164,10 +1189,10 @@ class DataFrameTable(DataTable):
 
         # 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)
+            self.load_rows(self.loaded_rows + self.BATCH_SIZE)
 
     # Highlighting
-    def _do_highlight(self, force: bool = False) -> None:
+    def apply_highlight(self, force: bool = False) -> None:
         """Update all rows, highlighting selected ones and restoring others to default.
 
         Args:
@@ -1177,10 +1202,10 @@ class DataFrameTable(DataTable):
         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)
+        self.load_rows(stop)
+        self.highlight_table(force)
 
-    def _highlight_table(self, force: bool = False) -> None:
+    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
@@ -1217,7 +1242,7 @@ class DataFrameTable(DataTable):
                     self.update_cell(row.key, col.key, cell_text)
 
     # History & Undo
-    def _create_history(self, description: str) -> None:
+    def create_history(self, description: str) -> None:
         """Create the initial history state."""
         return History(
             description=description,
@@ -1232,9 +1257,10 @@ class DataFrameTable(DataTable):
             fixed_columns=self.fixed_columns,
             cursor_coordinate=self.cursor_coordinate,
             matches={k: v.copy() for k, v in self.matches.items()},
+            dirty=self.dirty,
         )
 
-    def _apply_history(self, history: History) -> None:
+    def apply_history(self, history: History) -> None:
         """Apply the current history state to the table."""
         if history is None:
             return
@@ -1251,20 +1277,26 @@ class DataFrameTable(DataTable):
         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)
+        self.dirty = history.dirty
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
-    def _add_history(self, description: str) -> None:
+    def add_history(self, description: str, dirty: bool = False) -> None:
         """Add the current state to the history stack.
 
         Args:
             description: Description of the action for this history entry.
+            dirty: Whether this operation modifies the data (True) or just display state (False).
         """
-        history = self._create_history(description)
+        history = self.create_history(description)
         self.histories.append(history)
 
-    def _undo(self) -> None:
+        # Mark table as dirty if this operation modifies data
+        if dirty:
+            self.dirty = True
+
+    def do_undo(self) -> None:
         """Undo the last action."""
         if not self.histories:
             self.notify("No actions to undo", title="Undo", severity="warning")
@@ -1274,14 +1306,14 @@ class DataFrameTable(DataTable):
         history = self.histories.pop()
 
         # Save current state for redo
-        self.history = self._create_history(history.description)
+        self.history = self.create_history(history.description)
 
         # Restore state
-        self._apply_history(history)
+        self.apply_history(history)
 
         self.notify(f"Reverted: {history.description}", title="Undo")
 
-    def _redo(self) -> None:
+    def do_redo(self) -> None:
         """Redo the last undone action."""
         if self.history is None:
             self.notify("No actions to redo", title="Redo", severity="warning")
@@ -1290,39 +1322,51 @@ class DataFrameTable(DataTable):
         description = self.history.description
 
         # Save current state for undo
-        self._add_history(description)
+        self.add_history(description)
 
         # Restore state
-        self._apply_history(self.history)
+        self.apply_history(self.history)
 
         # Clear redo state
         self.history = None
 
         self.notify(f"Reapplied: {description}", title="Redo")
 
+    def do_reset(self) -> None:
+        """Reset the table to the initial state."""
+        self.setup_table(reset=True)
+        self.notify("Restored initial state", title="Reset")
+
+    def restore_dirty(self, default: bool | None = None) -> None:
+        """Restore the dirty state from the last history entry."""
+        if self.last_history:
+            self.dirty = self.last_history.dirty
+        elif default is not None:
+            self.dirty = default
+
     # Display
-    def _cycle_cursor_type(self) -> None:
+    def do_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")
 
-    def _view_row_detail(self) -> None:
+    def do_view_row_detail(self) -> None:
         """Open a modal screen to view the selected row's details."""
         ridx = self.cursor_row_idx
 
         # Push the modal screen
         self.app.push_screen(RowDetailScreen(ridx, self))
 
-    def _show_frequency(self) -> None:
+    def do_show_frequency(self) -> None:
         """Show frequency distribution for the current column."""
         cidx = self.cursor_col_idx
 
         # Push the frequency modal screen
         self.app.push_screen(FrequencyScreen(cidx, self))
 
-    def _show_statistics(self, scope: str = "column") -> None:
+    def do_show_statistics(self, scope: str = "column") -> None:
         """Show statistics for the current column or entire dataframe.
 
         Args:
@@ -1336,11 +1380,11 @@ class DataFrameTable(DataTable):
             cidx = self.cursor_col_idx
             self.app.push_screen(StatisticsScreen(self, col_idx=cidx))
 
-    def _freeze_row_column(self) -> None:
+    def do_freeze_row_column(self) -> None:
         """Open the freeze screen to set fixed rows and columns."""
-        self.app.push_screen(FreezeScreen(), callback=self._do_freeze)
+        self.app.push_screen(FreezeScreen(), callback=self.freeze_row_column)
 
-    def _do_freeze(self, result: tuple[int, int] | None) -> None:
+    def freeze_row_column(self, result: tuple[int, int] | None) -> None:
         """Handle result from PinScreen.
 
         Args:
@@ -1352,7 +1396,7 @@ class DataFrameTable(DataTable):
         fixed_rows, fixed_columns = result
 
         # Add to history
-        self._add_history(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{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:
@@ -1362,14 +1406,14 @@ class DataFrameTable(DataTable):
 
         # self.notify(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns", title="Pin")
 
-    def _hide_column(self) -> None:
+    def do_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}[/]")
+        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)
@@ -1383,7 +1427,7 @@ class DataFrameTable(DataTable):
 
         # self.notify(f"Hid column [$accent]{col_name}[/]. Press [$success]H[/] to show hidden columns", title="Hide")
 
-    def _expand_column(self) -> None:
+    def do_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
@@ -1420,7 +1464,7 @@ class DataFrameTable(DataTable):
             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:
+    def do_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)
@@ -1433,729 +1477,761 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self._add_history("Showed hidden rows/columns")
+        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.setup_table()
 
         self.notify(
             f"Showed [$accent]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] column(s)",
             title="Show",
         )
 
-    def _make_cell_clickable(self) -> None:
-        """Make cells with URLs in the current column clickable.
+    # Sort
+    def do_sort_by_column(self, descending: bool = False) -> None:
+        """Sort by the currently selected column.
 
-        Scans all loaded rows in the current column for cells containing URLs
-        (starting with 'http://' or 'https://') and applies Textual link styling
-        to make them clickable. Does not modify the dataframe.
+        Supports multi-column sorting:
+        - First press on a column: sort by that column only
+        - Subsequent presses on other columns: add to sort order
 
-        Returns:
-            None
+        Args:
+            descending: If True, sort in descending order. If False, ascending order.
         """
-        cidx = self.cursor_col_idx
-        col_key = self.cursor_col_key
-        dtype = self.df.dtypes[cidx]
-
-        # Only process string columns
-        if dtype != pl.String:
-            return
+        col_name = self.cursor_col_name
+        col_idx = self.cursor_column
 
-        # Count how many URLs were made clickable
-        url_count = 0
+        # Check if this column is already in the sort keys
+        old_desc = self.sorted_columns.get(col_name)
 
-        # Iterate through all loaded rows and make URLs clickable
-        for row in self.ordered_rows:
-            cell_text: Text = self.get_cell(row.key, col_key)
-            if cell_text.plain.startswith(("http://", "https://")):
-                cell_text.style = f"#00afff link {cell_text.plain}"  # sky blue
-                self.update_cell(row.key, col_key, cell_text)
-                url_count += 1
+        # Add to history
+        self.add_history(f"Sorted on column [$success]{col_name}[/]", dirty=True)
+        if old_desc is None:
+            # Add new column to sort
+            self.sorted_columns[col_name] = descending
+        elif old_desc == descending:
+            # Same direction - remove from sort
+            del self.sorted_columns[col_name]
+        else:
+            # Move to end of sort order
+            del self.sorted_columns[col_name]
+            self.sorted_columns[col_name] = descending
 
-        if url_count:
-            self.notify(
-                f"Use Ctrl/Cmd click to open the links in column [$success]{col_key.value}[/]", title="Hyperlink"
-            )
+        # Apply multi-column sort
+        if sort_cols := list(self.sorted_columns.keys()):
+            descending_flags = list(self.sorted_columns.values())
+            df_sorted = self.df.with_row_index(RIDX).sort(sort_cols, descending=descending_flags, nulls_last=True)
+        else:
+            # No sort columns - restore original order
+            df_sorted = self.df.with_row_index(RIDX)
 
-    # Delete & Move
-    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
-        col_name = self.cursor_col_name
-        col_key = self.cursor_col_key
+        # Updated selected_rows and visible_rows to match new order
+        old_row_indices = df_sorted[RIDX].to_list()
+        self.selected_rows = [self.selected_rows[i] for i in old_row_indices]
+        self.visible_rows = [self.visible_rows[i] for i in old_row_indices]
 
-        col_names_to_remove = []
-        col_keys_to_remove = []
+        # Update the dataframe
+        self.df = df_sorted.drop(RIDX)
 
-        # 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)
+        # Recreate table for display
+        self.setup_table()
 
-            message = f"Removed column [$success]{col_name}[/] and all columns before"
+        # Restore cursor position on the sorted column
+        self.move_cursor(column=col_idx, row=0)
 
-        # 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)
+    # Edit
+    def do_edit_cell(self, ridx: int = None, cidx: int = None) -> None:
+        """Open modal to edit the selected cell."""
+        ridx = self.cursor_row_idx if ridx is None else ridx
+        cidx = self.cursor_col_idx if cidx is None else cidx
 
-            message = f"Removed column [$success]{col_name}[/] and all columns after"
+        # Push the edit modal screen
+        self.app.push_screen(
+            EditCellScreen(ridx, cidx, self.df),
+            callback=self.edit_cell,
+        )
 
-        # 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}[/]"
+    def edit_cell(self, result) -> None:
+        """Handle result from EditCellScreen."""
+        if result is None:
+            return
 
-        # Add to history
-        self._add_history(message)
+        ridx, cidx, new_value = result
+        if new_value is None:
+            self.app.push_screen(
+                EditCellScreen(ridx, cidx, self.df),
+                callback=self.edit_cell,
+            )
+            return
 
-        # Remove the columns from the table display using the column names as keys
-        for ck in col_keys_to_remove:
-            self.remove_column(ck)
+        col_name = self.df.columns[cidx]
 
-        # 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)
+        # Add to history
+        self.add_history(f"Edited cell [$success]({ridx + 1}, {col_name})[/]", dirty=True)
 
-        # Remove from sorted columns if present
-        for col_name in col_names_to_remove:
-            if col_name in self.sorted_columns:
-                del self.sorted_columns[col_name]
+        # Update the cell in the dataframe
+        try:
+            self.df = self.df.with_columns(
+                pl.when(pl.arange(0, len(self.df)) == ridx)
+                .then(pl.lit(new_value))
+                .otherwise(pl.col(col_name))
+                .alias(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]
+            # Update the display
+            cell_value = self.df.item(ridx, cidx)
+            if cell_value is None:
+                cell_value = NULL_DISPLAY
+            dtype = self.df.dtypes[cidx]
+            dc = DtypeConfig(dtype)
+            formatted_value = Text(str(cell_value), style=dc.style, justify=dc.justify)
 
-        # Remove from dataframe
-        self.df = self.df.drop(col_names_to_remove)
+            # string as keys
+            row_key = str(ridx)
+            col_key = col_name
+            self.update_cell(row_key, col_key, formatted_value, update_width=True)
 
-        self.notify(message, title="Delete")
+            # self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit")
+        except Exception as e:
+            self.notify("Error updating cell", title="Edit", severity="error")
+            self.log(f"Error updating cell: {str(e)}")
 
-    def _duplicate_column(self) -> None:
-        """Duplicate the currently selected column, inserting it right after the current column."""
+    def do_edit_column(self) -> None:
+        """Open modal to edit the entire column with an expression."""
         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 :]
 
-        # 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)
+        # Push the edit column modal screen
+        self.app.push_screen(
+            EditColumnScreen(cidx, self.df),
+            callback=self.edit_column,
         )
 
-        # 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
+    def edit_column(self, result) -> None:
+        """Edit a column."""
+        if result is None:
+            return
+        term, cidx = result
 
-        # Recreate table for display
-        self._setup_table()
+        col_name = self.df.columns[cidx]
 
-        # Move cursor to the new duplicated column
-        self.move_cursor(column=col_idx + 1)
+        # Null case
+        if term is None or term == NULL:
+            expr = pl.lit(None)
 
-        # self.notify(f"Duplicated column [$accent]{col_name}[/] as [$success]{new_col_name}[/]", title="Duplicate")
+        # 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
 
-    def _delete_row(self, more: str = None) -> None:
-        """Delete rows from the table and dataframe.
+        # Otherwise, treat term as a literal value
+        else:
+            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))
 
-        Supports deleting multiple selected rows. If no rows are selected, deletes the row at the cursor.
-        """
-        old_count = len(self.df)
-        predicates = [True] * len(self.df)
+        # Add to history
+        self.add_history(f"Edited column [$accent]{col_name}[/] with expression", dirty=True)
 
-        # Delete all selected rows
-        if selected_count := self.selected_rows.count(True):
-            history_desc = f"Deleted {selected_count} selected row(s)"
+        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
 
-            for ridx, selected in enumerate(self.selected_rows):
-                if selected:
-                    predicates[ridx] = False
+        # Recreate table for display
+        self.setup_table()
 
-        # 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
+        # self.notify(f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]", title="Edit")
 
-        # 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
+    def do_rename_column(self) -> None:
+        """Open modal to rename the selected column."""
+        col_name = self.cursor_col_name
+        col_idx = self.cursor_column
 
-        # Delete the row at the cursor
-        else:
-            ridx = self.cursor_row_idx
-            history_desc = f"Deleted row [$success]{ridx + 1}[/]"
-            if self.visible_rows[ridx]:
-                predicates[ridx] = False
+        # Push the rename column modal screen
+        self.app.push_screen(
+            RenameColumnScreen(col_idx, col_name, self.df.columns),
+            callback=self.rename_column,
+        )
 
-        # Add to history
-        self._add_history(history_desc)
+    def rename_column(self, result) -> None:
+        """Handle result from RenameColumnScreen."""
+        if result is None:
+            return
 
-        # Apply the filter to remove rows
-        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
+        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.rename_column,
+            )
             return
 
-        self.df = df.drop(RIDX)
+        # Add to history
+        self.add_history(f"Renamed column [$accent]{col_name}[/] to [$success]{new_name}[/]", dirty=True)
 
-        # Update selected and visible rows tracking
-        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]
+        # Rename the column in the dataframe
+        self.df = self.df.rename({col_name: new_name})
 
-        # Clear all matches since row indices have changed
-        self.matches = defaultdict(set)
+        # 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)
+
+        # 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)
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
-        deleted_count = old_count - len(self.df)
-        if deleted_count > 0:
-            self.notify(f"Deleted [$accent]{deleted_count}[/] row(s)", title="Delete")
+        # Move cursor to the renamed column
+        self.move_cursor(column=col_idx)
 
-    def _duplicate_row(self) -> None:
-        """Duplicate the currently selected row, inserting it right after the current row."""
-        ridx = self.cursor_row_idx
+        # self.notify(f"Renamed column [$success]{col_name}[/] to [$success]{new_name}[/]", title="Column")
 
-        # Get the row to duplicate
-        row_to_duplicate = self.df.slice(ridx, 1)
+    def do_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
 
         # Add to history
-        self._add_history(f"Duplicated row [$success]{ridx + 1}[/]")
+        self.add_history(f"Cleared cell [$success]({ridx + 1}, {col_name})[/]", dirty=True)
 
-        # Concatenate: rows before + duplicated row + rows after
-        df_before = self.df.slice(0, ridx + 1)
-        df_after = self.df.slice(ridx + 1)
+        # 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)
+            )
 
-        # Combine the parts
-        self.df = pl.concat([df_before, row_to_duplicate, df_after])
+            # Update the display
+            dtype = self.df.dtypes[cidx]
+            dc = DtypeConfig(dtype)
+            formatted_value = Text(NULL_DISPLAY, style=dc.style, justify=dc.justify)
 
-        # 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
+            self.update_cell(row_key, col_key, formatted_value)
 
-        # 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
+            # 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
+
+    def do_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:
+            new_name = col_name
+
+        # Add to history
+        self.add_history(f"Added column [$success]{new_name}[/] after column {cidx + 1}", dirty=True)
+
+        try:
+            # Create an empty column (all None values)
+            if isinstance(col_value, pl.Expr):
+                new_col = col_value.alias(new_name)
             else:
-                new_matches[row_idx + 1] = cols
-        self.matches = new_matches
+                new_col = pl.lit(col_value).alias(new_name)
 
-        # Recreate table for display
-        self._setup_table()
+            # 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 :]
 
-        # Move cursor to the new duplicated row
-        self.move_cursor(row=ridx + 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)
 
-        # self.notify(f"Duplicated row [$success]{ridx + 1}[/]", title="Row")
+            # Recreate table for display
+            self.setup_table()
 
-    def _move_column(self, direction: str) -> None:
-        """Move the current column left or right.
+            # Move cursor to the new column
+            self.move_cursor(column=cidx + 1)
 
-        Args:
-            direction: "left" to move left, "right" to move right.
-        """
-        row_idx, col_idx = self.cursor_coordinate
-        col_key = self.cursor_col_key
-        col_name = col_key.value
+            # 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 do_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.add_column_expr,
+        )
 
-        # Validate move is possible
-        if direction == "left":
-            if col_idx <= 0:
-                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.notify("Cannot move column right", title="Move", severity="warning")
-                return
-            swap_idx = col_idx + 1
+    def 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
 
-        # 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)
+        cidx, new_col_name, expr = result
 
         # Add to history
-        self._add_history(f"Moved column [$success]{col_name}[/] {direction} (swapped with [$success]{swap_name}[/])")
+        self.add_history(f"Added column [$success]{new_col_name}[/] with expression {expr}.", dirty=True)
 
-        # Swap columns in the table's internal column locations
-        self.check_idle()
+        try:
+            # Create the column
+            new_col = expr.alias(new_col_name)
 
-        (
-            self._column_locations[col_key],
-            self._column_locations[swap_key],
-        ) = (
-            self._column_locations.get(swap_key),
-            self._column_locations.get(col_key),
-        )
+            # 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 :]
 
-        self._update_count += 1
-        self.refresh()
+            # 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)
 
-        # Restore cursor position on the moved column
-        self.move_cursor(row=row_idx, column=swap_idx)
+            # Recreate table for display
+            self.setup_table()
 
-        # Update the dataframe column order
-        cols = list(self.df.columns)
-        cols[cidx], cols[swap_cidx] = cols[swap_cidx], cols[cidx]
-        self.df = self.df.select(cols)
+            # Move cursor to the new column
+            self.move_cursor(column=cidx + 1)
 
-        # self.notify(f"Moved column [$success]{col_name}[/] {direction}", title="Move")
+            # 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 _move_row(self, direction: str) -> None:
-        """Move the current row up or down.
+    def do_add_link_column(self) -> None:
+        self.app.push_screen(
+            AddLinkScreen(self.cursor_col_idx, self.df),
+            callback=self.add_link_column,
+        )
+
+    def add_link_column(self, result: tuple[str, str] | None) -> None:
+        """Handle result from AddLinkScreen.
+
+        Creates a new link column in the dataframe with clickable links based on a
+        user-provided template. Supports multiple placeholder types:
+        - `$_` - 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:
-            direction: "up" to move up, "down" to move down.
+            result: Tuple of (cidx, new_col_name, link_template) or None if cancelled.
         """
-        row_idx, col_idx = self.cursor_coordinate
-
-        # Validate move is possible
-        if direction == "up":
-            if row_idx <= 0:
-                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.notify("Cannot move row down", title="Move", severity="warning")
-                return
-            swap_idx = row_idx + 1
-        else:
-            # Invalid direction
+        if result is None:
             return
+        cidx, new_col_name, link_template = result
 
-        row_key = self.coordinate_to_cell_key((row_idx, 0)).row_key
-        swap_key = self.coordinate_to_cell_key((swap_idx, 0)).row_key
-
-        # Add to history
-        self._add_history(
-            f"Moved row [$success]{row_key.value}[/] {direction} (swapped with row [$success]{swap_key.value}[/])"
+        self.add_history(
+            f"Added link column [$accent]{new_col_name}[/] with template [$success]{link_template}[/].", dirty=True
         )
 
-        # Swap rows in the table's internal row locations
-        self.check_idle()
+        try:
+            # Hack to support PubChem link
+            link_template = link_template.replace("PC", "pubchem.ncbi.nlm.nih.gov")
 
-        (
-            self._row_locations[row_key],
-            self._row_locations[swap_key],
-        ) = (
-            self._row_locations.get(swap_key),
-            self._row_locations.get(row_key),
-        )
+            # Ensure link starts with http:// or https://
+            if not link_template.startswith(("https://", "http://")):
+                link_template = "https://" + link_template
 
-        self._update_count += 1
-        self.refresh()
+            # Parse template placeholders into Polars expressions
+            parts = parse_placeholders(link_template, self.df.columns, cidx)
 
-        # Restore cursor position on the moved row
-        self.move_cursor(row=swap_idx, column=col_idx)
+            # 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)
 
-        # Swap rows in the dataframe
-        ridx = int(row_key.value)  # 0-based
-        swap_ridx = int(swap_key.value)  # 0-based
-        first, second = sorted([ridx, swap_ridx])
+            # 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 :]
 
-        self.df = pl.concat(
-            [
-                self.df.slice(0, first),
-                self.df.slice(second, 1),
-                self.df.slice(first + 1, second - first - 1),
-                self.df.slice(first, 1),
-                self.df.slice(second + 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)
 
-        # self.notify(f"Moved row [$success]{row_key.value}[/] {direction}", title="Move")
+            # Recreate table for display
+            self.setup_table()
 
-    # Sort
-    def _sort_by_column(self, descending: bool = False) -> None:
-        """Sort by the currently selected column.
+            # Move cursor to the new column
+            self.move_cursor(column=cidx + 1)
 
-        Supports multi-column sorting:
-        - First press on a column: sort by that column only
-        - Subsequent presses on other columns: add to sort order
+            self.notify(f"Added link column [$success]{new_col_name}[/]. Use Ctrl/Cmd click to open.", title="Add Link")
 
-        Args:
-            descending: If True, sort in descending order. If False, ascending order.
-        """
-        col_name = self.cursor_col_name
+        except Exception as e:
+            self.notify(f"Error adding link column [$error]{new_col_name}[/]", title="Add Link", severity="error")
+            self.log(f"Error adding link column: {str(e)}")
+
+    def do_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
+        col_name = self.cursor_col_name
+        col_key = self.cursor_col_key
 
-        # Check if this column is already in the sort keys
-        old_desc = self.sorted_columns.get(col_name)
+        col_names_to_remove = []
+        col_keys_to_remove = []
 
-        # Add to history
-        self._add_history(f"Sorted on column [$success]{col_name}[/]")
-        if old_desc is None:
-            # Add new column to sort
-            self.sorted_columns[col_name] = descending
-        elif old_desc == descending:
-            # Same direction - remove from sort
-            del self.sorted_columns[col_name]
-        else:
-            # Move to end of sort order
-            del self.sorted_columns[col_name]
-            self.sorted_columns[col_name] = descending
+        # 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)
 
-        # Apply multi-column sort
-        if sort_cols := list(self.sorted_columns.keys()):
-            descending_flags = list(self.sorted_columns.values())
-            df_sorted = self.df.with_row_index(RIDX).sort(sort_cols, descending=descending_flags, nulls_last=True)
+            message = f"Removed column [$success]{col_name}[/] and all columns before"
+
+        # 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:
-            # No sort columns - restore original order
-            df_sorted = self.df.with_row_index(RIDX)
+            col_names_to_remove.append(col_name)
+            col_keys_to_remove.append(col_key)
+            message = f"Removed column [$success]{col_name}[/]"
 
-        # Updated selected_rows and visible_rows to match new order
-        old_row_indices = df_sorted[RIDX].to_list()
-        self.selected_rows = [self.selected_rows[i] for i in old_row_indices]
-        self.visible_rows = [self.visible_rows[i] for i in old_row_indices]
+        # Add to history
+        self.add_history(message, dirty=True)
 
-        # Update the dataframe
-        self.df = df_sorted.drop(RIDX)
+        # Remove the columns from the table display using the column names as keys
+        for ck in col_keys_to_remove:
+            self.remove_column(ck)
 
-        # Recreate table for display
-        self._setup_table()
+        # 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)
 
-        # Restore cursor position on the sorted column
-        self.move_cursor(column=col_idx, row=0)
+        # Remove from sorted columns if present
+        for col_name in col_names_to_remove:
+            if col_name in self.sorted_columns:
+                del self.sorted_columns[col_name]
 
-    # Edit
-    def _edit_cell(self, ridx: int = None, cidx: int = None) -> None:
-        """Open modal to edit the selected cell."""
-        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]
+        # 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]
 
-        # Add to history
-        self._add_history(f"Edited cell [$success]({ridx + 1}, {col_name})[/]")
+        # Remove from dataframe
+        self.df = self.df.drop(col_names_to_remove)
 
-        # Push the edit modal screen
-        self.app.push_screen(
-            EditCellScreen(ridx, cidx, self.df),
-            callback=self._do_edit_cell,
-        )
+        self.notify(message, title="Delete")
 
-    def _do_edit_cell(self, result) -> None:
-        """Handle result from EditCellScreen."""
-        if result is None:
-            return
+    def do_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
 
-        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_idx = self.cursor_column
+        new_col_name = f"{col_name}_copy"
 
-        col_name = self.df.columns[cidx]
+        # Add to history
+        self.add_history(f"Duplicated column [$success]{col_name}[/]", dirty=True)
 
-        # Update the cell in the dataframe
-        try:
-            self.df = self.df.with_columns(
-                pl.when(pl.arange(0, len(self.df)) == ridx)
-                .then(pl.lit(new_value))
-                .otherwise(pl.col(col_name))
-                .alias(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 :]
 
-            # Update the display
-            cell_value = self.df.item(ridx, cidx)
-            if cell_value is None:
-                cell_value = NULL_DISPLAY
-            dtype = self.df.dtypes[cidx]
-            dc = DtypeConfig(dtype)
-            formatted_value = Text(str(cell_value), style=dc.style, justify=dc.justify)
+        # 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)
+        )
 
-            # string as keys
-            row_key = str(ridx)
-            col_key = col_name
-            self.update_cell(row_key, col_key, formatted_value, update_width=True)
+        # 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
 
-            # self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit")
-        except Exception as e:
-            self.notify("Error updating cell", title="Edit", severity="error")
-            self.log(f"Error updating cell: {str(e)}")
+        # Recreate table for display
+        self.setup_table()
 
-    def _edit_column(self) -> None:
-        """Open modal to edit the entire column with an expression."""
-        cidx = self.cursor_col_idx
+        # Move cursor to the new duplicated column
+        self.move_cursor(column=col_idx + 1)
 
-        # Push the edit column modal screen
-        self.app.push_screen(
-            EditColumnScreen(cidx, self.df),
-            callback=self._do_edit_column,
-        )
+        # self.notify(f"Duplicated column [$accent]{col_name}[/] as [$success]{new_col_name}[/]", title="Duplicate")
 
-    def _do_edit_column(self, result) -> None:
-        """Edit a column."""
-        if result is None:
-            return
-        term, cidx = result
+    def do_delete_row(self, more: str = None) -> None:
+        """Delete rows from the table and dataframe.
 
-        col_name = self.df.columns[cidx]
+        Supports deleting multiple selected rows. If no rows are selected, deletes the row at the cursor.
+        """
+        old_count = len(self.df)
+        predicates = [True] * len(self.df)
 
-        # Null case
-        if term is None or term == NULL:
-            expr = pl.lit(None)
+        # Delete all selected rows
+        if selected_count := self.selected_rows.count(True):
+            history_desc = f"Deleted {selected_count} selected row(s)"
 
-        # 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
+            for ridx, selected in enumerate(self.selected_rows):
+                if selected:
+                    predicates[ridx] = False
 
-        # Otherwise, treat term as a literal value
+        # 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:
-            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))
+            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(f"Edited column [$accent]{col_name}[/] with expression")
+        self.add_history(history_desc, dirty=True)
 
+        # Apply the filter to remove rows
         try:
-            # Apply the expression to the column
-            self.df = self.df.with_columns(expr.alias(col_name))
+            df = self.df.with_row_index(RIDX).filter(predicates)
         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)}")
+            self.notify(f"Error deleting row(s): {e}", title="Delete", severity="error")
+            self.histories.pop()  # Remove last history entry
             return
 
-        # Recreate table for display
-        self._setup_table()
-
-        # self.notify(f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]", title="Edit")
-
-    def _rename_column(self) -> None:
-        """Open modal to rename the selected column."""
-        col_name = self.cursor_col_name
-        col_idx = self.cursor_column
-
-        # Push the rename column modal screen
-        self.app.push_screen(
-            RenameColumnScreen(col_idx, col_name, self.df.columns),
-            callback=self._do_rename_column,
-        )
+        self.df = df.drop(RIDX)
 
-    def _do_rename_column(self, result) -> None:
-        """Handle result from RenameColumnScreen."""
-        if result is None:
-            return
+        # Update selected and visible rows tracking
+        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]
 
-        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
+        # Clear all matches since row indices have changed
+        self.matches = defaultdict(set)
 
-        # Add to history
-        self._add_history(f"Renamed column [$accent]{col_name}[/] to [$success]{new_name}[/]")
+        # Recreate table for display
+        self.setup_table()
 
-        # Rename the column in the dataframe
-        self.df = self.df.rename({col_name: new_name})
+        deleted_count = old_count - len(self.df)
+        if deleted_count > 0:
+            self.notify(f"Deleted [$accent]{deleted_count}[/] row(s)", title="Delete")
 
-        # 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)
+    def do_duplicate_row(self) -> None:
+        """Duplicate the currently selected row, inserting it right after the current row."""
+        ridx = self.cursor_row_idx
 
-        # 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)
+        # Get the row to duplicate
+        row_to_duplicate = self.df.slice(ridx, 1)
 
-        # Recreate table for display
-        self._setup_table()
+        # Add to history
+        self.add_history(f"Duplicated row [$success]{ridx + 1}[/]", dirty=True)
 
-        # Move cursor to the renamed column
-        self.move_cursor(column=col_idx)
+        # Concatenate: rows before + duplicated row + rows after
+        df_before = self.df.slice(0, ridx + 1)
+        df_after = self.df.slice(ridx + 1)
 
-        # self.notify(f"Renamed column [$success]{col_name}[/] to [$success]{new_name}[/]", title="Column")
+        # Combine the parts
+        self.df = pl.concat([df_before, row_to_duplicate, df_after])
 
-    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
+        # 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
 
-        # Add to history
-        self._add_history(f"Cleared cell [$success]({ridx + 1}, {col_name})[/]")
+        # 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
 
-        # 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)
-            )
+        # Recreate table for display
+        self.setup_table()
 
-            # Update the display
-            dtype = self.df.dtypes[cidx]
-            dc = DtypeConfig(dtype)
-            formatted_value = Text(NULL_DISPLAY, style=dc.style, justify=dc.justify)
+        # Move cursor to the new duplicated row
+        self.move_cursor(row=ridx + 1)
 
-            self.update_cell(row_key, col_key, formatted_value)
+        # self.notify(f"Duplicated row [$success]{ridx + 1}[/]", title="Row")
 
-            # 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
+    def do_move_column(self, direction: str) -> None:
+        """Move the current column left or right.
 
-    def _add_column(self, col_name: str = None, col_value: pl.Expr = None) -> None:
-        """Add acolumn after the current column."""
+        Args:
+            direction: "left" to move left, "right" to move right.
+        """
+        row_idx, col_idx = self.cursor_coordinate
+        col_key = self.cursor_col_key
+        col_name = col_key.value
         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:
-            new_name = col_name
+        # Validate move is possible
+        if direction == "left":
+            if col_idx <= 0:
+                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.notify("Cannot move column right", title="Move", severity="warning")
+                return
+            swap_idx = col_idx + 1
+
+        # 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"Added column [$success]{new_name}[/] after column {cidx + 1}")
+        self.add_history(
+            f"Moved column [$success]{col_name}[/] {direction} (swapped with [$success]{swap_name}[/])", dirty=True
+        )
 
-        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)
+        # Swap columns in the table's internal column locations
+        self.check_idle()
 
-            # 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 :]
+        (
+            self._column_locations[col_key],
+            self._column_locations[swap_key],
+        ) = (
+            self._column_locations.get(swap_key),
+            self._column_locations.get(col_key),
+        )
 
-            # 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)
+        self._update_count += 1
+        self.refresh()
 
-            # Recreate table for display
-            self._setup_table()
+        # Restore cursor position on the moved column
+        self.move_cursor(row=row_idx, column=swap_idx)
 
-            # Move cursor to the new column
-            self.move_cursor(column=cidx + 1)
+        # Update the dataframe column order
+        cols = list(self.df.columns)
+        cols[cidx], cols[swap_cidx] = cols[swap_cidx], cols[cidx]
+        self.df = self.df.select(cols)
 
-            # 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
+        # self.notify(f"Moved column [$success]{col_name}[/] {direction}", title="Move")
 
-    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_move_row(self, direction: str) -> None:
+        """Move the current row up or down.
 
-    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:
+        Args:
+            direction: "up" to move up, "down" to move down.
+        """
+        row_idx, col_idx = self.cursor_coordinate
+
+        # Validate move is possible
+        if direction == "up":
+            if row_idx <= 0:
+                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.notify("Cannot move row down", title="Move", severity="warning")
+                return
+            swap_idx = row_idx + 1
+        else:
+            # Invalid direction
             return
 
-        cidx, col_name, expr = result
+        row_key = self.coordinate_to_cell_key((row_idx, 0)).row_key
+        swap_key = self.coordinate_to_cell_key((swap_idx, 0)).row_key
 
         # Add to history
-        self._add_history(f"Added column [$success]{col_name}[/] with expression {expr}.")
+        self.add_history(
+            f"Moved row [$success]{row_key.value}[/] {direction} (swapped with row [$success]{swap_key.value}[/])",
+            dirty=True,
+        )
 
-        try:
-            # Create the column
-            new_col = expr.alias(col_name)
+        # Swap rows in the table's internal row locations
+        self.check_idle()
 
-            # 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 :]
+        (
+            self._row_locations[row_key],
+            self._row_locations[swap_key],
+        ) = (
+            self._row_locations.get(swap_key),
+            self._row_locations.get(row_key),
+        )
 
-            # Build the new dataframe with columns reordered
-            select_cols = cols_before + [col_name] + cols_after
-            self.df = self.df.with_row_index(RIDX).with_columns(new_col).select(select_cols)
+        self._update_count += 1
+        self.refresh()
 
-            # Recreate table for display
-            self._setup_table()
+        # Restore cursor position on the moved row
+        self.move_cursor(row=swap_idx, column=col_idx)
 
-            # Move cursor to the new column
-            self.move_cursor(column=cidx + 1)
+        # Swap rows in the dataframe
+        ridx = int(row_key.value)  # 0-based
+        swap_ridx = int(swap_key.value)  # 0-based
+        first, second = sorted([ridx, swap_ridx])
 
-            # 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 `{col_name}`: {str(e)}")
+        self.df = pl.concat(
+            [
+                self.df.slice(0, first),
+                self.df.slice(second, 1),
+                self.df.slice(first + 1, second - first - 1),
+                self.df.slice(first, 1),
+                self.df.slice(second + 1),
+            ]
+        )
+
+        # self.notify(f"Moved row [$success]{row_key.value}[/] {direction}", title="Move")
 
-    # Type Casting
-    def _cast_column_dtype(self, dtype: str) -> None:
+    # Type casting
+    def do_cast_column_dtype(self, dtype: str) -> None:
         """Cast the current column to a different data type.
 
         Args:
@@ -2180,8 +2256,9 @@ class DataFrameTable(DataTable):
             return  # No change needed
 
         # Add to history
-        self._add_history(
-            f"Cast column [$accent]{col_name}[/] from [$success]{current_dtype}[/] to [$success]{target_dtype}[/]"
+        self.add_history(
+            f"Cast column [$accent]{col_name}[/] from [$success]{current_dtype}[/] to [$success]{target_dtype}[/]",
+            dirty=True,
         )
 
         try:
@@ -2189,7 +2266,7 @@ class DataFrameTable(DataTable):
             self.df = self.df.with_columns(pl.col(col_name).cast(target_dtype))
 
             # Recreate table for display
-            self._setup_table()
+            self.setup_table()
 
             self.notify(f"Cast column [$accent]{col_name}[/] to [$success]{target_dtype}[/]", title="Cast")
         except Exception as e:
@@ -2201,16 +2278,16 @@ class DataFrameTable(DataTable):
             self.log(f"Error casting column `{col_name}`: {str(e)}")
 
     # Search
-    def _search_cursor_value(self) -> None:
+    def do_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))
+        self.search((term, cidx, False, True))
 
-    def _search_expr(self) -> None:
+    def do_search_expr(self) -> None:
         """Search by expression."""
         cidx = self.cursor_col_idx
 
@@ -2220,10 +2297,10 @@ class DataFrameTable(DataTable):
         # Push the search modal screen
         self.app.push_screen(
             SearchScreen("Search", term, self.df, cidx),
-            callback=self._do_search,
+            callback=self.search,
         )
 
-    def _do_search(self, result) -> None:
+    def search(self, result) -> None:
         """Search for a term."""
         if result is None:
             return
@@ -2291,7 +2368,7 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self._add_history(f"Searched [$accent]{term}[/] in column [$success]{col_name}[/]")
+        self.add_history(f"Searched [$accent]{term}[/] in column [$success]{col_name}[/]")
 
         # Update selected rows to include new matches
         for m in matches:
@@ -2301,10 +2378,10 @@ class DataFrameTable(DataTable):
         self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Search")
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
     # Find
-    def _find_matches(
+    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.
@@ -2366,7 +2443,7 @@ class DataFrameTable(DataTable):
 
         return matches
 
-    def _find_cursor_value(self, scope="column") -> None:
+    def do_find_cursor_value(self, scope="column") -> None:
         """Find by cursor value.
 
         Args:
@@ -2377,11 +2454,11 @@ class DataFrameTable(DataTable):
 
         if scope == "column":
             cidx = self.cursor_col_idx
-            self._do_find((term, cidx, False, True))
+            self.find((term, cidx, False, True))
         else:
-            self._do_find_global((term, None, False, True))
+            self.find_global((term, None, False, True))
 
-    def _find_expr(self, scope="column") -> None:
+    def do_find_expr(self, scope="column") -> None:
         """Open screen to find by expression.
 
         Args:
@@ -2394,10 +2471,10 @@ class DataFrameTable(DataTable):
         # 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,
+            callback=self.find if scope == "column" else self.find_global,
         )
 
-    def _do_find(self, result) -> None:
+    def find(self, result) -> None:
         """Find a term in current column."""
         if result is None:
             return
@@ -2406,7 +2483,7 @@ class DataFrameTable(DataTable):
         col_name = self.df.columns[cidx]
 
         try:
-            matches = self._find_matches(term, cidx, match_nocase, match_whole)
+            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)}")
@@ -2421,7 +2498,7 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self._add_history(f"Found [$accent]{term}[/] in column [$success]{col_name}[/]")
+        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())
@@ -2431,16 +2508,16 @@ class DataFrameTable(DataTable):
         self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Find")
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
-    def _do_find_global(self, result) -> None:
+    def 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)
+            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)}")
@@ -2455,7 +2532,7 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self._add_history(f"Found [$success]{term}[/] across all columns")
+        self.add_history(f"Found [$success]{term}[/] across all columns")
 
         # Add to matches and count total
         match_count = sum(len(col_idxs) for col_idxs in matches.values())
@@ -2467,9 +2544,9 @@ class DataFrameTable(DataTable):
         )
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
-    def _next_match(self) -> None:
+    def do_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")
@@ -2491,7 +2568,7 @@ class DataFrameTable(DataTable):
         first_ridx, first_cidx = ordered_matches[0]
         self.move_cursor_to(first_ridx, first_cidx)
 
-    def _previous_match(self) -> None:
+    def do_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")
@@ -2519,7 +2596,7 @@ class DataFrameTable(DataTable):
         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:
+    def do_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")
@@ -2541,7 +2618,7 @@ class DataFrameTable(DataTable):
         first_ridx = selected_row_indices[0]
         self.move_cursor_to(first_ridx, self.cursor_col_idx)
 
-    def _previous_selected_row(self) -> None:
+    def do_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")
@@ -2564,31 +2641,31 @@ class DataFrameTable(DataTable):
         self.move_cursor_to(last_ridx, self.cursor_col_idx)
 
     # Replace
-    def _replace(self) -> None:
+    def do_replace(self) -> None:
         """Open replace screen for current column."""
         # Push the replace modal screen
         self.app.push_screen(
             FindReplaceScreen(self, title="Find and Replace in Current Column"),
-            callback=self._do_replace,
+            callback=self.replace,
         )
 
-    def _do_replace(self, result) -> None:
+    def replace(self, result) -> None:
         """Handle replace in current column."""
-        self._handle_replace(result, self.cursor_col_idx)
+        self.handle_replace(result, self.cursor_col_idx)
 
-    def _replace_global(self) -> None:
+    def do_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,
+            callback=self.replace_global,
         )
 
-    def _do_replace_global(self, result) -> None:
+    def replace_global(self, result) -> None:
         """Handle replace across all columns."""
-        self._handle_replace(result, None)
+        self.handle_replace(result, None)
 
-    def _handle_replace(self, result, cidx) -> None:
+    def handle_replace(self, result, cidx) -> None:
         """Handle replace result from ReplaceScreen.
 
         Args:
@@ -2605,14 +2682,14 @@ class DataFrameTable(DataTable):
             col_name = self.df.columns[cidx]
 
         # Find all matches
-        matches = self._find_matches(term_find, cidx, match_nocase, match_whole)
+        matches = self.find_matches(term_find, cidx, match_nocase, match_whole)
 
         if not matches:
             self.notify(f"No matches found for [$warning]{term_find}[/]", title="Replace", severity="warning")
             return
 
         # Add to history
-        self._add_history(
+        self.add_history(
             f"Replaced [$accent]{term_find}[/] with [$success]{term_replace}[/] in column [$accent]{col_name}[/]"
         )
 
@@ -2620,21 +2697,22 @@ class DataFrameTable(DataTable):
         self.matches = {ridx: col_idxs.copy() for ridx, col_idxs in matches.items()}
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
         # Store state for interactive replacement using dataclass
-        self._replace_state = ReplaceState(
+        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(list(self.matches.keys())),
-            cols_per_row=[sorted(list(self.matches[ridx])) for ridx in sorted(self.matches.keys())],
+            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=len(self.matches),
+            total_occurrence=sum(len(col_idxs) for col_idxs in self.matches.values()),
             replaced_occurrence=0,
             skipped_occurrence=0,
             done=False,
@@ -2643,10 +2721,10 @@ class DataFrameTable(DataTable):
         try:
             if replace_all:
                 # Replace all occurrences
-                self._do_replace_all(term_find, term_replace)
+                self.replace_all(term_find, term_replace)
             else:
                 # Replace with confirmation for each occurrence
-                self._do_replace_interactive(term_find, term_replace)
+                self.replace_interactive(term_find, term_replace)
 
         except Exception as e:
             self.notify(
@@ -2656,59 +2734,75 @@ class DataFrameTable(DataTable):
             )
             self.log(f"Error replacing `{term_find}` with `{term_replace}`: {str(e)}")
 
-    def _do_replace_all(self, term_find: str, term_replace: str) -> None:
+    def replace_all(self, term_find: str, term_replace: str) -> None:
         """Replace all occurrences."""
-        state = self._replace_state
+        state = self.replace_state
         self.app.push_screen(
             ConfirmScreen(
                 "Replace All",
-                label=f"Replace [$accent]{term_find}[/] with [$success]{term_replace}[/] for all [$accent]{state.total_occurrence}[/] occurrences?",
+                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,
+            callback=self.handle_replace_all_confirmation,
         )
 
-    def _handle_replace_all_confirmation(self, result) -> None:
+    def handle_replace_all_confirmation(self, result) -> None:
         """Handle user's confirmation for replace all."""
         if result is None:
             return
 
-        state = self._replace_state
+        state = self.replace_state
         rows = state.rows
         cols_per_row = state.cols_per_row
 
-        # Replace in each matched row/column
-        for ridx, col_idxs in zip(rows, cols_per_row):
-            for cidx in col_idxs:
-                col_name = self.df.columns[cidx]
-                dtype = self.df.dtypes[cidx]
-
-                # 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)
-                    )
+        # 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)
 
-                state.replaced_occurrence += 1
+        # 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()
+        self.setup_table()
+
+        # Mark as dirty if any replacements were made
+        if state.replaced_occurrence > 0:
+            self.dirty = True
 
         col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
         self.notify(
@@ -2716,11 +2810,11 @@ class DataFrameTable(DataTable):
             title="Replace",
         )
 
-    def _do_replace_interactive(self, term_find: str, term_replace: str) -> None:
+    def 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()
+            self.show_next_replace_confirmation()
         except Exception as e:
             self.notify(
                 f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
@@ -2729,9 +2823,9 @@ class DataFrameTable(DataTable):
             )
             self.log(f"Error in interactive replace: {str(e)}")
 
-    def _show_next_replace_confirmation(self) -> None:
+    def show_next_replace_confirmation(self) -> None:
         """Show confirmation for next replacement."""
-        state = self._replace_state
+        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]
@@ -2739,6 +2833,10 @@ class DataFrameTable(DataTable):
             if state.skipped_occurrence > 0:
                 msg += f", [$warning]{state.skipped_occurrence}[/] skipped"
             self.notify(msg, title="Replace")
+
+            if state.replaced_occurrence > 0:
+                self.dirty = True
+
             return
 
         # Move cursor to next match
@@ -2753,12 +2851,12 @@ class DataFrameTable(DataTable):
 
         self.app.push_screen(
             ConfirmScreen("Replace", label=label, maybe="Skip"),
-            callback=self._handle_replace_confirmation,
+            callback=self.handle_replace_confirmation,
         )
 
-    def _handle_replace_confirmation(self, result) -> None:
+    def handle_replace_confirmation(self, result) -> None:
         """Handle user's confirmation response."""
-        state = self._replace_state
+        state = self.replace_state
         if state.done:
             return
 
@@ -2801,30 +2899,34 @@ class DataFrameTable(DataTable):
         # 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 not state.done:
+            # 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)
+            )
 
-        if state.current_rpos >= len(state.rows):
-            state.done = True
+            # 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
 
-        # Recreate table for display
-        self._setup_table()
+            if state.current_rpos >= len(state.rows):
+                state.done = True
 
         # Show next confirmation
-        self._show_next_replace_confirmation()
+        self.show_next_replace_confirmation()
 
     # Selection & Match
-    def _toggle_selections(self) -> None:
+    def do_toggle_selections(self) -> None:
         """Toggle selected rows highlighting on/off."""
         # Add to history
-        self._add_history("Toggled row selection")
+        self.add_history("Toggled row selection")
 
         if False in self.visible_rows:
             # Some rows are hidden - invert only selected visible rows and clear selections for hidden rows
@@ -2842,12 +2944,12 @@ class DataFrameTable(DataTable):
             self.notify(f"Toggled selection for [$accent]{new_selected_count}[/] rows", title="Toggle")
 
         # Recreate table for display
-        self._setup_table()
+        self.setup_table()
 
-    def _toggle_row_selection(self) -> None:
+    def do_toggle_row_selection(self) -> None:
         """Select/deselect current row."""
         # Add to history
-        self._add_history("Toggled row selection")
+        self.add_history("Toggled row selection")
 
         ridx = self.cursor_row_idx
         self.selected_rows[ridx] = not self.selected_rows[ridx]
@@ -2868,7 +2970,7 @@ class DataFrameTable(DataTable):
 
             self.update_cell(row_key, col_key, cell_text)
 
-    def _clear_selections_and_matches(self) -> None:
+    def do_clear_selections_and_matches(self) -> None:
         """Clear all selected rows and matches without removing them from the dataframe."""
         # Check if any selected rows or matches
         if not any(self.selected_rows) and not self.matches:
@@ -2880,19 +2982,19 @@ class DataFrameTable(DataTable):
         )
 
         # Add to history
-        self._add_history("Cleared all selected rows")
+        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.setup_table()
 
         self.notify(f"Cleared selections for [$accent]{row_count}[/] rows", title="Clear")
 
     # Filter & View
-    def _filter_rows(self) -> None:
+    def do_filter_rows(self) -> None:
         """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")
@@ -2903,7 +3005,7 @@ class DataFrameTable(DataTable):
         ]
 
         # Add to history
-        self._add_history("Filtered to selections and matches")
+        self.add_history("Filtered to selections and matches", dirty=True)
 
         # Apply filter to dataframe with row indices
         df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
@@ -2918,13 +3020,13 @@ class DataFrameTable(DataTable):
         self.df = df_filtered.drop(RIDX)
 
         # Recreate table for display
-        self._setup_table()
+        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:
+    def do_view_rows(self) -> None:
         """View rows.
 
         If there are selected rows or matches, view those rows.
@@ -2943,9 +3045,9 @@ class DataFrameTable(DataTable):
             ridx = self.cursor_row_idx
             term = str(self.df.item(ridx, cidx))
 
-        self._do_view_rows((term, cidx, False, True))
+        self.view_rows((term, cidx, False, True))
 
-    def _view_rows_expr(self) -> None:
+    def do_view_rows_expr(self) -> None:
         """Open the filter screen to enter an expression."""
         ridx = self.cursor_row_idx
         cidx = self.cursor_col_idx
@@ -2953,10 +3055,10 @@ class DataFrameTable(DataTable):
 
         self.app.push_screen(
             FilterScreen(self.df, cidx, cursor_value),
-            callback=self._do_view_rows,
+            callback=self.view_rows,
         )
 
-    def _do_view_rows(self, result) -> None:
+    def 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
@@ -3006,13 +3108,18 @@ class DataFrameTable(DataTable):
         if False in self.visible_rows:
             lf = lf.filter(self.visible_rows)
 
+        if isinstance(expr, (list, pl.Series)):
+            expr_str = str(list(expr)[:10]) + ("..." if len(expr) > 10 else "")
+        else:
+            expr_str = str(expr)
+
         # 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)}")
+            self.notify(f"Error applying filter [$error]{expr_str}[/]", title="Filter", severity="error")
+            self.log(f"Error applying filter `{expr_str}`: {str(e)}")
             return
 
         matched_count = len(df_filtered)
@@ -3021,7 +3128,7 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self._add_history(f"Filtered by expression [$success]{expr}[/]")
+        self.add_history(f"Filtered by expression [$success]{expr_str}[/]", dirty=True)
 
         # Mark unfiltered rows as invisible
         filtered_row_indices = set(df_filtered[RIDX].to_list())
@@ -3031,12 +3138,12 @@ class DataFrameTable(DataTable):
                     self.visible_rows[ridx] = False
 
         # Recreate table for display
-        self._setup_table()
+        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:
+    def do_copy_to_clipboard(self, content: str, message: str) -> None:
         """Copy content to clipboard using pbcopy (macOS) or xclip (Linux).
 
         Args:
@@ -3059,54 +3166,64 @@ class DataFrameTable(DataTable):
         except FileNotFoundError:
             self.notify("Error copying to clipboard", title="Clipboard", severity="error")
 
-    def _save_to_file(self) -> None:
+    def do_save_to_file(
+        self, title: str = "Save to File", all_tabs: bool | None = None, task_after_save: str | None = None
+    ) -> None:
         """Open screen to save file."""
-        self.app.push_screen(SaveFileScreen(self.filename), callback=self._do_save_file)
+        self._task_after_save = task_after_save
+
+        multi_tab = len(self.app.tabs) > 1
+        filename = (
+            "all-tabs.xlsx"
+            if all_tabs or (all_tabs is None and multi_tab)
+            else str(Path(self.filename).with_stem(self.tabname))
+        )
+        self.app.push_screen(
+            SaveFileScreen(filename, title=title, all_tabs=all_tabs, multi_tab=multi_tab),
+            callback=self.save_to_file,
+        )
 
-    def _do_save_file(self, filename: str | None, all_tabs: bool = False) -> None:
+    def save_to_file(self, result) -> None:
         """Handle result from SaveFileScreen."""
-        if filename is None:
+        if result is None:
             return
-        filepath = Path(filename)
-        ext = filepath.suffix.lower()
+        filename, all_tabs = result
 
         # Whether to save all tabs (for Excel files)
         self._all_tabs = all_tabs
 
         # Check if file exists
-        if filepath.exists():
+        if Path(filename).exists():
             self._pending_filename = filename
             self.app.push_screen(
                 ConfirmScreen("File already exists. Overwrite?"),
-                callback=self._on_overwrite_screen,
+                callback=self.confirm_overwrite,
             )
-        elif ext in (".xlsx", ".xls"):
-            self._do_save_excel(filename)
         else:
-            self._do_save(filename)
+            self.save_file(filename)
 
-    def _on_overwrite_screen(self, should_overwrite: bool) -> None:
+    def confirm_overwrite(self, should_overwrite: bool) -> None:
         """Handle result from ConfirmScreen."""
         if should_overwrite:
-            self._do_save(self._pending_filename)
+            self.save_file(self._pending_filename)
         else:
             # Go back to SaveFileScreen to allow user to enter a different name
             self.app.push_screen(
                 SaveFileScreen(self._pending_filename),
-                callback=self._do_save_file,
+                callback=self.save_to_file,
             )
 
-    def _do_save(self, filename: str) -> None:
+    def save_file(self, filename: str) -> None:
         """Actually save the dataframe to a file."""
         filepath = Path(filename)
         ext = filepath.suffix.lower()
 
         # Add to history
-        self._add_history(f"Saved dataframe to [$success]{filename}[/]")
+        self.add_history(f"Saved dataframe to [$success]{filename}[/]")
 
         try:
             if ext in (".xlsx", ".xls"):
-                self._do_save_excel(filename)
+                self.save_excel(filename)
             elif ext in (".tsv", ".tab"):
                 self.df.write_csv(filename, separator="\t")
             elif ext == ".json":
@@ -3118,14 +3235,31 @@ class DataFrameTable(DataTable):
 
             self.dataframe = self.df  # Update original dataframe
             self.filename = filename  # Update current filename
-            if not self._all_tabs:
-                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")
+
+            # Reset dirty flag after save
+            if self._all_tabs:
+                tabs: dict[TabPane, DataFrameTable] = self.app.tabs
+                for table in tabs.values():
+                    table.dirty = False
+            else:
+                self.dirty = False
+
+            if self._task_after_save == "close_tab":
+                self.app.do_close_tab()
+            elif self._task_after_save == "quit_app":
+                self.app.exit()
+
+            # From ConfirmScreen callback, so notify accordingly
+            if self._all_tabs:
+                self.notify(f"Saved all tabs to [$success]{filename}[/]", title="Save to File")
+            else:
+                self.notify(f"Saved current tab to [$success]{filename}[/]", title="Save to File")
+
         except Exception as e:
-            self.notify(f"Error saving [$error]{filename}[/]", title="Save", severity="error")
+            self.notify(f"Error saving [$error]{filename}[/]", title="Save to File", severity="error")
             self.log(f"Error saving file `{filename}`: {str(e)}")
 
-    def _do_save_excel(self, filename: str) -> None:
+    def save_excel(self, filename: str) -> None:
         """Save to an Excel file."""
         import xlsxwriter
 
@@ -3136,75 +3270,97 @@ class DataFrameTable(DataTable):
             # Multiple tabs - use xlsxwriter to create multiple sheets
             with xlsxwriter.Workbook(filename) as wb:
                 tabs: dict[TabPane, DataFrameTable] = self.app.tabs
-                for tab, table in tabs.items():
-                    worksheet = wb.add_worksheet(tab.name)
+                for table in tabs.values():
+                    worksheet = wb.add_worksheet(table.tabname)
                     table.df.write_excel(workbook=wb, worksheet=worksheet)
 
-        # From ConfirmScreen callback, so notify accordingly
-        if self._all_tabs is True:
-            self.notify(f"Saved all tabs to [$success]{filename}[/]", title="Save")
-        else:
-            self.notify(
-                f"Saved current tab with [$accent]{len(self.df)}[/] rows to [$success]{filename}[/]", title="Save"
-            )
-
     # SQL Interface
-    def _simple_sql(self) -> None:
+    def do_simple_sql(self) -> None:
         """Open the SQL interface screen."""
         self.app.push_screen(
             SimpleSqlScreen(self),
-            callback=self._do_simple_sql,
+            callback=self.simple_sql,
         )
 
-    def _do_simple_sql(self, result) -> None:
+    def simple_sql(self, result) -> None:
         """Handle SQL result result from SimpleSqlScreen."""
         if result is None:
             return
-        columns, where = result
+        columns, where, view = result
 
         sql = f"SELECT {columns} FROM self"
         if where:
             sql += f" WHERE {where}"
 
-        self._do_sql(sql)
+        self.run_sql(sql, view)
 
-    def _advanced_sql(self) -> None:
+    def do_advanced_sql(self) -> None:
         """Open the advanced SQL interface screen."""
         self.app.push_screen(
             AdvancedSqlScreen(self),
-            callback=self._do_advanced_sql,
+            callback=self.advanced_sql,
         )
 
-    def _do_advanced_sql(self, result) -> None:
+    def advanced_sql(self, result) -> None:
         """Handle SQL result result from AdvancedSqlScreen."""
         if result is None:
             return
+        sql, view = result
 
-        self._do_sql(result)
+        self.run_sql(sql, view)
 
-    def _do_sql(self, sql: str) -> None:
+    def run_sql(self, sql: str, view: bool = True) -> 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}[/]")
+
+        import re
+
+        RE_FROM_SELF = re.compile(r"\bfrom\s+self\b", re.IGNORECASE)
+
+        sql = RE_FROM_SELF.sub(f", `{RIDX}` FROM self", sql)
 
         # Execute the SQL query
         try:
-            self.df = self.df.sql(sql)
+            lf = self.df.lazy().with_row_index(RIDX)
+            if False in self.visible_rows:
+                lf = lf.filter(self.visible_rows)
+
+            df_filtered = lf.sql(sql).collect()
+
+            if not len(df_filtered):
+                self.notify(
+                    f"SQL query returned no results for [$warning]{sql}[/]", title="SQL Query", severity="warning"
+                )
+                return
+
+            # Add to history
+            self.add_history(f"SQL Query:\n[$accent]{sql}[/]", dirty=not view)
+
+            if view:
+                # Just view - do not modify the dataframe
+                filtered_row_indices = set(df_filtered[RIDX].to_list())
+                if filtered_row_indices:
+                    self.visible_rows = [ridx in filtered_row_indices for ridx in range(len(self.visible_rows))]
+
+                filtered_col_names = set(df_filtered.columns)
+                if filtered_col_names:
+                    self.hidden_columns = {
+                        col_name for col_name in self.df.columns if col_name not in filtered_col_names
+                    }
+            else:  # filter - modify the dataframe
+                self.df = df_filtered.drop(RIDX)
+                self.visible_rows = [True] * len(self.df)
+                self.hidden_columns.clear()
         except Exception as e:
-            self.notify(f"Error executing SQL query [$error]{sql}[/]", title="SQL Query", severity="error")
+            self.notify(f"Error executing SQL query [$error]{sql}[/]", title="SQL Query", severity="error", timeout=10)
             self.log(f"Error executing SQL query `{sql}`: {str(e)}")
             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.setup_table()
 
         self.notify(
             f"SQL query executed successfully. Now showing [$accent]{len(self.df)}[/] rows and [$accent]{len(self.df.columns)}[/] columns.",