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

dataframe_textual/data_frame_table.py

@@ -10,7 +10,6 @@ from typing import Any
 
 import polars as pl
 from rich.text import Text, TextType
-from textual import work
 from textual._two_way_dict import TwoWayDict
 from textual.coordinate import Coordinate
 from textual.events import Click
@@ -32,7 +31,7 @@ from .common import (
     CURSOR_TYPES,
     NULL,
     NULL_DISPLAY,
-    RIDX,
+    RID,
     SUBSCRIPT_DIGITS,
     SUPPORTED_FORMATS,
     DtypeConfig,
@@ -40,7 +39,6 @@ from .common import (
     get_next_item,
     parse_placeholders,
     round_to_nearest_hundreds,
-    sleep_async,
     tentative_expr,
     validate_expr,
 )
@@ -79,16 +77,16 @@ class History:
 
     description: str
     df: pl.DataFrame
+    df_view: pl.DataFrame | None
     filename: str
     loaded_rows: int
-    sorted_columns: dict[str, bool]
     hidden_columns: set[str]
-    selected_rows: list[bool]
-    visible_rows: list[bool]
+    selected_rows: set[int]
+    sorted_columns: dict[str, bool]  # col_name -> descending
     fixed_rows: int
     fixed_columns: int
     cursor_coordinate: Coordinate
-    matches: dict[int, set[int]]
+    matches: dict[int, set[str]]  # RID -> set of col names
     dirty: bool = False  # Whether this history state has unsaved changes
 
 
@@ -155,7 +153,7 @@ class DataFrameTable(DataTable):
         - *(Multi-column sort supported)*
 
         ## ✅ Row Selection
-        - **\\\\** - ✅ Select rows in current column using cursor value
+        - **\\\\** - ✅ Select rows with cell matches or those matching cursor value in current column
         - **|** - ✅ Select rows with expression
         - **'** - ✅ Select/deselect current row
         - **t** - 💡 Toggle row selection (invert all)
@@ -177,8 +175,8 @@ class DataFrameTable(DataTable):
 
         ## 👁️ View & Filter
         - **"** - 📍 Filter selected rows (removes others)
-        - **v** - 👁️ View rows that are selected or contain matching cells (hide others)
-        - **V** - 🔧 View rows by expression (hides others)
+        - **v** - 👁️ View selected rows (hides others)
+        - **V** - 🔧 View selected rows matching expression (hides others)
 
         ## 🔍 SQL Interface
         - **l** - 💬 Open simple SQL interface (select columns & where clause)
@@ -221,10 +219,8 @@ class DataFrameTable(DataTable):
         # Navigation
         ("g", "jump_top", "Jump to top"),
         ("G", "jump_bottom", "Jump to bottom"),
-        ("ctrl+f", "forward_page", "Page down"),
-        ("ctrl+b", "backward_page", "Page up"),
-        ("pageup", "page_up", "Page up"),
-        ("pagedown", "page_down", "Page down"),
+        ("pageup,ctrl+b", "page_up", "Page up"),
+        ("pagedown,ctrl+f", "page_down", "Page down"),
         # Undo/Redo/Reset
         ("u", "undo", "Undo"),
         ("U", "redo", "Redo"),
@@ -237,6 +233,7 @@ class DataFrameTable(DataTable):
         ("z", "freeze_row_column", "Freeze rows/columns"),
         ("comma", "show_thousand_separator", "Toggle thousand separator"),  # `,`
         ("underscore", "expand_column", "Expand column to full width"),  # `_`
+        ("circumflex_accent", "toggle_rid", "Toggle internal row index"),  # `^`
         # Copy
         ("c", "copy_cell", "Copy cell to clipboard"),
         ("ctrl+c", "copy_column", "Copy column to clipboard"),
@@ -254,11 +251,11 @@ class DataFrameTable(DataTable):
         ("left_square_bracket", "sort_ascending", "Sort ascending"),  # `[`
         ("right_square_bracket", "sort_descending", "Sort descending"),  # `]`
         # View & Filter
-        ("v", "view_rows", "View rows"),
-        ("V", "view_rows_expr", "View rows by expression"),
-        ("quotation_mark", "filter_rows", "Filter selected"),  # `"`
+        ("v", "view_rows", "View selected rows"),
+        ("V", "view_rows_expr", "View selected rows matching expression"),
+        ("quotation_mark", "filter_rows", "Filter selected rows"),  # `"`
         # Row Selection
-        ("backslash", "select_row_cursor_value", "Select rows with cursor value in current column"),  # `\`
+        ("backslash", "select_row", "Select rows with cell matches or those matching cursor value in current column"),  # `\`
         ("vertical_line", "select_row_expr", "Select rows with expression"),  # `|`
         ("right_curly_bracket", "next_selected_row", "Go to next selected row"),  # `}`
         ("left_curly_bracket", "previous_selected_row", "Go to previous selected row"),  # `{`
@@ -324,34 +321,40 @@ class DataFrameTable(DataTable):
         super().__init__(**kwargs)
 
         # DataFrame state
-        self.dataframe = df  # Original dataframe
-        self.df = df  # Internal/working dataframe
+        self.dataframe = df.lazy().with_row_index(RID).select(pl.exclude(RID), RID).collect()  # Original dataframe
+        self.df = self.dataframe  # Internal/working dataframe
         self.filename = filename or "untitled.csv"  # Current filename
         self.tabname = tabname or Path(filename).stem  # Tab name
+
+        # In view mode, this is the copy of self.df
+        self.df_view = None
+
         # Pagination & Loading
         self.BATCH_SIZE = max((self.app.size.height // 100 + 1) * 100, 100)
         self.loaded_rows = 0  # Track how many rows are currently loaded
         self.loaded_ranges: list[tuple[int, int]] = []  # List of (start, end) row indices that are loaded
 
         # State tracking (all 0-based indexing)
-        self.sorted_columns: dict[str, bool] = {}  # col_name -> descending
         self.hidden_columns: set[str] = set()  # Set of hidden column names
-        self.selected_rows: list[bool] = [False] * len(self.df)  # Track selected rows
-        self.visible_rows: list[bool] = [True] * len(self.df)  # Track visible rows (for filtering)
-        self.matches: dict[int, set[int]] = defaultdict(set)  # Track search matches: row_idx -> set of col_idx
+        self.selected_rows: set[int] = set()  # Track selected rows by RID
+        self.sorted_columns: dict[str, bool] = {}  # col_name -> descending
+        self.matches: dict[int, set[str]] = defaultdict(set)  # Track search matches: RID -> set of col_names
 
         # Freezing
         self.fixed_rows = 0  # Number of fixed rows
         self.fixed_columns = 0  # Number of fixed columns
 
         # History stack for undo
-        self.histories: deque[History] = deque()
-        # Current history state for redo
-        self.history: History = None
+        self.histories_undo: deque[History] = deque()
+        # History stack for redo
+        self.histories_redo: deque[History] = deque()
 
         # Whether to use thousand separator for numeric display
         self.thousand_separator = False
 
+        # Whether to show internal row index column
+        self.show_rid = False
+
     @property
     def cursor_key(self) -> CellKey:
         """Get the current cursor position as a CellKey.
@@ -418,22 +421,13 @@ class DataFrameTable(DataTable):
 
     @property
     def cursor_value(self) -> Any:
-        """Get the current cursor cell value.
+        """Get the current cursor cell value in the dataframe.
 
         Returns:
             Any: The value of the cell at the cursor position.
         """
         return self.df.item(self.cursor_row_idx, self.cursor_col_idx)
 
-    @property
-    def has_hidden_rows(self) -> bool:
-        """Check if there are any hidden rows.
-
-        Returns:
-            bool: True if there are hidden rows, False otherwise.
-        """
-        return any(1 for v in self.visible_rows if v is False)
-
     @property
     def ordered_selected_rows(self) -> list[int]:
         """Get the list of selected row indices in order.
@@ -441,7 +435,7 @@ class DataFrameTable(DataTable):
         Returns:
             list[int]: A list of 0-based row indices that are currently selected.
         """
-        return [ridx for ridx, selected in enumerate(self.selected_rows) if selected]
+        return [ridx for ridx, rid in enumerate(self.df[RID]) if rid in self.selected_rows]
 
     @property
     def ordered_matches(self) -> list[tuple[int, int]]:
@@ -451,19 +445,22 @@ class DataFrameTable(DataTable):
             list[tuple[int, int]]: A list of (row_idx, col_idx) tuples for matched cells.
         """
         matches = []
-        for ridx in sorted(self.matches.keys()):
-            for cidx in sorted(self.matches[ridx]):
-                matches.append((ridx, cidx))
-        return matches
 
-    @property
-    def last_history(self) -> History:
-        """Get the last history state.
+        # Uniq columns
+        cols_to_check = set()
+        for cols in self.matches.values():
+            cols_to_check.update(cols)
 
-        Returns:
-            History: The most recent History object from the histories deque.
-        """
-        return self.histories[-1] if self.histories else None
+        # Ordered columns
+        cidx2col = {cidx: col for cidx, col in enumerate(self.df.columns) if col in cols_to_check}
+
+        for ridx, rid in enumerate(self.df[RID]):
+            if cols := self.matches.get(rid):
+                for cidx, col in cidx2col.items():
+                    if col in cols:
+                        matches.append((ridx, cidx))
+
+        return matches
 
     def _round_to_nearest_hundreds(self, num: int):
         """Round a number to the nearest hundreds.
@@ -677,42 +674,19 @@ class DataFrameTable(DataTable):
     # Action handlers for BINDINGS
     def action_jump_top(self) -> None:
         """Jump to the top of the table."""
-        self.move_cursor(row=0)
+        self.do_jump_top()
 
     def action_jump_bottom(self) -> None:
         """Jump to the bottom of the table."""
-        stop = len(self.df)
-        start = max(0, ((stop - self.BATCH_SIZE) // self.BATCH_SIZE + 1) * self.BATCH_SIZE)
-        self.load_rows_range(start, stop)
-        self.move_cursor(row=self.row_count - 1)
+        self.do_jump_bottom()
 
     def action_page_up(self) -> None:
         """Move the cursor one page up."""
-        self._set_hover_cursor(False)
-        if self.show_cursor and self.cursor_type in ("cell", "row"):
-            height = self.scrollable_content_region.height - (self.header_height if self.show_header else 0)
-
-            col_idx = self.cursor_column
-            ridx = self.cursor_row_idx
-            next_ridx = max(0, ridx - height - BUFFER_SIZE)
-            start, stop = self._round_to_nearest_hundreds(next_ridx)
-            self.load_rows_range(start, stop)
-
-            self.move_cursor(row=self.get_row_idx(str(next_ridx)), column=col_idx)
-        else:
-            super().action_page_up()
+        self.do_page_up()
 
     def action_page_down(self) -> None:
-        super().action_page_down()
-        self.load_rows_down()
-
-    def action_backward_page(self) -> None:
-        """Scroll up one page."""
-        self.action_page_up()
-
-    def action_forward_page(self) -> None:
-        """Scroll down one page."""
-        self.action_page_down()
+        """Move the cursor one page down."""
+        self.do_page_down()
 
     def action_view_row_detail(self) -> None:
         """View details of the current row."""
@@ -730,6 +704,10 @@ class DataFrameTable(DataTable):
         """Expand the current column to its full width."""
         self.do_expand_column()
 
+    def action_toggle_rid(self) -> None:
+        """Toggle the internal row index column visibility."""
+        self.do_toggle_rid()
+
     def action_show_hidden_rows_columns(self) -> None:
         """Show all hidden rows/columns."""
         self.do_show_hidden_rows_columns()
@@ -802,9 +780,9 @@ class DataFrameTable(DataTable):
         """Clear the current cell (set to None)."""
         self.do_clear_cell()
 
-    def action_select_row_cursor_value(self) -> None:
+    def action_select_row(self) -> None:
         """Select rows with cursor value in the current column."""
-        self.do_select_row_cursor_value()
+        self.do_select_row()
 
     def action_select_row_expr(self) -> None:
         """Select rows by expression."""
@@ -1014,51 +992,31 @@ class DataFrameTable(DataTable):
         # Set new dataframe and reset table
         self.df = new_df
         self.loaded_rows = 0
-        self.sorted_columns = {}
         self.hidden_columns = set()
-        self.selected_rows = [False] * len(self.df)
-        self.visible_rows = [True] * len(self.df)
+        self.selected_rows = set()
+        self.sorted_columns = {}
         self.fixed_rows = 0
         self.fixed_columns = 0
         self.matches = defaultdict(set)
         # self.histories.clear()
-        # self.history = None
+        # self.histories2.clear()
         self.dirty = dirty  # Mark as dirty since data changed
 
-    def setup_table(self, reset: bool = False) -> None:
+    def setup_table(self) -> None:
         """Setup the table for display.
 
         Row keys are 0-based indices, which map directly to dataframe row indices.
         Column keys are header names from the dataframe.
         """
         self.loaded_rows = 0
+        self.loaded_ranges.clear()
         self.show_row_labels = True
 
-        # Reset to original dataframe
-        if reset:
-            self.reset_df(self.dataframe, dirty=False)
-
-        # Lazy load up to BATCH_SIZE visible rows
-        stop, visible_count, row_idx = self.BATCH_SIZE, 0, 0
-        for row_idx, visible in enumerate(self.visible_rows):
-            if not visible:
-                continue
-            visible_count += 1
-            if visible_count > self.BATCH_SIZE:
-                stop = row_idx
-                break
-        else:
-            stop = row_idx
-
-        # Round up to next hundreds
-        if stop % self.BATCH_SIZE != 0:
-            stop = (stop // self.BATCH_SIZE + 1) * self.BATCH_SIZE
-
         # Save current cursor position before clearing
         row_idx, col_idx = self.cursor_coordinate
 
         self.setup_columns()
-        self.load_rows_range(0, stop)
+        self.load_rows_range(0, self.BATCH_SIZE)  # Load initial rows
 
         # Restore cursor position
         if row_idx < len(self.rows) and col_idx < len(self.columns):
@@ -1102,28 +1060,30 @@ class DataFrameTable(DataTable):
             # Get column label width
             # Add padding for sort indicators if any
             label_width = measure(self.app.console, col, 1) + 2
+            if dtype != pl.String:
+                available_width -= label_width
+                continue
 
             try:
                 # Get sample values from the column
-                sample_values = sample_lf.select(col).collect().get_column(col).to_list()
+                sample_values = sample_lf.select(col).collect().get_column(col).drop_nulls().to_list()
                 if any(val.startswith(("https://", "http://")) for val in sample_values):
                     continue  # Skip link columns so they can auto-size and be clickable
 
                 # Find maximum width in sample
                 max_cell_width = max(
-                    (measure(self.app.console, str(val), 1) for val in sample_values if val),
+                    (measure(self.app.console, val, 1) for val in sample_values),
                     default=label_width,
                 )
 
                 # Set column width to max of label and sampled data (capped at reasonable max)
                 max_width = max(label_width, max_cell_width)
-            except Exception:
+            except Exception as e:
                 # If any error, let Textual auto-size
                 max_width = label_width
+                self.log(f"Error determining width for column '{col}': {e}")
 
-            if dtype == pl.String:
-                column_widths[col] = max_width
-
+            column_widths[col] = max_width
             available_width -= max_width
 
         # If there's no more available width, auto-size remaining columns
@@ -1147,8 +1107,8 @@ class DataFrameTable(DataTable):
 
         # Add columns with justified headers
         for col, dtype in zip(self.df.columns, self.df.dtypes):
-            if col in self.hidden_columns:
-                continue  # Skip hidden columns
+            if col in self.hidden_columns or (col == RID and not self.show_rid):
+                continue  # Skip hidden columns and internal RID
             for idx, c in enumerate(self.sorted_columns, 1):
                 if c == col:
                     # Add sort indicator to column header
@@ -1166,71 +1126,6 @@ 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:
-        """Load a batch of rows into the table (synchronous wrapper).
-
-        Args:
-            stop: Stop loading rows when this index is reached.
-                  If None, load until the end of the dataframe.
-        """
-        if stop is None or stop > len(self.df):
-            stop = len(self.df)
-
-        # If already loaded enough rows, just move cursor if needed
-        if stop <= self.loaded_rows:
-            if move_to_end:
-                self.move_cursor(row=self.row_count - 1)
-
-            return
-
-        # Warn user if loading a large number of rows
-        elif (nrows := stop - self.loaded_rows) >= WARN_ROWS_THRESHOLD:
-
-            def _continue(result: bool) -> None:
-                if result:
-                    self.load_rows_async(stop, move_to_end=move_to_end)
-
-            self.app.push_screen(
-                ConfirmScreen(
-                    f"Load {nrows} Rows",
-                    label="Loading a large number of rows may cause the application to become unresponsive. Do you want to continue?",
-                ),
-                callback=_continue,
-            )
-
-            return
-
-        # Load rows asynchronously
-        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:
-        """Perform loading with async to avoid blocking.
-
-        Args:
-            stop: Stop loading rows when this index is reached.
-            move_to_end: If True, move cursor to the last loaded row after loading completes.
-        """
-        # Load rows in smaller chunks to avoid blocking
-        if stop > self.loaded_rows:
-            self.log(f"Async loading up to row {self.loaded_rows = }, {stop = }")
-            # Load incrementally to avoid one big block
-            # Load max BATCH_SIZE rows at a time
-            chunk_size = min(self.BATCH_SIZE, stop - self.loaded_rows)
-            next_stop = min(self.loaded_rows + chunk_size, stop)
-            self.load_rows_range(self.loaded_rows, next_stop)
-            self.loaded_rows = next_stop
-
-            # If there's more to load, yield to event loop with delay
-            if next_stop < stop:
-                await sleep_async(0.05)  # 50ms delay to allow UI updates
-                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 _calculate_load_range(self, start: int, stop: int) -> list[tuple[int, int]]:
         """Calculate the actual ranges to load, accounting for already-loaded ranges.
 
@@ -1262,8 +1157,11 @@ class DataFrameTable(DataTable):
         # Merge overlapping/adjacent ranges
         merged = []
         for range_start, range_stop in sorted_ranges:
-            if merged and range_start <= merged[-1][1]:
-                # Overlapping or adjacent: merge
+            # Fully covered, no need to load anything
+            if range_start <= start and range_stop >= stop:
+                return []
+            # Overlapping or adjacent: merge
+            elif merged and range_start <= merged[-1][1]:
                 merged[-1] = (merged[-1][0], max(merged[-1][1], range_stop))
             else:
                 merged.append((range_start, range_stop))
@@ -1356,23 +1254,20 @@ class DataFrameTable(DataTable):
         df_slice = self.df.slice(segment_start, segment_stop - segment_start)
 
         # Load each row at the correct position
-        for ridx, row in enumerate(df_slice.rows(), segment_start):
-            if not self.visible_rows[ridx]:
-                continue  # Skip hidden rows
-
-            is_selected = self.selected_rows[ridx]
-            match_cols = self.matches.get(ridx, set())
+        for (ridx, row), rid in zip(enumerate(df_slice.rows(), segment_start), df_slice[RID]):
+            is_selected = rid in self.selected_rows
+            match_cols = self.matches.get(rid, set())
 
             vals, dtypes, styles = [], [], []
-            for cidx, (val, col, dtype) in enumerate(zip(row, self.df.columns, self.df.dtypes)):
-                if col in self.hidden_columns:
-                    continue  # Skip hidden columns
+            for val, col, dtype in zip(row, self.df.columns, self.df.dtypes, strict=True):
+                if col in self.hidden_columns or (col == RID and not self.show_rid):
+                    continue  # Skip hidden columns and internal RID
 
                 vals.append(val)
                 dtypes.append(dtype)
 
                 # Highlight entire row with selection or cells with matches
-                styles.append(HIGHLIGHT_COLOR if is_selected or cidx in match_cols else None)
+                styles.append(HIGHLIGHT_COLOR if is_selected or col in match_cols else None)
 
             formatted_row = format_row(vals, dtypes, styles=styles, thousand_separator=self.thousand_separator)
 
@@ -1413,8 +1308,7 @@ class DataFrameTable(DataTable):
 
             # If nothing needs loading, return early
             if not ranges_to_load:
-                self.log(f"Range {start}-{stop} already loaded, skipping")
-                return 0
+                return 0  # Already loaded
 
             # Track the number of loaded rows in this range
             range_count = 0
@@ -1446,26 +1340,12 @@ class DataFrameTable(DataTable):
         if top_row_key:
             top_ridx = int(top_row_key.value)
         else:
-            top_ridx = 0
-            self.log(f"No top row key at index {top_row_index}, defaulting to 0")
+            top_ridx = 0  # No top row key at index, default to 0
 
         # Load upward
         start, stop = self._round_to_nearest_hundreds(top_ridx - BUFFER_SIZE * 2)
         range_count = self.load_rows_range(start, stop)
 
-        # self.log(
-        #     "========",
-        #     f"{self.scrollable_content_region.height = },",
-        #     f"{self.header_height = },",
-        #     f"{self.scroll_y = },",
-        #     f"{top_row_index = },",
-        #     f"{top_ridx = },",
-        #     f"{start = },",
-        #     f"{stop = },",
-        #     f"{range_count = },",
-        #     f"{self.loaded_ranges = }",
-        # )
-
         # Adjust scroll to maintain position if rows were loaded above
         if range_count > 0:
             self.move_cursor(row=top_row_index + range_count)
@@ -1477,33 +1357,19 @@ class DataFrameTable(DataTable):
         if self.loaded_rows >= len(self.df):
             return
 
-        visible_row_count = self.scrollable_content_region.height - self.header_height
+        visible_row_count = self.scrollable_content_region.height - (self.header_height if self.show_header else 0)
         bottom_row_index = self.scroll_y + visible_row_count - BUFFER_SIZE
 
         bottom_row_key = self.get_row_key(bottom_row_index)
         if bottom_row_key:
             bottom_ridx = int(bottom_row_key.value)
         else:
-            bottom_ridx = 0
-            self.log(f"No bottom row key at index {bottom_row_index}, defaulting to 0")
+            bottom_ridx = 0  # No bottom row key at index, default to 0
 
         # Load downward
         start, stop = self._round_to_nearest_hundreds(bottom_ridx + BUFFER_SIZE * 2)
         range_count = self.load_rows_range(start, stop)
 
-        # self.log(
-        #     "========",
-        #     f"{self.scrollable_content_region.height = },",
-        #     f"{self.header_height = },",
-        #     f"{self.scroll_y = },",
-        #     f"{bottom_row_index = },",
-        #     f"{bottom_ridx = },",
-        #     f"{start = },",
-        #     f"{stop = },",
-        #     f"{range_count = },",
-        #     f"{self.loaded_ranges = }",
-        # )
-
         if range_count > 0:
             self.log(f"Loaded down: {range_count} rows in range {start}-{stop}/{len(self.df)}")
 
@@ -1608,18 +1474,58 @@ class DataFrameTable(DataTable):
         self.check_idle()
         return row_key
 
+    # Navigation
+    def do_jump_top(self) -> None:
+        """Jump to the top of the table."""
+        self.move_cursor(row=0)
+
+    def do_jump_bottom(self) -> None:
+        """Jump to the bottom of the table."""
+        stop = len(self.df)
+        start = max(0, stop - self.BATCH_SIZE)
+
+        if start % self.BATCH_SIZE != 0:
+            start = (start // self.BATCH_SIZE + 1) * self.BATCH_SIZE
+
+        if stop - start < self.BATCH_SIZE:
+            start -= self.BATCH_SIZE
+
+        self.load_rows_range(start, stop)
+        self.move_cursor(row=self.row_count - 1)
+
+    def do_page_up(self) -> None:
+        """Move the cursor one page up."""
+        self._set_hover_cursor(False)
+        if self.show_cursor and self.cursor_type in ("cell", "row"):
+            height = self.scrollable_content_region.height - (self.header_height if self.show_header else 0)
+
+            col_idx = self.cursor_column
+            ridx = self.cursor_row_idx
+            next_ridx = max(0, ridx - height - BUFFER_SIZE)
+            start, stop = self._round_to_nearest_hundreds(next_ridx)
+            self.load_rows_range(start, stop)
+
+            self.move_cursor(row=self.get_row_idx(str(next_ridx)), column=col_idx)
+        else:
+            super().action_page_up()
+
+    def do_page_down(self) -> None:
+        """Move the cursor one page down."""
+        super().action_page_down()
+        self.load_rows_down()
+
     # History & Undo
     def create_history(self, description: str) -> None:
         """Create the initial history state."""
         return History(
             description=description,
             df=self.df,
+            df_view=self.df_view,
             filename=self.filename,
             loaded_rows=self.loaded_rows,
-            sorted_columns=self.sorted_columns.copy(),
             hidden_columns=self.hidden_columns.copy(),
             selected_rows=self.selected_rows.copy(),
-            visible_rows=self.visible_rows.copy(),
+            sorted_columns=self.sorted_columns.copy(),
             fixed_rows=self.fixed_rows,
             fixed_columns=self.fixed_columns,
             cursor_coordinate=self.cursor_coordinate,
@@ -1634,12 +1540,12 @@ class DataFrameTable(DataTable):
 
         # Restore state
         self.df = history.df
+        self.df_view = history.df_view
         self.filename = history.filename
         self.loaded_rows = history.loaded_rows
-        self.sorted_columns = history.sorted_columns.copy()
         self.hidden_columns = history.hidden_columns.copy()
         self.selected_rows = history.selected_rows.copy()
-        self.visible_rows = history.visible_rows.copy()
+        self.sorted_columns = history.sorted_columns.copy()
         self.fixed_rows = history.fixed_rows
         self.fixed_columns = history.fixed_columns
         self.cursor_coordinate = history.cursor_coordinate
@@ -1649,15 +1555,18 @@ class DataFrameTable(DataTable):
         # Recreate table for display
         self.setup_table()
 
-    def add_history(self, description: str, dirty: bool = False) -> None:
+    def add_history(self, description: str, dirty: bool = False, clear_redo: bool = True) -> 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)
-        self.histories.append(history)
+        self.histories_undo.append(self.create_history(description))
+
+        # Clear redo stack when a new action is performed
+        if clear_redo:
+            self.histories_redo.clear()
 
         # Mark table as dirty if this operation modifies data
         if dirty:
@@ -1665,52 +1574,43 @@ class DataFrameTable(DataTable):
 
     def do_undo(self) -> None:
         """Undo the last action."""
-        if not self.histories:
+        if not self.histories_undo:
             self.notify("No actions to undo", title="Undo", severity="warning")
             return
 
-        # Pop the last history state for undo
-        history = self.histories.pop()
-
-        # Save current state for redo
-        self.history = self.create_history(history.description)
+        # Pop the last history state for undo and save to redo stack
+        history = self.histories_undo.pop()
+        self.histories_redo.append(self.create_history(history.description))
 
         # Restore state
         self.apply_history(history)
 
-        self.notify(f"Reverted: [$success]{history.description}[/]", title="Undo")
+        self.notify(f"Reverted: {history.description}", title="Undo")
 
     def do_redo(self) -> None:
         """Redo the last undone action."""
-        if self.history is None:
+        if not self.histories_redo:
             self.notify("No actions to redo", title="Redo", severity="warning")
             return
 
-        description = self.history.description
+        # Pop the last undone state from redo stack
+        history = self.histories_redo.pop()
+        description = history.description
 
         # Save current state for undo
-        self.add_history(description)
+        self.add_history(description, clear_redo=False)
 
         # Restore state
-        self.apply_history(self.history)
-
-        # Clear redo state
-        self.history = None
+        self.apply_history(history)
 
-        self.notify(f"Reapplied: [$success]{description}[/]", title="Redo")
+        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.reset_df(self.dataframe, dirty=False)
+        self.setup_table()
         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 do_cycle_cursor_type(self) -> None:
         """Cycle through cursor types: cell -> row -> column -> cell."""
@@ -1817,14 +1717,20 @@ class DataFrameTable(DataTable):
         max_width = len(col_name) + 2  # Start with column name width + padding
 
         try:
+            need_expand = False
+
             # Scan through all loaded rows that are visible to find max width
             for row_idx in range(self.loaded_rows):
-                if not self.visible_rows[row_idx]:
-                    continue  # Skip hidden rows
                 cell_value = str(self.df.item(row_idx, col_idx))
                 cell_width = measure(self.app.console, cell_value, 1)
+
+                if cell_width > max_width:
+                    need_expand = True
                 max_width = max(max_width, cell_width)
 
+            if not need_expand:
+                return
+
             # Update the column width
             col = self.columns[col_key]
             col.width = max_width
@@ -1841,32 +1747,34 @@ class DataFrameTable(DataTable):
             )
             self.log(f"Error expanding column `{col_name}`: {str(e)}")
 
-    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)
+    def do_toggle_rid(self) -> None:
+        """Toggle display of the internal RID column."""
+        self.show_rid = not self.show_rid
 
-        hidden_row_count = sum(0 if visible else 1 for visible in self.visible_rows)
-        hidden_col_count = sum(0 if col in visible_cols else 1 for col in self.df.columns)
+        # Recreate table for display
+        self.setup_table()
 
-        if not hidden_row_count and not hidden_col_count:
-            self.notify("No hidden columns or rows to show", title="Show", severity="warning")
+    def do_show_hidden_rows_columns(self) -> None:
+        """Show all hidden rows/columns by recreating the table."""
+        if not self.hidden_columns and self.df_view is None:
+            self.notify("No hidden rows or columns to show", title="Show", severity="warning")
             return
 
         # Add to history
         self.add_history("Showed hidden rows/columns")
 
+        # If in a filtered view, restore the full dataframe
+        if self.df_view is not None:
+            self.df = self.df_view
+            self.df_view = None
+
         # Clear hidden rows/columns tracking
-        self.visible_rows = [True] * len(self.df)
         self.hidden_columns.clear()
 
         # Recreate table for display
         self.setup_table()
 
-        self.notify(
-            f"Showed [$success]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] column(s)",
-            title="Show",
-        )
+        self.notify("Showed hidden row(s) and/or hidden column(s)", title="Show")
 
     # Sort
     def do_sort_by_column(self, descending: bool = False) -> None:
@@ -1888,41 +1796,39 @@ class DataFrameTable(DataTable):
         # Add to history
         self.add_history(f"Sorted on column [$success]{col_name}[/]", dirty=True)
 
+        # New column - add to sort
         if old_desc is None:
-            # Add new column to sort
             self.sorted_columns[col_name] = descending
+
+        # Old column, same direction - remove from sort
         elif old_desc == descending:
-            # Same direction - remove from sort
             del self.sorted_columns[col_name]
+
+        # Old column, different direction - add to sort at end
         else:
-            # Move to end of sort order
             del self.sorted_columns[col_name]
             self.sorted_columns[col_name] = descending
 
-        lf = self.df.lazy().with_row_index(RIDX)
+        lf = self.df.lazy()
+        sort_by = {}
 
         # Apply multi-column sort
         if sort_cols := list(self.sorted_columns.keys()):
             descending_flags = list(self.sorted_columns.values())
-            lf = lf.sort(sort_cols, descending=descending_flags, nulls_last=True)
-
-        df_sorted = lf.collect()
-
-        # Updated visible rows, selected rows, and cell matches to match new order
-        old_row_indices = df_sorted[RIDX].to_list()
-        if self.has_hidden_rows:
-            self.visible_rows = [self.visible_rows[old_ridx] for old_ridx in old_row_indices]
-        if any(self.selected_rows):
-            self.selected_rows = [self.selected_rows[old_ridx] for old_ridx in old_row_indices]
-        if any(self.matches):
-            self.matches = {
-                new_ridx: self.matches[old_ridx]
-                for new_ridx, old_ridx in enumerate(old_row_indices)
-                if old_ridx in self.matches
-            }
+            sort_by = {"by": sort_cols, "descending": descending_flags, "nulls_last": True}
+        else:
+            # No sort - restore original order by adding a temporary index column
+            sort_by = {"by": RID}
+
+        # Perform the sort
+        df_sorted = lf.sort(**sort_by).collect()
+
+        # Also update df_view if applicable
+        if self.df_view is not None:
+            self.df_view = self.df_view.lazy().sort(**sort_by).collect()
 
         # Update the dataframe
-        self.df = df_sorted.drop(RIDX)
+        self.df = df_sorted
 
         # Recreate table for display
         self.setup_table()
@@ -1969,6 +1875,17 @@ class DataFrameTable(DataTable):
                 .alias(col_name)
             )
 
+            # Also update the view if applicable
+            if self.df_view is not None:
+                # Get the RID value for this row in df_view
+                ridx_view = self.df.item(ridx, self.df.columns.index(RID))
+                self.df_view = self.df_view.with_columns(
+                    pl.when(pl.col(RID) == ridx_view)
+                    .then(pl.lit(new_value))
+                    .otherwise(pl.col(col_name))
+                    .alias(col_name)
+                )
+
             # Update the display
             cell_value = self.df.item(ridx, cidx)
             if cell_value is None:
@@ -2044,11 +1961,26 @@ class DataFrameTable(DataTable):
 
         try:
             # Apply the expression to the column
-            self.df = self.df.with_columns(expr.alias(col_name))
+            self.df = self.df.lazy().with_columns(expr.alias(col_name)).collect()
+
+            # Also update the view if applicable
+            # Update the value of col_name in df_view using the value of col_name from df based on RID mapping between them
+            if self.df_view is not None:
+                # Get updated column from df for rows that exist in df_view
+                col_updated = f"^_{col_name}_^"
+                lf_updated = self.df.lazy().select(RID, pl.col(col_name).alias(col_updated))
+                # Join and use coalesce to prefer updated value or keep original
+                self.df_view = (
+                    self.df_view.lazy()
+                    .join(lf_updated, on=RID, how="left")
+                    .with_columns(pl.coalesce(pl.col(col_updated), pl.col(col_name)).alias(col_name))
+                    .drop(col_updated)
+                    .collect()
+                )
         except Exception as e:
             self.notify(
                 f"Error applying expression: [$error]{term}[/] to column [$accent]{col_name}[/]",
-                title="Edit",
+                title="Edit Column",
                 severity="error",
                 timeout=10,
             )
@@ -2090,14 +2022,25 @@ class DataFrameTable(DataTable):
         # Rename the column in the dataframe
         self.df = self.df.rename({col_name: new_name})
 
-        # Update sorted_columns if this column was sorted
+        # Also update the view if applicable
+        if self.df_view is not None:
+            self.df_view = self.df_view.rename({col_name: new_name})
+
+        # Update sorted_columns if this column was sorted and maintain order
         if col_name in self.sorted_columns:
-            self.sorted_columns[new_name] = self.sorted_columns.pop(col_name)
+            sorted_columns = {}
+            for col, order in self.sorted_columns.items():
+                if col == col_name:
+                    sorted_columns[new_name] = order
+                else:
+                    sorted_columns[col] = order
+            self.sorted_columns = sorted_columns
 
-        # Update hidden_columns if this column was hidden
-        if col_name in self.hidden_columns:
-            self.hidden_columns.remove(col_name)
-            self.hidden_columns.add(new_name)
+        # Update matches if this column had cell matches
+        for cols in self.matches.values():
+            if col_name in cols:
+                cols.remove(col_name)
+                cols.add(new_name)
 
         # Recreate table for display
         self.setup_table()
@@ -2126,6 +2069,13 @@ class DataFrameTable(DataTable):
                 .alias(col_name)
             )
 
+            # Also update the view if applicable
+            if self.df_view is not None:
+                ridx_view = self.df.item(ridx, self.df.columns.index(RID))
+                self.df_view = self.df_view.with_columns(
+                    pl.when(pl.col(RID) == ridx_view).then(pl.lit(None)).otherwise(pl.col(col_name)).alias(col_name)
+                )
+
             # Update the display
             dtype = self.df.dtypes[cidx]
             dc = DtypeConfig(dtype)
@@ -2144,30 +2094,27 @@ class DataFrameTable(DataTable):
             self.log(f"Error clearing cell ({ridx}, {col_name}): {str(e)}")
             raise e
 
-    def do_add_column(self, col_name: str = None, col_value: pl.Expr = None) -> None:
+    def do_add_column(self, col_name: str = 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
+            new_col_name = base_name
             counter = 1
-            while new_name in self.df.columns:
-                new_name = f"{base_name}_{counter}"
+            while new_col_name in self.df.columns:
+                new_col_name = f"{base_name}_{counter}"
                 counter += 1
         else:
-            new_name = col_name
+            new_col_name = col_name
 
         # Add to history
-        self.add_history(f"Added column [$success]{new_name}[/] after column [$accent]{cidx + 1}[/]", dirty=True)
+        self.add_history(f"Added column [$success]{new_col_name}[/] after column [$accent]{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_col = pl.lit(col_value).alias(new_name)
+            new_col_name = pl.lit(None).alias(new_col_name)
 
             # Get columns up to current, the new column, then remaining columns
             cols = self.df.columns
@@ -2175,8 +2122,12 @@ class DataFrameTable(DataTable):
             cols_after = cols[cidx + 1 :]
 
             # Build the new dataframe with columns reordered
-            select_cols = cols_before + [new_name] + cols_after
-            self.df = self.df.with_columns(new_col).select(select_cols)
+            select_cols = cols_before + [new_col_name] + cols_after
+            self.df = self.df.lazy().with_columns(new_col_name).select(select_cols).collect()
+
+            # Also update the view if applicable
+            if self.df_view is not None:
+                self.df_view = self.df_view.lazy().with_columns(new_col_name).select(select_cols).collect()
 
             # Recreate table for display
             self.setup_table()
@@ -2186,8 +2137,10 @@ class DataFrameTable(DataTable):
 
             # self.notify(f"Added column [$success]{new_name}[/]", title="Add Column")
         except Exception as e:
-            self.notify(f"Error adding column [$error]{new_name}[/]", title="Add Column", severity="error", timeout=10)
-            self.log(f"Error adding column `{new_name}`: {str(e)}")
+            self.notify(
+                f"Error adding column [$error]{new_col_name}[/]", title="Add Column", severity="error", timeout=10
+            )
+            self.log(f"Error adding column `{new_col_name}`: {str(e)}")
             raise e
 
     def do_add_column_expr(self) -> None:
@@ -2219,7 +2172,14 @@ class DataFrameTable(DataTable):
 
             # 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)
+            self.df = self.df.lazy().with_columns(new_col).select(select_cols).collect()
+
+            # Also update the view if applicable
+            if self.df_view is not None:
+                # Get updated column from df for rows that exist in df_view
+                lf_updated = self.df.lazy().select(RID, pl.col(new_col_name))
+                # Join and use coalesce to prefer updated value or keep original
+                self.df_view = self.df_view.lazy().join(lf_updated, on=RID, how="left").select(select_cols).collect()
 
             # Recreate table for display
             self.setup_table()
@@ -2285,7 +2245,14 @@ class DataFrameTable(DataTable):
 
             # 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.df = self.df.lazy().with_columns(new_col).select(select_cols).collect()
+
+            # Also update the view if applicable
+            if self.df_view is not None:
+                # Get updated column from df for rows that exist in df_view
+                lf_updated = self.df.lazy().select(RID, pl.col(new_col_name))
+                # Join and use coalesce to prefer updated value or keep original
+                self.df_view = self.df_view.lazy().join(lf_updated, on=RID, how="left").select(select_cols).collect()
 
             # Recreate table for display
             self.setup_table()
@@ -2352,17 +2319,24 @@ class DataFrameTable(DataTable):
             if col_name in self.sorted_columns:
                 del self.sorted_columns[col_name]
 
+        # Remove from hidden columns if present
+        for col_name in col_names_to_remove:
+            self.hidden_columns.discard(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)
+        for rid in list(self.matches.keys()):
+            self.matches[rid].difference_update(col_names_to_remove)
             # Remove empty entries
-            if not self.matches[row_idx]:
-                del self.matches[row_idx]
+            if not self.matches[rid]:
+                del self.matches[rid]
 
         # Remove from dataframe
         self.df = self.df.drop(col_names_to_remove)
 
+        # Also update the view if applicable
+        if self.df_view is not None:
+            self.df_view = self.df_view.drop(col_names_to_remove)
+
         self.notify(message, title="Delete")
 
     def do_duplicate_column(self) -> None:
@@ -2373,29 +2347,28 @@ class DataFrameTable(DataTable):
         col_idx = self.cursor_column
         new_col_name = f"{col_name}_copy"
 
+        # Ensure new column name is unique
+        counter = 1
+        while new_col_name in self.df.columns:
+            new_col_name = f"{new_col_name}{counter}"
+            counter += 1
+
         # Add to history
         self.add_history(f"Duplicated column [$success]{col_name}[/]", dirty=True)
 
         # 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 :]
+        cols_new = cols_before + [new_col_name] + cols_after
 
         # 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)
-        )
+        self.df = self.df.lazy().with_columns(pl.col(col_name).alias(new_col_name)).select(cols_new).collect()
 
-        # 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
+        # Also update the view if applicable
+        if self.df_view is not None:
+            self.df_view = (
+                self.df_view.lazy().with_columns(pl.col(col_name).alias(new_col_name)).select(cols_new).collect()
+            )
 
         # Recreate table for display
         self.setup_table()
@@ -2411,58 +2384,61 @@ class DataFrameTable(DataTable):
         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)
+        rids_to_delete = set()
 
         # Delete all selected rows
-        if selected_count := self.selected_rows.count(True):
+        if selected_count := len(self.selected_rows):
             history_desc = f"Deleted {selected_count} selected row(s)"
-
-            for ridx, selected in enumerate(self.selected_rows):
-                if selected:
-                    predicates[ridx] = False
+            rids_to_delete = self.selected_rows
 
         # 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
+            for rid in self.df[RID][: ridx + 1]:
+                rids_to_delete.add(rid)
 
         # 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
+            for rid in self.df[RID][ridx:]:
+                rids_to_delete.add(rid)
 
         # 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
+            rids_to_delete.add(self.df[RID][ridx])
 
         # Add to history
         self.add_history(history_desc, dirty=True)
 
         # Apply the filter to remove rows
         try:
-            df = self.df.with_row_index(RIDX).filter(predicates)
+            df_filtered = self.df.lazy().filter(~pl.col(RID).is_in(rids_to_delete)).collect()
         except Exception as e:
             self.notify(f"Error deleting row(s): {e}", title="Delete", severity="error", timeout=10)
-            self.histories.pop()  # Remove last history entry
+            self.histories_undo.pop()  # Remove last history entry
             return
 
-        self.df = df.drop(RIDX)
+        # RIDs of remaining rows
+        ok_rids = set(df_filtered[RID])
 
-        # 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]
+        # Update selected rows tracking
+        if self.selected_rows:
+            self.selected_rows.intersection_update(ok_rids)
 
-        # Clear all matches since row indices have changed
-        self.matches = defaultdict(set)
+        # Update the dataframe
+        self.df = df_filtered
+
+        # Update matches since row indices have changed
+        if self.matches:
+            self.matches = {rid: cols for rid, cols in self.matches.items() if rid in ok_rids}
+
+        # Also update the view if applicable
+        if self.df_view is not None:
+            self.df_view = self.df_view.lazy().filter(~pl.col(RID).is_in(rids_to_delete)).collect()
 
         # Recreate table for display
         self.setup_table()
@@ -2474,34 +2450,29 @@ class DataFrameTable(DataTable):
     def do_duplicate_row(self) -> None:
         """Duplicate the currently selected row, inserting it right after the current row."""
         ridx = self.cursor_row_idx
+        rid = self.df[RID][ridx]
+
+        lf = self.df.lazy()
 
         # Get the row to duplicate
-        row_to_duplicate = self.df.slice(ridx, 1)
+        row_to_duplicate = lf.slice(ridx, 1).with_columns(pl.col(RID) + 1)
 
         # Add to history
         self.add_history(f"Duplicated row [$success]{ridx + 1}[/]", dirty=True)
 
         # Concatenate: rows before + duplicated row + rows after
-        df_before = self.df.slice(0, ridx + 1)
-        df_after = self.df.slice(ridx + 1)
+        lf_before = lf.slice(0, ridx + 1)
+        lf_after = lf.slice(ridx + 1).with_columns(pl.col(RID) + 1)
 
         # Combine the parts
-        self.df = pl.concat([df_before, row_to_duplicate, df_after])
-
-        # Update selected and visible rows tracking to account for new row
-        new_selected_rows = self.selected_rows[: ridx + 1] + [self.selected_rows[ridx]] + self.selected_rows[ridx + 1 :]
-        new_visible_rows = self.visible_rows[: ridx + 1] + [self.visible_rows[ridx]] + self.visible_rows[ridx + 1 :]
-        self.selected_rows = new_selected_rows
-        self.visible_rows = new_visible_rows
-
-        # Update matches to account for new row
-        new_matches = defaultdict(set)
-        for row_idx, cols in self.matches.items():
-            if row_idx <= ridx:
-                new_matches[row_idx] = cols
-            else:
-                new_matches[row_idx + 1] = cols
-        self.matches = new_matches
+        self.df = pl.concat([lf_before, row_to_duplicate, lf_after]).collect()
+
+        # Also update the view if applicable
+        if self.df_view is not None:
+            lf_view = self.df_view.lazy()
+            lf_view_before = lf_view.slice(0, rid + 1)
+            lf_view_after = lf_view.slice(rid + 1).with_columns(pl.col(RID) + 1)
+            self.df_view = pl.concat([lf_view_before, row_to_duplicate, lf_view_after]).collect()
 
         # Recreate table for display
         self.setup_table()
@@ -2567,6 +2538,10 @@ class DataFrameTable(DataTable):
         cols[cidx], cols[swap_cidx] = cols[swap_cidx], cols[cidx]
         self.df = self.df.select(cols)
 
+        # Also update the view if applicable
+        if self.df_view is not None:
+            self.df_view = self.df_view.select(cols)
+
         # self.notify(f"Moved column [$success]{col_name}[/] {direction}", title="Move")
 
     def do_move_row(self, direction: str) -> None:
@@ -2575,65 +2550,88 @@ class DataFrameTable(DataTable):
         Args:
             direction: "up" to move up, "down" to move down.
         """
-        row_idx, col_idx = self.cursor_coordinate
+        curr_row_idx, col_idx = self.cursor_coordinate
 
         # Validate move is possible
         if direction == "up":
-            if row_idx <= 0:
+            if curr_row_idx <= 0:
                 self.notify("Cannot move row up", title="Move", severity="warning")
                 return
-            swap_idx = row_idx - 1
+            swap_row_idx = curr_row_idx - 1
         elif direction == "down":
-            if row_idx >= len(self.rows) - 1:
+            if curr_row_idx >= len(self.rows) - 1:
                 self.notify("Cannot move row down", title="Move", severity="warning")
                 return
-            swap_idx = row_idx + 1
+            swap_row_idx = curr_row_idx + 1
         else:
             # Invalid direction
             return
 
-        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}[/] [$accent]{direction}[/] (swapped with row [$success]{swap_key.value}[/])",
+            f"Moved row [$success]{curr_row_idx}[/] [$accent]{direction}[/] (swapped with row [$success]{swap_row_idx}[/])",
             dirty=True,
         )
 
         # Swap rows in the table's internal row locations
+        curr_key = self.coordinate_to_cell_key((curr_row_idx, 0)).row_key
+        swap_key = self.coordinate_to_cell_key((swap_row_idx, 0)).row_key
+
         self.check_idle()
 
         (
-            self._row_locations[row_key],
+            self._row_locations[curr_key],
             self._row_locations[swap_key],
         ) = (
             self.get_row_idx(swap_key),
-            self.get_row_idx(row_key),
+            self.get_row_idx(curr_key),
         )
 
         self._update_count += 1
         self.refresh()
 
         # Restore cursor position on the moved row
-        self.move_cursor(row=swap_idx, column=col_idx)
+        self.move_cursor(row=swap_row_idx, column=col_idx)
 
-        # 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])
+        # Locate the rows to swap
+        curr_ridx = curr_row_idx
+        swap_ridx = swap_row_idx
+        first, second = sorted([curr_ridx, swap_ridx])
 
+        # Swap the rows in the dataframe
         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.df.slice(0, first).lazy(),
+                self.df.slice(second, 1).lazy(),
+                self.df.slice(first + 1, second - first - 1).lazy(),
+                self.df.slice(first, 1).lazy(),
+                self.df.slice(second + 1).lazy(),
             ]
-        )
+        ).collect()
+
+        # Also update the view if applicable
+        if self.df_view is not None:
+            # Find RID values
+            curr_rid = self.df[RID][curr_row_idx]
+            swap_rid = self.df[RID][swap_row_idx]
+
+            # Locate the rows by RID in the view
+            curr_ridx = self.df_view[RID].index_of(curr_rid)
+            swap_ridx = self.df_view[RID].index_of(swap_rid)
+            first, second = sorted([curr_ridx, swap_ridx])
+
+            # Swap the rows in the view
+            self.df_view = pl.concat(
+                [
+                    self.df_view.slice(0, first).lazy(),
+                    self.df_view.slice(second, 1).lazy(),
+                    self.df_view.slice(first + 1, second - first - 1).lazy(),
+                    self.df_view.slice(first, 1).lazy(),
+                    self.df_view.slice(second + 1).lazy(),
+                ]
+            ).collect()
 
-        # self.notify(f"Moved row [$success]{row_key.value}[/] {direction}", title="Move")
+        # self.notify(f"Moved row [$success]{row_key.value}[/] {direction}", title="Move Row")
 
     # Type casting
     def do_cast_column_dtype(self, dtype: str) -> None:
@@ -2670,6 +2668,10 @@ class DataFrameTable(DataTable):
             # Cast the column using Polars
             self.df = self.df.with_columns(pl.col(col_name).cast(target_dtype))
 
+            # Also update the view if applicable
+            if self.df_view is not None:
+                self.df_view = self.df_view.with_columns(pl.col(col_name).cast(target_dtype))
+
             # Recreate table for display
             self.setup_table()
 
@@ -2684,17 +2686,26 @@ class DataFrameTable(DataTable):
             self.log(f"Error casting column `{col_name}`: {str(e)}")
 
     # Row selection
-    def do_select_row_cursor_value(self) -> None:
-        """Search with cursor value in current column."""
+    def do_select_row(self) -> None:
+        """Select rows.
+
+        If there are existing cell matches, use those to select rows.
+        Otherwise, use the current cell value as the search term and select rows matching that value.
+        """
         cidx = self.cursor_col_idx
-        col_name = self.cursor_col_name
 
-        # Get the value of the currently selected cell
-        term = NULL if self.cursor_value is None else str(self.cursor_value)
-        if self.cursor_value is None:
-            term = pl.col(col_name).is_null()
+        # Use existing cell matches if present
+        if self.matches:
+            term = pl.col(RID).is_in(self.matches)
         else:
-            term = pl.col(col_name) == self.cursor_value
+            col_name = self.cursor_col_name
+
+            # Get the value of the currently selected cell
+            term = NULL if self.cursor_value is None else str(self.cursor_value)
+            if self.cursor_value is None:
+                term = pl.col(col_name).is_null()
+            else:
+                term = pl.col(col_name) == self.cursor_value
 
         self.select_row((term, cidx, False, True))
 
@@ -2707,7 +2718,7 @@ class DataFrameTable(DataTable):
 
         # Push the search modal screen
         self.app.push_screen(
-            SearchScreen("Search", term, self.df, cidx),
+            SearchScreen("Select", term, self.df, cidx),
             callback=self.select_row,
         )
 
@@ -2717,12 +2728,16 @@ class DataFrameTable(DataTable):
             return
 
         term, cidx, match_nocase, match_whole = result
-        col_name = self.df.columns[cidx]
+        col_name = "all columns" if cidx is None else self.df.columns[cidx]
 
         # Already a Polars expression
         if isinstance(term, pl.Expr):
             expr = term
 
+        # bool list or Series
+        elif isinstance(term, (list, pl.Series)):
+            expr = term
+
         # Null case
         elif term == NULL:
             expr = pl.col(col_name).is_null()
@@ -2764,13 +2779,11 @@ class DataFrameTable(DataTable):
                     )
 
         # Lazyframe for filtering
-        lf = self.df.lazy().with_row_index(RIDX)
-        if self.has_hidden_rows:
-            lf = lf.filter(self.visible_rows)
+        lf = self.df.lazy()
 
         # Apply filter to get matched row indices
         try:
-            matches = set(lf.filter(expr).select(RIDX).collect().to_series().to_list())
+            ok_rids = set(lf.filter(expr).collect()[RID])
         except Exception as e:
             self.notify(
                 f"Error applying search filter `[$error]{term}[/]`", title="Search", severity="error", timeout=10
@@ -2778,7 +2791,7 @@ class DataFrameTable(DataTable):
             self.log(f"Error applying search filter `{term}`: {str(e)}")
             return
 
-        match_count = len(matches)
+        match_count = len(ok_rids)
         if match_count == 0:
             self.notify(
                 f"No matches found for `[$warning]{term}[/]`. Try [$accent](?i)abc[/] for case-insensitive search.",
@@ -2787,14 +2800,13 @@ class DataFrameTable(DataTable):
             )
             return
 
-        message = f"Found [$success]{match_count}[/] matching row(s) for `[$accent]{term}[/]`"
+        message = f"Found [$success]{match_count}[/] matching row(s)"
 
         # Add to history
         self.add_history(message)
 
-        # Update selected rows to include new matches
-        for m in matches:
-            self.selected_rows[m] = True
+        # Update selected rows to include new selections
+        self.selected_rows.update(ok_rids)
 
         # Show notification immediately, then start highlighting
         self.notify(message, title="Select Row")
@@ -2807,20 +2819,12 @@ class DataFrameTable(DataTable):
         # Add to history
         self.add_history("Toggled row selection")
 
-        if self.has_hidden_rows:
-            # Some rows are hidden - invert only selected visible rows and clear selections for hidden rows
-            for i in range(len(self.selected_rows)):
-                if self.visible_rows[i]:
-                    self.selected_rows[i] = not self.selected_rows[i]
-                else:
-                    self.selected_rows[i] = False
-        else:
-            # Invert all selected rows
-            self.selected_rows = [not selected for selected in self.selected_rows]
+        # Invert all selected rows
+        self.selected_rows = {rid for rid in self.df[RID] if rid not in self.selected_rows}
 
         # Check if we're highlighting or un-highlighting
-        if new_selected_count := self.selected_rows.count(True):
-            self.notify(f"Toggled selection for [$success]{new_selected_count}[/] rows", title="Toggle")
+        if selected_count := len(self.selected_rows):
+            self.notify(f"Toggled selection for [$success]{selected_count}[/] rows", title="Toggle")
 
         # Recreate table for display
         self.setup_table()
@@ -2830,16 +2834,25 @@ class DataFrameTable(DataTable):
         # Add to history
         self.add_history("Toggled row selection")
 
+        # Get current row RID
         ridx = self.cursor_row_idx
-        self.selected_rows[ridx] = not self.selected_rows[ridx]
+        rid = self.df[RID][ridx]
+
+        if rid in self.selected_rows:
+            self.selected_rows.discard(rid)
+        else:
+            self.selected_rows.add(rid)
+
+        row_key = self.cursor_row_key
+        is_selected = rid in self.selected_rows
+        match_cols = self.matches.get(rid, set())
 
-        row_key = str(ridx)
-        match_cols = self.matches.get(ridx, set())
         for col_idx, col in enumerate(self.ordered_columns):
             col_key = col.key
+            col_name = col_key.value
             cell_text: Text = self.get_cell(row_key, col_key)
 
-            if self.selected_rows[ridx] or (col_idx in match_cols):
+            if is_selected or (col_name in match_cols):
                 cell_text.style = HIGHLIGHT_COLOR
             else:
                 # Reset to default style based on dtype
@@ -2852,19 +2865,17 @@ class DataFrameTable(DataTable):
     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:
+        if not self.selected_rows and not self.matches:
             self.notify("No selections to clear", title="Clear", severity="warning")
             return
 
-        row_count = sum(
-            1 if (selected or idx in self.matches) else 0 for idx, selected in enumerate(self.selected_rows)
-        )
+        row_count = len(self.selected_rows | set(self.matches.keys()))
 
         # Add to history
         self.add_history("Cleared all selected rows")
 
         # Clear all selections
-        self.selected_rows = [False] * len(self.df)
+        self.selected_rows = set()
         self.matches = defaultdict(set)
 
         # Recreate table for display
@@ -2875,7 +2886,7 @@ class DataFrameTable(DataTable):
     # Find & Replace
     def find_matches(
         self, term: str, cidx: int | None = None, match_nocase: bool = False, match_whole: bool = False
-    ) -> dict[int, set[int]]:
+    ) -> dict[int, set[str]]:
         """Find matches for a term in the dataframe.
 
         Args:
@@ -2892,12 +2903,10 @@ class DataFrameTable(DataTable):
         Raises:
             Exception: If expression validation or filtering fails.
         """
-        matches: dict[int, set[int]] = defaultdict(set)
+        matches: dict[int, set[str]] = defaultdict(set)
 
         # Lazyframe for filtering
-        lf = self.df.lazy().with_row_index(RIDX)
-        if self.has_hidden_rows:
-            lf = lf.filter(self.visible_rows)
+        lf = self.df.lazy()
 
         # Determine which columns to search: single column or all columns
         if cidx is not None:
@@ -2928,14 +2937,14 @@ class DataFrameTable(DataTable):
 
             # Get matched row indices
             try:
-                matched_ridxs = lf.filter(expr).select(RIDX).collect().to_series().to_list()
+                matched_ridxs = lf.filter(expr).collect()[RID]
             except Exception as e:
                 self.notify(f"Error applying filter: [$error]{expr}[/]", title="Find", severity="error", timeout=10)
                 self.log(f"Error applying filter: {str(e)}")
                 return matches
 
             for ridx in matched_ridxs:
-                matches[ridx].add(col_idx)
+                matches[ridx].add(col_name)
 
         return matches
 
@@ -2997,9 +3006,9 @@ class DataFrameTable(DataTable):
         self.add_history(f"Found `[$success]{term}[/]` in column [$accent]{col_name}[/]")
 
         # Add to matches and count total
-        match_count = sum(len(col_idxs) for col_idxs in matches.values())
-        for ridx, col_idxs in matches.items():
-            self.matches[ridx].update(col_idxs)
+        match_count = sum(len(cols) for cols in matches.values())
+        for rid, cols in matches.items():
+            self.matches[rid].update(cols)
 
         self.notify(f"Found [$success]{match_count}[/] matches for `[$accent]{term}[/]`", title="Find")
 
@@ -3031,9 +3040,9 @@ class DataFrameTable(DataTable):
         self.add_history(f"Found `[$success]{term}[/]` across all columns")
 
         # Add to matches and count total
-        match_count = sum(len(col_idxs) for col_idxs in matches.values())
-        for ridx, col_idxs in matches.items():
-            self.matches[ridx].update(col_idxs)
+        match_count = sum(len(cols) for cols in matches.values())
+        for rid, cols in matches.items():
+            self.matches[rid].update(cols)
 
         self.notify(
             f"Found [$success]{match_count}[/] matches for `[$accent]{term}[/]` across all columns",
@@ -3095,7 +3104,7 @@ class DataFrameTable(DataTable):
 
     def do_next_selected_row(self) -> None:
         """Move cursor to the next selected row."""
-        if not any(self.selected_rows):
+        if not self.selected_rows:
             self.notify("No selected rows to navigate", title="Next Selected Row", severity="warning")
             return
 
@@ -3117,7 +3126,7 @@ class DataFrameTable(DataTable):
 
     def do_previous_selected_row(self) -> None:
         """Move cursor to the previous selected row."""
-        if not any(self.selected_rows):
+        if not self.selected_rows:
             self.notify("No selected rows to navigate", title="Previous Selected Row", severity="warning")
             return
 
@@ -3190,25 +3199,34 @@ class DataFrameTable(DataTable):
         )
 
         # Update matches
-        self.matches = {ridx: col_idxs.copy() for ridx, col_idxs in matches.items()}
+        self.matches = matches
 
         # Recreate table for display
         self.setup_table()
 
         # Store state for interactive replacement using dataclass
-        sorted_rows = sorted(self.matches.keys())
+        rid2ridx = {rid: ridx for ridx, rid in enumerate(self.df[RID]) if rid in self.matches}
+
+        # Unique columns to replace
+        cols_to_replace = set()
+        for cols in self.matches.values():
+            cols_to_replace.update(cols)
+
+        # Sorted column indices to replace
+        cidx2col = {cidx: col for cidx, col in enumerate(self.df.columns) if col in cols_to_replace}
+
         self.replace_state = ReplaceState(
             term_find=term_find,
             term_replace=term_replace,
             match_nocase=match_nocase,
             match_whole=match_whole,
             cidx=cidx,
-            rows=sorted_rows,
-            cols_per_row=[sorted(self.matches[ridx]) for ridx in sorted_rows],
+            rows=list(rid2ridx.values()),
+            cols_per_row=[[cidx for cidx, col in cidx2col.items() if col in self.matches[rid]] for rid in rid2ridx],
             current_rpos=0,
             current_cpos=0,
             current_occurrence=0,
-            total_occurrence=sum(len(col_idxs) for col_idxs in self.matches.values()),
+            total_occurrence=sum(len(cols) for cols in self.matches.values()),
             replaced_occurrence=0,
             skipped_occurrence=0,
             done=False,
@@ -3292,6 +3310,18 @@ class DataFrameTable(DataTable):
                     pl.when(mask).then(pl.lit(value)).otherwise(pl.col(col_name)).alias(col_name)
                 )
 
+            # Also update the view if applicable
+            if self.df_view is not None:
+                col_updated = f"^_{col_name}_^"
+                lf_updated = self.df.lazy().filter(mask).select(pl.col(col_name).alias(col_updated), pl.col(RID))
+                self.df_view = (
+                    self.df_view.lazy()
+                    .join(lf_updated, on=RID, how="left")
+                    .with_columns(pl.coalesce(pl.col(col_updated), pl.col(col_name)).alias(col_name))
+                    .drop(col_updated)
+                    .collect()
+                )
+
             state.replaced_occurrence += len(ridxs)
 
         # Recreate table for display
@@ -3303,7 +3333,7 @@ class DataFrameTable(DataTable):
 
         col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
         self.notify(
-            f"Replaced [$success]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$s]{col_name}[/]",
+            f"Replaced [$success]{state.replaced_occurrence}[/] of [$success]{state.total_occurrence}[/] in [$accent]{col_name}[/]",
             title="Replace",
         )
 
@@ -3327,7 +3357,7 @@ class DataFrameTable(DataTable):
         if state.done:
             # All done - show final notification
             col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
-            msg = f"Replaced [$success]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$success]{col_name}[/]"
+            msg = f"Replaced [$success]{state.replaced_occurrence}[/] of [$success]{state.total_occurrence}[/] in [$accent]{col_name}[/]"
             if state.skipped_occurrence > 0:
                 msg += f", [$warning]{state.skipped_occurrence}[/] skipped"
             self.notify(msg, title="Replace")
@@ -3362,6 +3392,7 @@ class DataFrameTable(DataTable):
         cidx = state.cols_per_row[state.current_rpos][state.current_cpos]
         col_name = self.df.columns[cidx]
         dtype = self.df.dtypes[cidx]
+        rid = self.df[RID][ridx]
 
         # Replace
         if result is True:
@@ -3374,6 +3405,15 @@ class DataFrameTable(DataTable):
                     .otherwise(pl.col(col_name))
                     .alias(col_name)
                 )
+
+                # Also update the view if applicable
+                if self.df_view is not None:
+                    self.df_view = self.df_view.with_columns(
+                        pl.when(pl.col(RID) == rid)
+                        .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:
@@ -3388,6 +3428,12 @@ class DataFrameTable(DataTable):
                     .alias(col_name)
                 )
 
+                # Also update the view if applicable
+                if self.df_view is not None:
+                    self.df_view = self.df_view.with_columns(
+                        pl.when(pl.col(RID) == rid).then(pl.lit(value)).otherwise(pl.col(col_name)).alias(col_name)
+                    )
+
             state.replaced_occurrence += 1
 
         # Skip
@@ -3424,18 +3470,16 @@ class DataFrameTable(DataTable):
     def do_view_rows(self) -> None:
         """View rows.
 
-        If there are selected rows or matches, view those rows.
-        Otherwise, view based on the value of the currently selected cell.
+        If there are selected rows, view those.
+        Otherwise, view based on the cursor value.
         """
 
         cidx = self.cursor_col_idx
-        col_name = self.df.columns[cidx]
+        col_name = self.cursor_col_name
 
-        # If there are rows with selections or matches, use those
-        if any(self.selected_rows) or self.matches:
-            term = [
-                True if (selected or idx in self.matches) else False for idx, selected in enumerate(self.selected_rows)
-            ]
+        # If there are selected rows, use those
+        if self.selected_rows:
+            term = pl.col(RID).is_in(self.selected_rows)
         # Otherwise, use the current cell value
         else:
             ridx = self.cursor_row_idx
@@ -3457,7 +3501,7 @@ class DataFrameTable(DataTable):
         )
 
     def view_rows(self, result) -> None:
-        """Show only rows with selections or matches, and do hide others. Do not modify the dataframe."""
+        """View selected rows and hide others. Do not modify the dataframe."""
         if result is None:
             return
         term, cidx, match_nocase, match_whole = result
@@ -3467,13 +3511,17 @@ class DataFrameTable(DataTable):
         # Support for polars expression
         if isinstance(term, pl.Expr):
             expr = term
+
         # Support for list of booleans (selected rows)
         elif isinstance(term, (list, pl.Series)):
             expr = term
+
+        # Null case
         elif term == NULL:
             expr = pl.col(col_name).is_null()
+
+        # Support for polars expression in string form
         elif tentative_expr(term):
-            # Support for polars expression in string form
             try:
                 expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
@@ -3482,6 +3530,8 @@ class DataFrameTable(DataTable):
                 )
                 self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
+
+        # Type-aware search based on column dtype
         else:
             dtype = self.df.dtypes[cidx]
             if dtype == pl.String:
@@ -3505,11 +3555,7 @@ class DataFrameTable(DataTable):
                     )
 
         # Lazyframe with row indices
-        lf = self.df.lazy().with_row_index(RIDX)
-
-        # Apply existing visibility filter first
-        if self.has_hidden_rows:
-            lf = lf.filter(self.visible_rows)
+        lf = self.df.lazy()
 
         expr_str = "boolean list or series" if isinstance(expr, (list, pl.Series)) else str(expr)
 
@@ -3517,7 +3563,7 @@ class DataFrameTable(DataTable):
         try:
             df_filtered = lf.filter(expr).collect()
         except Exception as e:
-            self.histories.pop()  # Remove last history entry
+            self.histories_undo.pop()  # Remove last history entry
             self.notify(f"Error applying filter [$error]{expr_str}[/]", title="Filter", severity="error", timeout=10)
             self.log(f"Error applying filter `{expr_str}`: {str(e)}")
             return
@@ -3530,26 +3576,37 @@ class DataFrameTable(DataTable):
         # Add to history
         self.add_history(f"Filtered by expression [$success]{expr_str}[/]")
 
-        # Mark unfiltered rows as invisible
-        filtered_row_indices = set(df_filtered[RIDX].to_list())
-        if filtered_row_indices:
-            for ridx in range(len(self.visible_rows)):
-                if ridx not in filtered_row_indices:
-                    self.visible_rows[ridx] = False
+        ok_rids = set(df_filtered[RID])
+
+        # Create a view of self.df as a copy
+        if self.df_view is None:
+            self.df_view = self.df
+
+        # Update dataframe
+        self.df = df_filtered
+
+        # Update selected rows
+        if self.selected_rows:
+            self.selected_rows.intersection_update(ok_rids)
+
+        # Update matches
+        if self.matches:
+            self.matches = {rid: cols for rid, cols in self.matches.items() if rid in ok_rids}
 
         # Recreate table for display
         self.setup_table()
 
-        self.notify(f"Filtered to [$success]{matched_count}[/] matching rows", title="Filter")
+        self.notify(f"Filtered to [$success]{matched_count}[/] matching row(s)", title="Filter")
 
     def do_filter_rows(self) -> None:
-        """Keep only the rows with selections and cell matches, and remove others."""
-        if any(self.selected_rows) or self.matches:
-            message = "Filtered to rows with selection and cell matches (other rows removed)"
-            filter_expr = [
-                True if (selected or ridx in self.matches) else False
-                for ridx, selected in enumerate(self.selected_rows)
-            ]
+        """Filter rows.
+
+        If there are selected rows, use those.
+        Otherwise, filter based on the cursor value.
+        """
+        if self.selected_rows:
+            message = "Filtered to selected rows (other rows removed)"
+            filter_expr = pl.col(RID).is_in(self.selected_rows)
         else:  # Search cursor value in current column
             message = "Filtered to rows matching cursor value (other rows removed)"
             cidx = self.cursor_col_idx
@@ -3565,16 +3622,26 @@ class DataFrameTable(DataTable):
         self.add_history(message, dirty=True)
 
         # Apply filter to dataframe with row indices
-        df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
+        df_filtered = self.df.lazy().filter(filter_expr).collect()
+        ok_rids = set(df_filtered[RID])
 
         # Update selected rows
-        selected_rows = [self.selected_rows[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))]
+        if self.selected_rows:
+            selected_rows = {rid for rid in self.selected_rows if rid in ok_rids}
+        else:
+            selected_rows = set()
 
         # Update matches
-        matches = {ridx: self.matches[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))}
+        if self.matches:
+            matches = {rid: cols for rid, cols in self.matches.items() if rid in ok_rids}
+        else:
+            matches = defaultdict(set)
 
         # Update dataframe
-        self.reset_df(df_filtered.drop(RIDX))
+        self.reset_df(df_filtered)
+
+        # Clear view for filter mode
+        self.df_view = None
 
         # Restore selected rows and matches
         self.selected_rows = selected_rows
@@ -3583,7 +3650,7 @@ class DataFrameTable(DataTable):
         # Recreate table for display
         self.setup_table()
 
-        self.notify(f"{message}. Now showing [$success]{len(self.df)}[/] rows", title="Filter")
+        self.notify(f"{message}. Now showing [$success]{len(self.df)}[/] rows.", title="Filter")
 
     # Copy & Save
     def do_copy_to_clipboard(self, content: str, message: str) -> None:
@@ -3609,20 +3676,24 @@ class DataFrameTable(DataTable):
         except FileNotFoundError:
             self.notify("Error copying to clipboard", title="Clipboard", severity="error", timeout=10)
 
-    def do_save_to_file(
-        self, title: str = "Save to File", all_tabs: bool | None = None, task_after_save: str | None = None
-    ) -> None:
+    def do_save_to_file(self, all_tabs: bool | None = None, task_after_save: str | None = None) -> None:
         """Open screen to save file."""
         self._task_after_save = task_after_save
+        tab_count = len(self.app.tabs)
+        save_all = tab_count > 1 and all_tabs is not False
+
+        filepath = Path(self.filename)
+        if save_all:
+            ext = filepath.suffix.lower()
+            if ext in (".xlsx", ".xls"):
+                filename = self.filename
+            else:
+                filename = "all-tabs.xlsx"
+        else:
+            filename = str(filepath.with_stem(self.tabname))
 
-        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),
+            SaveFileScreen(filename, save_all=save_all, tab_count=tab_count),
             callback=self.save_to_file,
         )
 
@@ -3630,10 +3701,8 @@ class DataFrameTable(DataTable):
         """Handle result from SaveFileScreen."""
         if result is None:
             return
-        filename, all_tabs, overwrite_prompt = result
-
-        # Whether to save all tabs (for Excel files)
-        self._all_tabs = all_tabs
+        filename, save_all, overwrite_prompt = result
+        self._save_all = save_all
 
         # Check if file exists
         if overwrite_prompt and Path(filename).exists():
@@ -3652,7 +3721,7 @@ class DataFrameTable(DataTable):
         else:
             # Go back to SaveFileScreen to allow user to enter a different name
             self.app.push_screen(
-                SaveFileScreen(self._pending_filename),
+                SaveFileScreen(self._pending_filename, save_all=self._save_all),
                 callback=self.save_to_file,
             )
 
@@ -3660,7 +3729,7 @@ class DataFrameTable(DataTable):
         """Actually save the dataframe to a file."""
         filepath = Path(filename)
         ext = filepath.suffix.lower()
-        if ext.endswith(".gz"):
+        if ext == ".gz":
             ext = Path(filename).with_suffix("").suffix.lower()
 
         fmt = ext.removeprefix(".")
@@ -3672,30 +3741,28 @@ class DataFrameTable(DataTable):
             )
             fmt = "csv"
 
-        # Add to history
-        self.add_history(f"Saved dataframe to [$success]{filename}[/]")
-
+        df = (self.df if self.df_view is None else self.df_view).select(pl.exclude(RID))
         try:
             if fmt == "csv":
-                self.df.write_csv(filename)
+                df.write_csv(filename)
             elif fmt in ("tsv", "tab"):
-                self.df.write_csv(filename, separator="\t")
+                df.write_csv(filename, separator="\t")
             elif fmt in ("xlsx", "xls"):
                 self.save_excel(filename)
             elif fmt == "json":
-                self.df.write_json(filename)
+                df.write_json(filename)
             elif fmt == "ndjson":
-                self.df.write_ndjson(filename)
+                df.write_ndjson(filename)
             elif fmt == "parquet":
-                self.df.write_parquet(filename)
+                df.write_parquet(filename)
             else:  # Fallback to CSV
-                self.df.write_csv(filename)
+                df.write_csv(filename)
 
             # Update current filename
             self.filename = filename
 
             # Reset dirty flag after save
-            if self._all_tabs:
+            if self._save_all:
                 tabs: dict[TabPane, DataFrameTable] = self.app.tabs
                 for table in tabs.values():
                     table.dirty = False
@@ -3709,7 +3776,7 @@ class DataFrameTable(DataTable):
                     self.app.exit()
 
             # From ConfirmScreen callback, so notify accordingly
-            if self._all_tabs:
+            if self._save_all:
                 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")
@@ -3722,16 +3789,18 @@ class DataFrameTable(DataTable):
         """Save to an Excel file."""
         import xlsxwriter
 
-        if not self._all_tabs or len(self.app.tabs) == 1:
+        if not self._save_all or len(self.app.tabs) == 1:
             # Single tab - save directly
-            self.df.write_excel(filename)
+            df = (self.df if self.df_view is None else self.df_view).select(pl.exclude(RID))
+            df.write_excel(filename, worksheet=self.tabname)
         else:
             # Multiple tabs - use xlsxwriter to create multiple sheets
             with xlsxwriter.Workbook(filename) as wb:
                 tabs: dict[TabPane, DataFrameTable] = self.app.tabs
                 for table in tabs.values():
                     worksheet = wb.add_worksheet(table.tabname)
-                    table.df.write_excel(workbook=wb, worksheet=worksheet)
+                    df = (table.df if table.df_view is None else table.df_view).select(pl.exclude(RID))
+                    df.write_excel(workbook=wb, worksheet=worksheet)
 
     # SQL Interface
     def do_simple_sql(self) -> None:
@@ -3775,19 +3844,17 @@ class DataFrameTable(DataTable):
             sql: The SQL query string to execute.
         """
 
-        import re
-
-        RE_FROM_SELF = re.compile(r"\bfrom\s+self\b", re.IGNORECASE)
+        sql = sql.replace("$#", f"(`{RID}` + 1)")
+        if RID not in sql and "*" not in sql:
+            # Ensure RID is selected
+            import re
 
-        sql = RE_FROM_SELF.sub(f", `{RIDX}` FROM self", sql)
+            RE_FROM_SELF = re.compile(r"\bFROM\s+self\b", re.IGNORECASE)
+            sql = RE_FROM_SELF.sub(f", `{RID}` FROM self", sql)
 
         # Execute the SQL query
         try:
-            lf = self.df.lazy().with_row_index(RIDX)
-            if self.has_hidden_rows:
-                lf = lf.filter(self.visible_rows)
-
-            df_filtered = lf.sql(sql).collect()
+            df_filtered = self.df.lazy().sql(sql).collect()
 
             if not len(df_filtered):
                 self.notify(
@@ -3795,38 +3862,34 @@ class DataFrameTable(DataTable):
                 )
                 return
 
-            # Add to history
-            self.add_history(f"SQL Query:\n[$success]{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
-                # Update selected rows
-                selected_rows = [self.selected_rows[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))]
-
-                # Update matches
-                matches = {ridx: self.matches[df_filtered[RIDX][ridx]] for ridx in range(len(df_filtered))}
-
-                # Update dataframe
-                self.reset_df(df_filtered.drop(RIDX))
-
-                # Restore selected rows and matches
-                self.selected_rows = selected_rows
-                self.matches = matches
         except Exception as e:
             self.notify(f"Error executing SQL query [$error]{sql}[/]", title="SQL Query", severity="error", timeout=10)
             self.log(f"Error executing SQL query `{sql}`: {str(e)}")
             return
 
+        # Add to history
+        self.add_history(f"SQL Query:\n[$success]{sql}[/]", dirty=not view)
+
+        # Create a view of self.df as a copy
+        if view and self.df_view is None:
+            self.df_view = self.df
+
+        # Clear view for filter mode
+        if not view:
+            self.df_view = None
+
+        # Update dataframe
+        self.df = df_filtered
+        ok_rids = set(df_filtered[RID])
+
+        # Update selected rows
+        if self.selected_rows:
+            self.selected_rows.intersection_update(ok_rids)
+
+        # Update matches
+        if self.matches:
+            self.matches = {rid: cols for rid, cols in self.matches.items() if rid in ok_rids}
+
         # Recreate table for display
         self.setup_table()