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

dataframe_textual/data_frame_table.py

@@ -9,8 +9,10 @@ from typing import Any
 
 import polars as pl
 from rich.text import Text
+from textual import work
 from textual.coordinate import Coordinate
 from textual.events import Click
+from textual.render import measure
 from textual.widgets import DataTable, TabPane
 from textual.widgets._data_table import (
     CellDoesNotExist,
@@ -30,9 +32,11 @@ from .common import (
     format_row,
     get_next_item,
     rindex,
+    sleep_async,
     tentative_expr,
     validate_expr,
 )
+from .sql_screen import AdvancedSqlScreen, SimpleSqlScreen
 from .table_screen import FrequencyScreen, RowDetailScreen, StatisticsScreen
 from .yes_no_screen import (
     AddColumnScreen,
@@ -47,6 +51,15 @@ from .yes_no_screen import (
     SearchScreen,
 )
 
+# Color for highlighting selections and matches
+HIGHLIGHT_COLOR = "red"
+
+# Warning threshold for loading rows
+WARN_ROWS_THRESHOLD = 50_000
+
+# Maximum width for string columns before truncation
+STRING_WIDTH_CAP = 35
+
 
 @dataclass
 class History:
@@ -97,6 +110,8 @@ class DataFrameTable(DataTable):
         - **↑↓←→** - 🎯 Move cursor (cell/row/column)
         - **g** - ⬆️ Jump to first row
         - **G** - ⬇️ Jump to last row
+        - **Ctrl+F** - 📜 Page down
+        - **Ctrl+B** - 📜 Page up
         - **PgUp/PgDn** - 📜 Page up/down
 
         ## 👁️ View & Display
@@ -106,6 +121,7 @@ class DataFrameTable(DataTable):
         - **S** - 📊 Show statistics for entire dataframe
         - **h** - 👁️ Hide current column
         - **H** - 👀 Show all hidden rows/columns
+        - **_** - 📏 Expand column to full width
         - **z** - 📌 Freeze rows and columns
         - **~** - 🏷️ Toggle row labels
         - **,** - 🔢 Toggle thousand separator for numeric display
@@ -121,8 +137,8 @@ class DataFrameTable(DataTable):
         - **\\\\** - 🔎 Search in current column using cursor value
         - **/** - 🔎 Find in current column with cursor value
         - **?** - 🔎 Find in current column with expression
-        - **f** - 🌐 Global find using cursor value
-        - **Ctrl+f** - 🌐 Global find with expression
+        - **;** - 🌐 Global find using cursor value
+        - **:** - 🌐 Global find with expression
         - **n** - ⬇️ Go to next match
         - **N** - ⬆️ Go to previous match
         - **v** - 👁️ View/filter rows by cell or selected rows
@@ -142,6 +158,10 @@ class DataFrameTable(DataTable):
         - **"** - 📍 Filter to show only selected rows
         - **T** - 🧹 Clear all selections and matches
 
+        ## 🔍 SQL Interface
+        - **l** - 💬 Open simple SQL interface (select columns & WHERE clause)
+        - **L** - 🔎 Open advanced SQL interface (full SQL queries)
+
         ## ✏️ Edit & Modify
         - **Double-click** - ✍️ Edit cell or rename column header
         - **e** - ✍️ Edit current cell
@@ -153,12 +173,9 @@ class DataFrameTable(DataTable):
         - **Ctrl+X** - ❌ Delete row and those above
         - **delete** - ❌ Clear current cell (set to NULL)
         - **-** - ❌ Delete current column
-        - **_** - ❌ Delete column and those after
-        - **Ctrl+-** - ❌ Delete column and those before
         - **d** - 📋 Duplicate current column
         - **D** - 📋 Duplicate current row
 
-
         ## 🎯 Reorder
         - **Shift+↑↓** - ⬆️⬇️ Move row up/down
         - **Shift+←→** - ⬅️➡️ Move column left/right
@@ -187,6 +204,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"),
         # Display
         ("h", "hide_column", "Hide column"),
         ("H", "show_hidden_rows_columns", "Show hidden rows/columns"),
@@ -194,6 +213,7 @@ class DataFrameTable(DataTable):
         ("K", "cycle_cursor_type", "Cycle cursor mode"),  # `K`
         ("z", "freeze_row_column", "Freeze rows/columns"),
         ("comma", "show_thousand_separator", "Toggle thousand separator"),  # `,`
+        ("underscore", "expand_column", "Expand column to full width"),  # `_`
         # Copy
         ("c", "copy_cell", "Copy cell to clipboard"),
         ("ctrl+c", "copy_column", "Copy column to clipboard"),
@@ -208,9 +228,10 @@ class DataFrameTable(DataTable):
         # Sort
         ("left_square_bracket", "sort_ascending", "Sort ascending"),  # `[`
         ("right_square_bracket", "sort_descending", "Sort descending"),  # `]`
-        # View
+        # View & Filter
         ("v", "view_rows", "View rows"),
         ("V", "view_rows_expr", "View rows by expression"),
+        ("quotation_mark", "filter_rows", "Filter selected"),  # `"`
         # Search
         ("backslash", "search_cursor_value", "Search column with cursor value"),  # `\`
         ("vertical_line", "search_expr", "Search column with expression"),  # `|`
@@ -219,23 +240,20 @@ class DataFrameTable(DataTable):
         # Find
         ("slash", "find_cursor_value", "Find in column with cursor value"),  # `/`
         ("question_mark", "find_expr", "Find in column with expression"),  # `?`
-        ("f", "find_cursor_value('global')", "Global find with cursor value"),  # `f`
-        ("ctrl+f", "find_expr('global')", "Global find with expression"),  # `Ctrl+F`
+        ("semicolon", "find_cursor_value('global')", "Global find with cursor value"),  # `;`
+        ("colon", "find_expr('global')", "Global find with expression"),  # `:`
         ("n", "next_match", "Go to next match"),  # `n`
         ("N", "previous_match", "Go to previous match"),  # `Shift+n`
         # Replace
         ("r", "replace", "Replace in column"),  # `r`
         ("R", "replace_global", "Replace global"),  # `Shift+R`
         # Selection
-        ("apostrophe", "make_selections", "Toggle row selection"),  # `'`
+        ("apostrophe", "toggle_row_selection", "Toggle row selection"),  # `'`
         ("t", "toggle_selections", "Toggle all row selections"),
         ("T", "clear_selections_and_matches", "Clear selections"),
-        ("quotation_mark", "filter_selected_rows", "Filter selected"),  # `"`
         # Delete
         ("delete", "clear_cell", "Clear cell"),
         ("minus", "delete_column", "Delete column"),  # `-`
-        ("underscore", "delete_column_and_after", "Delete column and those after"),  # `_`
-        ("ctrl+minus", "delete_column_and_before", "Delete column and those before"),  # `Ctrl+-`
         ("x", "delete_row", "Delete row"),
         ("X", "delete_row_and_below", "Delete row and those below"),
         ("ctrl+x", "delete_row_and_up", "Delete row and those up"),
@@ -254,11 +272,14 @@ class DataFrameTable(DataTable):
         ("shift+up", "move_row_up", "Move row up"),
         ("shift+down", "move_row_down", "Move row down"),
         # Type Conversion
-        ("number_sign", "cast_column_dtype('int')", "Cast column dtype to int"),  # `#`
-        ("percent_sign", "cast_column_dtype('float')", "Cast column dtype to float"),  # `%`
-        ("exclamation_mark", "cast_column_dtype('bool')", "Cast column dtype to bool"),  # `!`
-        ("dollar_sign", "cast_column_dtype('string')", "Cast column dtype to string"),  # `$`
+        ("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"),
@@ -266,14 +287,14 @@ class DataFrameTable(DataTable):
     ]
     # fmt: on
 
-    def __init__(self, df: pl.DataFrame | pl.LazyFrame, filename: str = "", name: str = "", **kwargs) -> None:
+    def __init__(self, df: pl.DataFrame, filename: str = "", name: str = "", **kwargs) -> None:
         """Initialize the DataFrameTable with a dataframe and manage all state.
 
         Sets up the table widget with display configuration, loads the dataframe, and
         initializes all state tracking variables for row/column operations.
 
         Args:
-            df: The Polars DataFrame or LazyFrame to display and edit.
+            df: The Polars DataFrame to display and edit.
             filename: Optional source filename for the data (used in save operations). Defaults to "".
             name: Optional display name for the table tab. Defaults to "" (uses filename stem).
             **kwargs: Additional keyword arguments passed to the parent DataTable widget.
@@ -284,8 +305,8 @@ class DataFrameTable(DataTable):
         super().__init__(name=(name or Path(filename).stem), **kwargs)
 
         # DataFrame state
-        self.lazyframe = df.lazy()  # Original dataframe
-        self.df = self.lazyframe.collect()  # Internal/working dataframe
+        self.dataframe = df  # Original dataframe
+        self.df = df  # Internal/working dataframe
         self.filename = filename  # Current filename
 
         # Pagination & Loading
@@ -522,6 +543,10 @@ class DataFrameTable(DataTable):
             ridx: Row index (0-based) in the dataframe.
             cidx: Column index (0-based) in the dataframe.
         """
+        # Ensure the target row is loaded
+        if ridx >= self.loaded_rows:
+            self._load_rows(stop=ridx + self.BATCH_SIZE)
+
         row_key = str(ridx)
         col_key = self.df.columns[cidx]
         row_idx, col_idx = self.get_cell_coordinate(row_key, col_key)
@@ -586,8 +611,16 @@ class DataFrameTable(DataTable):
 
     def action_jump_bottom(self) -> None:
         """Jump to the bottom of the table."""
-        self._load_rows()
-        self.move_cursor(row=self.row_count - 1)
+        self._load_rows(move_to_end=True)
+
+    def action_forward_page(self) -> None:
+        """Scroll down one page."""
+        super().action_page_down()
+        self._check_and_load_more()
+
+    def action_backward_page(self) -> None:
+        """Scroll up one page."""
+        super().action_page_up()
 
     def action_view_row_detail(self) -> None:
         """View details of the current row."""
@@ -597,18 +630,14 @@ class DataFrameTable(DataTable):
         """Delete the current column."""
         self._delete_column()
 
-    def action_delete_column_and_after(self) -> None:
-        """Delete the current column and those after."""
-        self._delete_column(more="after")
-
-    def action_delete_column_and_before(self) -> None:
-        """Delete the current column and those before."""
-        self._delete_column(more="before")
-
     def action_hide_column(self) -> None:
         """Hide the current column."""
         self._hide_column()
 
+    def action_expand_column(self) -> None:
+        """Expand the current column to its full width."""
+        self._expand_column()
+
     def action_show_hidden_rows_columns(self) -> None:
         """Show all hidden rows/columns."""
         self._show_hidden_rows_columns()
@@ -701,17 +730,17 @@ class DataFrameTable(DataTable):
         """Replace values across all columns."""
         self._replace_global()
 
-    def action_make_selections(self) -> None:
+    def action_toggle_row_selection(self) -> None:
         """Toggle selection for the current row."""
-        self._make_selections()
+        self._toggle_row_selection()
 
     def action_toggle_selections(self) -> None:
         """Toggle all row selections."""
         self._toggle_selections()
 
-    def action_filter_selected_rows(self) -> None:
+    def action_filter_rows(self) -> None:
         """Filter to show only selected rows."""
-        self._filter_selected_rows()
+        self._filter_rows()
 
     def action_delete_row(self) -> None:
         """Delete the current row."""
@@ -854,6 +883,14 @@ class DataFrameTable(DataTable):
         """Go to the previous selected row."""
         self._previous_selected_row()
 
+    def action_simple_sql(self) -> None:
+        """Open the SQL interface screen."""
+        self._simple_sql()
+
+    def action_advanced_sql(self) -> None:
+        """Open the advanced SQL interface screen."""
+        self._advanced_sql()
+
     def on_mouse_scroll_down(self, event) -> None:
         """Load more rows when scrolling down with mouse."""
         self._check_and_load_more()
@@ -865,9 +902,12 @@ class DataFrameTable(DataTable):
         Row keys are 0-based indices, which map directly to dataframe row indices.
         Column keys are header names from the dataframe.
         """
+        self.loaded_rows = 0
+        self.show_row_labels = True
+
         # Reset to original dataframe
         if reset:
-            self.df = self.lazyframe.collect()
+            self.df = self.dataframe
             self.loaded_rows = 0
             self.sorted_columns = {}
             self.hidden_columns = set()
@@ -878,35 +918,109 @@ class DataFrameTable(DataTable):
             self.matches = defaultdict(set)
 
         # Lazy load up to INITIAL_BATCH_SIZE visible rows
-        stop, visible_count = len(self.df), 0
+        stop, visible_count = self.INITIAL_BATCH_SIZE, 0
         for row_idx, visible in enumerate(self.visible_rows):
             if not visible:
                 continue
             visible_count += 1
-            if visible_count >= self.INITIAL_BATCH_SIZE:
-                stop = row_idx + 1
+            if visible_count > self.INITIAL_BATCH_SIZE:
+                stop = row_idx + self.BATCH_SIZE
                 break
+        else:
+            stop = row_idx + self.BATCH_SIZE
+
+        # # Ensure all selected rows or matches are loaded
+        # stop = max(stop, rindex(self.selected_rows, True) + 1)
+        # stop = max(stop, max(self.matches.keys(), default=0) + 1)
 
         # Save current cursor position before clearing
         row_idx, col_idx = self.cursor_coordinate
 
         self._setup_columns()
         self._load_rows(stop)
-        self._do_highlight()
 
         # 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]:
+        """Determine optimal width for each column based on data type and content.
+
+        For String columns:
+        - Minimum width: length of column label
+        - Ideal width: maximum width of all cells in the column
+        - If space constrained: find appropriate width smaller than maximum
+
+        For non-String columns:
+        - Return None to let Textual auto-determine width
+
+        Returns:
+            dict[str, int]: Mapping of column name to width (None for auto-sizing columns).
+        """
+        column_widths = {}
+
+        # Get available width for the table (with some padding for borders/scrollbar)
+        available_width = self.size.width - 4  # Account for borders and scrollbar
+
+        # Calculate how much width we need for string columns first
+        string_cols = [col for col, dtype in zip(self.df.columns, self.df.dtypes) if dtype == pl.String]
+
+        # No string columns, let TextualDataTable auto-size all columns
+        if not string_cols:
+            return column_widths
+
+        # Sample a reasonable number of rows to calculate widths (don't scan entire dataframe)
+        sample_size = min(self.INITIAL_BATCH_SIZE, len(self.df))
+        sample_lf = self.df.lazy().slice(0, sample_size)
+
+        # Determine widths for each column
+        for col, dtype in zip(self.df.columns, self.df.dtypes):
+            if col in self.hidden_columns:
+                continue
+
+            # Get column label width
+            # Add padding for sort indicators if any
+            label_width = measure(self.app.console, col, 1) + 2
+
+            try:
+                # Get sample values from the column
+                sample_values = sample_lf.select(col).collect().get_column(col).to_list()
+
+                # Find maximum width in sample
+                max_cell_width = max(
+                    (measure(self.app.console, str(val), 1) for val in sample_values if val),
+                    default=label_width,
+                )
+
+                # Set column width to max of label and sampled data (capped at reasonable max)
+                max_width = max(label_width, max_cell_width)
+            except Exception:
+                # If any error, let Textual auto-size
+                max_width = label_width
+
+            if dtype == pl.String:
+                column_widths[col] = max_width
+
+            available_width -= max_width
+
+        # If there's no more available width, auto-size remaining columns
+        if available_width < 0:
+            for col in column_widths:
+                if column_widths[col] > STRING_WIDTH_CAP:
+                    column_widths[col] = STRING_WIDTH_CAP  # Cap string columns
+
+        return column_widths
+
     def _setup_columns(self) -> None:
         """Clear table and setup columns.
 
         Column keys are header names from the dataframe.
         Column labels contain column names from the dataframe, with sort indicators if applicable.
         """
-        self.loaded_rows = 0
         self.clear(columns=True)
-        self.show_row_labels = True
+
+        # Get optimal column widths
+        column_widths = self._determine_column_widths()
 
         # Add columns with justified headers
         for col, dtype in zip(self.df.columns, self.df.dtypes):
@@ -924,45 +1038,120 @@ class DataFrameTable(DataTable):
             else:  # No break occurred, so column is not sorted
                 cell_value = col
 
-            self.add_column(Text(cell_value, justify=DtypeConfig(dtype).justify), key=col)
+            # Get the width for this column (None means auto-size)
+            width = column_widths.get(col)
 
-    def _load_rows(self, stop: int | None = None) -> None:
-        """Load a batch of rows into the table.
+            self.add_column(Text(cell_value, justify=DtypeConfig(dtype).justify), key=col, width=width)
 
-        Row keys are 0-based indices as strings, which map directly to dataframe row indices.
-        Row labels are 1-based indices as strings.
+    def _load_rows(self, stop: int | None = None, move_to_end: bool = False) -> None:
+        """Load a batch of rows into the table (synchronous wrapper).
 
         Args:
-            stop: Stop loading rows when this index is reached. If None, load until the end of the dataframe.
+            stop: Stop loading rows when this index is reached.
+                  If None, load until the end of the dataframe.
         """
         if stop is None or stop > len(self.df):
             stop = len(self.df)
 
+        # If already loaded enough rows, just move cursor if needed
         if stop <= self.loaded_rows:
+            if move_to_end:
+                self.move_cursor(row=self.row_count - 1)
+
             return
 
-        start = self.loaded_rows
-        df_slice = self.df.slice(start, stop - start)
+        # 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_batch(next_stop)
+
+            # If there's more to load, yield to event loop with delay
+            if next_stop < stop:
+                await sleep_async(0.05)  # 50ms delay to allow UI updates
+                self._load_rows_async(stop, move_to_end=move_to_end)
+                return
+
+        # 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:
+        """Load a batch of rows into the table.
+
+        Row keys are 0-based indices as strings, which map directly to dataframe row indices.
+        Row labels are 1-based indices as strings.
+
+        Args:
+            stop: Stop loading rows when this index is reached.
+        """
+        try:
+            start = self.loaded_rows
+            df_slice = self.df.slice(start, stop - start)
+
+            for ridx, row in enumerate(df_slice.rows(), start):
+                if not self.visible_rows[ridx]:
+                    continue  # Skip hidden rows
 
-        for row_idx, row in enumerate(df_slice.rows(), start):
-            if not self.visible_rows[row_idx]:
-                continue  # Skip hidden rows
+                is_selected = self.selected_rows[ridx]
+                match_cols = self.matches.get(ridx, set())
 
-            vals, dtypes = [], []
-            for val, col, dtype in zip(row, self.df.columns, self.df.dtypes):
-                if col in self.hidden_columns:
-                    continue  # Skip hidden columns
-                vals.append(val)
-                dtypes.append(dtype)
-            formatted_row = format_row(vals, dtypes, thousand_separator=self.thousand_separator)
+                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
 
-            # Always add labels so they can be shown/hidden via CSS
-            self.add_row(*formatted_row, key=str(row_idx), label=str(row_idx + 1))
+                    vals.append(val)
+                    dtypes.append(dtype)
 
-        # Update loaded rows count
-        self.loaded_rows = stop
+                    # Highlight entire row with selection or cells with matches
+                    styles.append(HIGHLIGHT_COLOR if is_selected or cidx in match_cols else None)
 
-        # self.notify(f"Loaded [$accent]{stop}/{len(self.df)}[/] rows from [$success]{self.name}[/]", title="Load")
+                formatted_row = format_row(vals, dtypes, styles=styles, thousand_separator=self.thousand_separator)
+
+                # Always add labels so they can be shown/hidden via CSS
+                self.add_row(*formatted_row, key=str(ridx), label=str(ridx + 1))
+
+            # Update loaded rows count
+            self.loaded_rows = stop
+
+            # self.notify(f"Loaded [$accent]{self.loaded_rows}/{len(self.df)}[/] rows from [$success]{self.name}[/]", title="Load")
+            self.log(f"Loaded {self.loaded_rows}/{len(self.df)} rows from `{self.filename or self.name}`")
+
+        except Exception as e:
+            self.notify("Error loading rows", title="Load", severity="error")
+            self.log(f"Error loading rows: {str(e)}")
 
     def _check_and_load_more(self) -> None:
         """Check if we need to load more rows and load them."""
@@ -977,6 +1166,7 @@ class DataFrameTable(DataTable):
         if bottom_visible_row >= self.loaded_rows - 10:
             self._load_rows(self.loaded_rows + self.BATCH_SIZE)
 
+    # Highlighting
     def _do_highlight(self, force: bool = False) -> None:
         """Update all rows, highlighting selected ones and restoring others to default.
 
@@ -1013,7 +1203,7 @@ class DataFrameTable(DataTable):
                 need_update = False
 
                 if is_selected or col_idx in match_cols:
-                    cell_text.style = "red"
+                    cell_text.style = HIGHLIGHT_COLOR
                     need_update = True
                 elif force:
                     # Restore original style based on dtype
@@ -1062,7 +1252,7 @@ class DataFrameTable(DataTable):
         self.cursor_coordinate = history.cursor_coordinate
         self.matches = {k: v.copy() for k, v in history.matches.items()} if history.matches else defaultdict(set)
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
     def _add_history(self, description: str) -> None:
@@ -1080,16 +1270,16 @@ class DataFrameTable(DataTable):
             self.notify("No actions to undo", title="Undo", severity="warning")
             return
 
-        # Save current state for redo
-        self.history = self._create_history("Redo state")
-
         # Pop the last history state for undo
         history = self.histories.pop()
 
+        # Save current state for redo
+        self.history = self._create_history(history.description)
+
         # Restore state
         self._apply_history(history)
 
-        # self.notify(f"Reverted: {history.description}", title="Undo")
+        self.notify(f"Reverted: {history.description}", title="Undo")
 
     def _redo(self) -> None:
         """Redo the last undone action."""
@@ -1097,8 +1287,10 @@ class DataFrameTable(DataTable):
             self.notify("No actions to redo", title="Redo", severity="warning")
             return
 
+        description = self.history.description
+
         # Save current state for undo
-        self._add_history("Undo state")
+        self._add_history(description)
 
         # Restore state
         self._apply_history(self.history)
@@ -1106,9 +1298,16 @@ class DataFrameTable(DataTable):
         # Clear redo state
         self.history = None
 
-        # self.notify(f"Reapplied: {history.description}", title="Redo")
+        self.notify(f"Reapplied: {description}", title="Redo")
+
+    # Display
+    def _cycle_cursor_type(self) -> None:
+        """Cycle through cursor types: cell -> row -> column -> cell."""
+        next_type = get_next_item(CURSOR_TYPES, self.cursor_type)
+        self.cursor_type = next_type
+
+        # self.notify(f"Changed cursor type to [$success]{next_type}[/]", title="Cursor")
 
-    # View
     def _view_row_detail(self) -> None:
         """Open a modal screen to view the selected row's details."""
         ridx = self.cursor_row_idx
@@ -1161,11 +1360,127 @@ class DataFrameTable(DataTable):
         if fixed_columns >= 0:
             self.fixed_columns = fixed_columns
 
+        # self.notify(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns", title="Pin")
+
+    def _hide_column(self) -> None:
+        """Hide the currently selected column from the table display."""
+        col_key = self.cursor_col_key
+        col_name = col_key.value
+        col_idx = self.cursor_column
+
+        # Add to history
+        self._add_history(f"Hid column [$success]{col_name}[/]")
+
+        # Remove the column from the table display (but keep in dataframe)
+        self.remove_column(col_key)
+
+        # Track hidden columns
+        self.hidden_columns.add(col_name)
+
+        # Move cursor left if we hid the last column
+        if col_idx >= len(self.columns):
+            self.move_cursor(column=len(self.columns) - 1)
+
+        # self.notify(f"Hid column [$accent]{col_name}[/]. Press [$success]H[/] to show hidden columns", title="Hide")
+
+    def _expand_column(self) -> None:
+        """Expand the current column to show the widest cell in the loaded data."""
+        col_idx = self.cursor_col_idx
+        col_key = self.cursor_col_key
+        col_name = col_key.value
+        dtype = self.df.dtypes[col_idx]
+
+        # Only expand string columns
+        if dtype != pl.String:
+            return
+
+        # Calculate the maximum width across all loaded rows
+        max_width = len(col_name) + 2  # Start with column name width + padding
+
+        try:
+            # Scan through all loaded rows that are visible to find max width
+            for row_idx in range(self.loaded_rows):
+                if not self.visible_rows[row_idx]:
+                    continue  # Skip hidden rows
+                cell_value = str(self.df.item(row_idx, col_idx))
+                cell_width = measure(self.app.console, cell_value, 1)
+                max_width = max(max_width, cell_width)
+
+            # Update the column width
+            col = self.columns[col_key]
+            col.width = max_width
+
+            # Force a refresh
+            self._update_count += 1
+            self._require_update_dimensions = True
+            self.refresh(layout=True)
+
+            # self.notify(f"Expanded column [$success]{col_name}[/] to width [$accent]{max_width}[/]", title="Expand")
+        except Exception as e:
+            self.notify("Error expanding column", title="Expand", severity="error")
+            self.log(f"Error expanding column `{col_name}`: {str(e)}")
+
+    def _show_hidden_rows_columns(self) -> None:
+        """Show all hidden rows/columns by recreating the table."""
+        # Get currently visible columns
+        visible_cols = set(col.key for col in self.ordered_columns)
+
+        hidden_row_count = sum(0 if visible else 1 for visible in self.visible_rows)
+        hidden_col_count = sum(0 if col in visible_cols else 1 for col in self.df.columns)
+
+        if not hidden_row_count and not hidden_col_count:
+            self.notify("No hidden columns or rows to show", title="Show", severity="warning")
+            return
+
+        # Add to history
+        self._add_history("Showed hidden rows/columns")
+
+        # Clear hidden rows/columns tracking
+        self.visible_rows = [True] * len(self.df)
+        self.hidden_columns.clear()
+
+        # Recreate table for display
+        self._setup_table()
+
         self.notify(
-            f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns",
-            title="Pin",
+            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.
+
+        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.
+
+        Returns:
+            None
+        """
+        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
+
+        # Count how many URLs were made clickable
+        url_count = 0
+
+        # 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
+
+        if url_count:
+            self.notify(
+                f"Use Ctrl/Cmd click to open the links in column [$success]{col_key.value}[/]", title="Hyperlink"
+            )
+
     # Delete & Move
     def _delete_column(self, more: str = None) -> None:
         """Remove the currently selected column from the table."""
@@ -1184,7 +1499,7 @@ class DataFrameTable(DataTable):
                 col_names_to_remove.append(col_key.value)
                 col_keys_to_remove.append(col_key)
 
-            descr = f"Removed column [$success]{col_name}[/] and all columns before"
+            message = f"Removed column [$success]{col_name}[/] and all columns before"
 
         # Remove all columns after the current column
         elif more == "after":
@@ -1193,16 +1508,16 @@ class DataFrameTable(DataTable):
                 col_names_to_remove.append(col_key.value)
                 col_keys_to_remove.append(col_key)
 
-            descr = f"Removed column [$success]{col_name}[/] and all columns after"
+            message = f"Removed column [$success]{col_name}[/] and all columns after"
 
         # Remove only the current column
         else:
             col_names_to_remove.append(col_name)
             col_keys_to_remove.append(col_key)
-            descr = f"Removed column [$success]{col_name}[/]"
+            message = f"Removed column [$success]{col_name}[/]"
 
         # Add to history
-        self._add_history(descr)
+        self._add_history(message)
 
         # Remove the columns from the table display using the column names as keys
         for ck in col_keys_to_remove:
@@ -1229,55 +1544,7 @@ class DataFrameTable(DataTable):
         # Remove from dataframe
         self.df = self.df.drop(col_names_to_remove)
 
-        # self.notify(descr, title="Delete")
-
-    def _hide_column(self) -> None:
-        """Hide the currently selected column from the table display."""
-        col_key = self.cursor_col_key
-        col_name = col_key.value
-        col_idx = self.cursor_column
-
-        # Add to history
-        self._add_history(f"Hid column [$success]{col_name}[/]")
-
-        # Remove the column from the table display (but keep in dataframe)
-        self.remove_column(col_key)
-
-        # Track hidden columns
-        self.hidden_columns.add(col_name)
-
-        # Move cursor left if we hid the last column
-        if col_idx >= len(self.columns):
-            self.move_cursor(column=len(self.columns) - 1)
-
-        # self.notify(f"Hid column [$accent]{col_name}[/]. Press [$success]H[/] to show hidden columns", title="Hide")
-
-    def _show_hidden_rows_columns(self) -> None:
-        """Show all hidden rows/columns by recreating the table."""
-        # Get currently visible columns
-        visible_cols = set(col.key for col in self.ordered_columns)
-
-        hidden_row_count = sum(0 if visible else 1 for visible in self.visible_rows)
-        hidden_col_count = sum(0 if col in visible_cols else 1 for col in self.df.columns)
-
-        if not hidden_row_count and not hidden_col_count:
-            self.notify("No hidden columns or rows to show", title="Show", severity="warning")
-            return
-
-        # Add to history
-        self._add_history("Showed hidden rows/columns")
-
-        # Clear hidden rows/columns tracking
-        self.visible_rows = [True] * len(self.df)
-        self.hidden_columns.clear()
-
-        # Recreate table for display
-        self._setup_table()
-
-        self.notify(
-            f"Showed [$accent]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] hidden column(s)",
-            title="Show",
-        )
+        self.notify(message, title="Delete")
 
     def _duplicate_column(self) -> None:
         """Duplicate the currently selected column, inserting it right after the current column."""
@@ -1311,16 +1578,13 @@ class DataFrameTable(DataTable):
             new_matches[row_idx] = new_cols
         self.matches = new_matches
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
         # Move cursor to the new duplicated column
         self.move_cursor(column=col_idx + 1)
 
-        self.notify(
-            f"Duplicated column [$accent]{col_name}[/] as [$success]{new_col_name}[/]",
-            title="Duplicate",
-        )
+        # self.notify(f"Duplicated column [$accent]{col_name}[/] as [$success]{new_col_name}[/]", title="Duplicate")
 
     def _delete_row(self, more: str = None) -> None:
         """Delete rows from the table and dataframe.
@@ -1381,11 +1645,11 @@ class DataFrameTable(DataTable):
         # Clear all matches since row indices have changed
         self.matches = defaultdict(set)
 
-        # Recreate the table display
+        # Recreate table for display
         self._setup_table()
 
         deleted_count = old_count - len(self.df)
-        if deleted_count > 1:
+        if deleted_count > 0:
             self.notify(f"Deleted [$accent]{deleted_count}[/] row(s)", title="Delete")
 
     def _duplicate_row(self) -> None:
@@ -1420,7 +1684,7 @@ class DataFrameTable(DataTable):
                 new_matches[row_idx + 1] = cols
         self.matches = new_matches
 
-        # Recreate the table display
+        # Recreate table for display
         self._setup_table()
 
         # Move cursor to the new duplicated row
@@ -1503,7 +1767,7 @@ class DataFrameTable(DataTable):
                 return
             swap_idx = row_idx + 1
         else:
-            self.notify(f"Invalid direction: {direction}", title="Move", severity="error")
+            # Invalid direction
             return
 
         row_key = self.coordinate_to_cell_key((row_idx, 0)).row_key
@@ -1594,7 +1858,7 @@ class DataFrameTable(DataTable):
         # Update the dataframe
         self.df = df_sorted.drop(RIDX)
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
         # Restore cursor position on the sorted column
@@ -1607,7 +1871,7 @@ class DataFrameTable(DataTable):
         cidx = self.cursor_col_idx if cidx is None else cidx
         col_name = self.df.columns[cidx]
 
-        # Save current state to history
+        # Add to history
         self._add_history(f"Edited cell [$success]({ridx + 1}, {col_name})[/]")
 
         # Push the edit modal screen
@@ -1653,9 +1917,10 @@ class DataFrameTable(DataTable):
             col_key = col_name
             self.update_cell(row_key, col_key, formatted_value, update_width=True)
 
-            self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit")
+            # self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit")
         except Exception as e:
-            self.notify(f"Failed to update cell: {str(e)}", title="Edit", severity="error")
+            self.notify("Error updating cell", title="Edit", severity="error")
+            self.log(f"Error updating cell: {str(e)}")
 
     def _edit_column(self) -> None:
         """Open modal to edit the entire column with an expression."""
@@ -1682,9 +1947,10 @@ class DataFrameTable(DataTable):
         # Check if term is a valid expression
         elif tentative_expr(term):
             try:
-                expr = validate_expr(term, self.df, cidx)
+                expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
-                self.notify(f"Error validating expression [$error]{term}[/]: {str(e)}", title="Edit", severity="error")
+                self.notify(f"Error validating expression [$error]{term}[/]", title="Edit", severity="error")
+                self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
 
         # Otherwise, treat term as a literal value
@@ -1695,7 +1961,7 @@ class DataFrameTable(DataTable):
                 expr = pl.lit(value)
             except Exception:
                 self.notify(
-                    f"Unable to convert [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
+                    f"Error converting [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
                     title="Edit",
                     severity="error",
                 )
@@ -1708,16 +1974,18 @@ class DataFrameTable(DataTable):
             # Apply the expression to the column
             self.df = self.df.with_columns(expr.alias(col_name))
         except Exception as e:
-            self.notify(f"Failed to apply expression: [$error]{str(e)}[/]", title="Edit", severity="error")
+            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
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
-        self.notify(
-            f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]",
-            title="Edit",
-        )
+        # 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."""
@@ -1758,16 +2026,13 @@ class DataFrameTable(DataTable):
             self.hidden_columns.remove(col_name)
             self.hidden_columns.add(new_name)
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
         # Move cursor to the renamed column
         self.move_cursor(column=col_idx)
 
-        self.notify(
-            f"Renamed column [$success]{col_name}[/] to [$success]{new_name}[/]",
-            title="Column",
-        )
+        # self.notify(f"Renamed column [$success]{col_name}[/] to [$success]{new_name}[/]", title="Column")
 
     def _clear_cell(self) -> None:
         """Clear the current cell by setting its value to None."""
@@ -1795,9 +2060,10 @@ class DataFrameTable(DataTable):
 
             self.update_cell(row_key, col_key, formatted_value)
 
-            self.notify(f"Cell cleared to [$success]{NULL_DISPLAY}[/]", title="Clear")
+            # self.notify(f"Cell cleared to [$success]{NULL_DISPLAY}[/]", title="Clear")
         except Exception as e:
-            self.notify(f"Failed to clear cell: {str(e)}", title="Clear", severity="error")
+            self.notify("Error clearing cell", title="Clear", severity="error")
+            self.log(f"Error clearing cell: {str(e)}")
             raise e
 
     def _add_column(self, col_name: str = None, col_value: pl.Expr = None) -> None:
@@ -1834,15 +2100,16 @@ class DataFrameTable(DataTable):
             select_cols = cols_before + [new_name] + cols_after
             self.df = self.df.with_columns(new_col).select(select_cols)
 
-            # Recreate the table display
+            # Recreate table for display
             self._setup_table()
 
             # Move cursor to the new column
             self.move_cursor(column=cidx + 1)
 
-            self.notify(f"Added column [$success]{new_name}[/]", title="Add Column")
+            # self.notify(f"Added column [$success]{new_name}[/]", title="Add Column")
         except Exception as e:
-            self.notify(f"Failed to add column: {str(e)}", title="Add Column", severity="error")
+            self.notify("Error adding column", title="Add Column", severity="error")
+            self.log(f"Error adding column: {str(e)}")
             raise e
 
     def _add_column_expr(self) -> None:
@@ -1876,7 +2143,7 @@ class DataFrameTable(DataTable):
             select_cols = cols_before + [col_name] + cols_after
             self.df = self.df.with_row_index(RIDX).with_columns(new_col).select(select_cols)
 
-            # Recreate the table display
+            # Recreate table for display
             self._setup_table()
 
             # Move cursor to the new column
@@ -1884,53 +2151,33 @@ class DataFrameTable(DataTable):
 
             # self.notify(f"Added column [$success]{col_name}[/]", title="Add Column")
         except Exception as e:
-            self.notify(f"Failed to add column: [$error]{str(e)}[/]", title="Add Column", severity="error")
-            raise e
-
-    def _string_to_polars_dtype(self, dtype_str: str) -> pl.DataType:
-        """Convert string type name to Polars DataType.
-
-        Args:
-            dtype_str: String representation of the type ("string", "int", "float", "bool")
-
-        Returns:
-            Corresponding Polars DataType
+            self.notify("Error adding column", title="Add Column", severity="error")
+            self.log(f"Error adding column `{col_name}`: {str(e)}")
 
-        Raises:
-            ValueError: If the type string is not recognized
-        """
-        dtype_map = {
-            "string": pl.String,
-            "int": pl.Int64,
-            "float": pl.Float64,
-            "bool": pl.Boolean,
-        }
-
-        dtype_lower = dtype_str.lower().strip()
-        return dtype_map.get(dtype_lower)
-
-    def _cast_column_dtype(self, dtype: str | pl.DataType = pl.String) -> None:
+    # Type Casting
+    def _cast_column_dtype(self, dtype: str) -> None:
         """Cast the current column to a different data type.
 
         Args:
-            dtype: Target data type (string like "int", "float", "bool", "string" or Polars DataType)
+            dtype: Target data type (string representation, e.g., "pl.String", "pl.Int64")
         """
         cidx = self.cursor_col_idx
         col_name = self.cursor_col_name
         current_dtype = self.df.dtypes[cidx]
 
-        # Convert string dtype to Polars DataType if needed
-        if isinstance(dtype, str):
-            target_dtype = self._string_to_polars_dtype(dtype)
-            if target_dtype is None:
-                self.notify(
-                    f"Use string for unknown data type: {dtype}. Supported types: {', '.join(self._string_to_polars_dtype.keys())}",
-                    title="Cast",
-                    severity="warning",
-                )
-                target_dtype = pl.String
-        else:
-            target_dtype = dtype
+        try:
+            target_dtype = eval(dtype)
+        except Exception:
+            self.notify(f"Invalid target data type: [$error]{dtype}[/]", title="Cast", severity="error")
+            return
+
+        if current_dtype == target_dtype:
+            self.notify(
+                f"Column [$accent]{col_name}[/] is already of type [$success]{target_dtype}[/]",
+                title="Cast",
+                severity="warning",
+            )
+            return  # No change needed
 
         # Add to history
         self._add_history(
@@ -1941,17 +2188,19 @@ class DataFrameTable(DataTable):
             # Cast the column using Polars
             self.df = self.df.with_columns(pl.col(col_name).cast(target_dtype))
 
-            # Recreate the table display
+            # Recreate table for display
             self._setup_table()
 
+            self.notify(f"Cast column [$accent]{col_name}[/] to [$success]{target_dtype}[/]", title="Cast")
+        except Exception as e:
             self.notify(
-                f"Cast column [$accent]{col_name}[/] to [$success]{target_dtype}[/]",
+                f"Error casting column [$accent]{col_name}[/] to [$error]{target_dtype}[/]",
                 title="Cast",
+                severity="error",
             )
-        except Exception as e:
-            self.notify(f"Failed to cast column: {str(e)}", title="Cast", severity="error")
-            raise e
+            self.log(f"Error casting column `{col_name}`: {str(e)}")
 
+    # Search
     def _search_cursor_value(self) -> None:
         """Search with cursor value in current column."""
         cidx = self.cursor_col_idx
@@ -1959,7 +2208,7 @@ class DataFrameTable(DataTable):
         # 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, False))
+        self._do_search((term, cidx, False, True))
 
     def _search_expr(self) -> None:
         """Search by expression."""
@@ -1978,6 +2227,7 @@ class DataFrameTable(DataTable):
         """Search for a term."""
         if result is None:
             return
+
         term, cidx, match_nocase, match_whole = result
         col_name = self.df.columns[cidx]
 
@@ -1987,13 +2237,10 @@ class DataFrameTable(DataTable):
         # Support for polars expressions
         elif tentative_expr(term):
             try:
-                expr = validate_expr(term, self.df, cidx)
+                expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
-                self.notify(
-                    f"Failed to validate Polars expression [$error]{term}[/]: {str(e)}",
-                    title="Search",
-                    severity="error",
-                )
+                self.notify(f"Error validating expression [$error]{term}[/]", title="Search", severity="error")
+                self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
 
         # Perform type-aware search based on column dtype
@@ -2016,7 +2263,7 @@ class DataFrameTable(DataTable):
                         term = f"(?i){term}"
                     expr = pl.col(col_name).cast(pl.String).str.contains(term)
                     self.notify(
-                        f"Unable to convert [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
+                        f"Error converting [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
                         title="Search",
                         severity="warning",
                     )
@@ -2030,17 +2277,14 @@ class DataFrameTable(DataTable):
         try:
             matches = set(lf.filter(expr).select(RIDX).collect().to_series().to_list())
         except Exception as e:
-            self.notify(
-                f"Error applying search filter: [$error]{str(e)}[/]",
-                title="Search",
-                severity="error",
-            )
+            self.notify(f"Error applying search filter [$error]{term}[/]", title="Search", severity="error")
+            self.log(f"Error applying search filter `{term}`: {str(e)}")
             return
 
         match_count = len(matches)
         if match_count == 0:
             self.notify(
-                f"No matches found for [$warning]{term}[/]. Try [$accent](?i)abc[/] for case-insensitive search.",
+                f"No matches found for [$accent]{term}[/]. Try [$warning](?i)abc[/] for case-insensitive search.",
                 title="Search",
                 severity="warning",
             )
@@ -2053,11 +2297,13 @@ class DataFrameTable(DataTable):
         for m in matches:
             self.selected_rows[m] = True
 
-        # Highlight matches
-        self._do_highlight()
-
+        # Show notification immediately, then start highlighting
         self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Search")
 
+        # Recreate table for display
+        self._setup_table()
+
+    # Find
     def _find_matches(
         self, term: str, cidx: int | None = None, match_nocase: bool = False, match_whole: bool = False
     ) -> dict[int, set[int]]:
@@ -2095,9 +2341,11 @@ class DataFrameTable(DataTable):
                 expr = pl.col(col_name).is_null()
             elif tentative_expr(term):
                 try:
-                    expr = validate_expr(term, self.df, col_idx)
+                    expr = validate_expr(term, self.df.columns, col_idx)
                 except Exception as e:
-                    raise Exception(f"Error validating Polars expression: {str(e)}")
+                    self.notify(f"Error validating expression [$error]{term}[/]", title="Find", severity="error")
+                    self.log(f"Error validating expression `{term}`: {str(e)}")
+                    return matches
             else:
                 if match_whole:
                     term = f"^{term}$"
@@ -2109,7 +2357,9 @@ class DataFrameTable(DataTable):
             try:
                 matched_ridxs = lf.filter(expr).select(RIDX).collect().to_series().to_list()
             except Exception as e:
-                raise Exception(f"Error applying filter: {str(e)}")
+                self.notify(f"Error applying filter: {expr}", title="Find", severity="error")
+                self.log(f"Error applying filter: {str(e)}")
+                return matches
 
             for ridx in matched_ridxs:
                 matches[ridx].add(col_idx)
@@ -2127,9 +2377,9 @@ class DataFrameTable(DataTable):
 
         if scope == "column":
             cidx = self.cursor_col_idx
-            self._do_find((term, cidx, False, False))
+            self._do_find((term, cidx, False, True))
         else:
-            self._do_find_global((term, None, False, False))
+            self._do_find_global((term, None, False, True))
 
     def _find_expr(self, scope="column") -> None:
         """Open screen to find by expression.
@@ -2158,16 +2408,13 @@ class DataFrameTable(DataTable):
         try:
             matches = self._find_matches(term, cidx, match_nocase, match_whole)
         except Exception as e:
-            self.notify(
-                f"Error finding matches: [$error]{str(e)}[/]",
-                title="Find",
-                severity="error",
-            )
+            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error")
+            self.log(f"Error finding matches for `{term}`: {str(e)}")
             return
 
         if not matches:
             self.notify(
-                f"No matches found for [$warning]{term}[/] in current column. Try [$accent](?i)abc[/] for case-insensitive search.",
+                f"No matches found for [$accent]{term}[/] in current column. Try [$warning](?i)abc[/] for case-insensitive search.",
                 title="Find",
                 severity="warning",
             )
@@ -2181,11 +2428,11 @@ class DataFrameTable(DataTable):
         for ridx, col_idxs in matches.items():
             self.matches[ridx].update(col_idxs)
 
-        # Highlight matches
-        self._do_highlight()
-
         self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Find")
 
+        # Recreate table for display
+        self._setup_table()
+
     def _do_find_global(self, result) -> None:
         """Global find a term across all columns."""
         if result is None:
@@ -2195,16 +2442,13 @@ class DataFrameTable(DataTable):
         try:
             matches = self._find_matches(term, cidx=None, match_nocase=match_nocase, match_whole=match_whole)
         except Exception as e:
-            self.notify(
-                f"Error finding matches: [$error]{str(e)}[/]",
-                title="Find",
-                severity="error",
-            )
+            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error")
+            self.log(f"Error finding matches for `{term}`: {str(e)}")
             return
 
         if not matches:
             self.notify(
-                f"No matches found for [$warning]{term}[/] in any column. Try [$accent](?i)abc[/] for case-insensitive search.",
+                f"No matches found for [$accent]{term}[/] in any column. Try [$warning](?i)abc[/] for case-insensitive search.",
                 title="Global Find",
                 severity="warning",
             )
@@ -2218,14 +2462,13 @@ class DataFrameTable(DataTable):
         for ridx, col_idxs in matches.items():
             self.matches[ridx].update(col_idxs)
 
-        # Highlight matches
-        self._do_highlight()
-
         self.notify(
-            f"Found [$accent]{match_count}[/] matches for [$success]{term}[/] across all columns",
-            title="Global Find",
+            f"Found [$accent]{match_count}[/] matches for [$success]{term}[/] across all columns", title="Global Find"
         )
 
+        # Recreate table for display
+        self._setup_table()
+
     def _next_match(self) -> None:
         """Move cursor to the next match."""
         if not self.matches:
@@ -2320,11 +2563,12 @@ class DataFrameTable(DataTable):
         last_ridx = selected_row_indices[-1]
         self.move_cursor_to(last_ridx, self.cursor_col_idx)
 
+    # Replace
     def _replace(self) -> None:
         """Open replace screen for current column."""
         # Push the replace modal screen
         self.app.push_screen(
-            FindReplaceScreen(self),
+            FindReplaceScreen(self, title="Find and Replace in Current Column"),
             callback=self._do_replace,
         )
 
@@ -2336,7 +2580,7 @@ class DataFrameTable(DataTable):
         """Open replace screen for all columns."""
         # Push the replace modal screen
         self.app.push_screen(
-            FindReplaceScreen(self),
+            FindReplaceScreen(self, title="Global Find and Replace"),
             callback=self._do_replace_global,
         )
 
@@ -2364,23 +2608,19 @@ class DataFrameTable(DataTable):
         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",
-            )
+            self.notify(f"No matches found for [$warning]{term_find}[/]", title="Replace", severity="warning")
             return
 
         # Add to history
         self._add_history(
-            f"Replacing [$accent]{term_find}[/] with [$success]{term_replace}[/] in column [$accent]{col_name}[/]"
+            f"Replaced [$accent]{term_find}[/] with [$success]{term_replace}[/] in column [$accent]{col_name}[/]"
         )
 
         # Update matches
-        self.matches = {ridx: set(col_idxs) for ridx, col_idxs in matches.items()}
+        self.matches = {ridx: col_idxs.copy() for ridx, col_idxs in matches.items()}
 
-        # Highlight matches
-        self._do_highlight()
+        # Recreate table for display
+        self._setup_table()
 
         # Store state for interactive replacement using dataclass
         self._replace_state = ReplaceState(
@@ -2410,10 +2650,11 @@ class DataFrameTable(DataTable):
 
         except Exception as e:
             self.notify(
-                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]: {str(e)}",
+                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
                 title="Replace",
                 severity="error",
             )
+            self.log(f"Error replacing `{term_find}` with `{term_replace}`: {str(e)}")
 
     def _do_replace_all(self, term_find: str, term_replace: str) -> None:
         """Replace all occurrences."""
@@ -2466,7 +2707,7 @@ class DataFrameTable(DataTable):
 
                 state.replaced_occurrence += 1
 
-        # Recreate the table display
+        # Recreate table for display
         self._setup_table()
 
         col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
@@ -2482,10 +2723,11 @@ class DataFrameTable(DataTable):
             self._show_next_replace_confirmation()
         except Exception as e:
             self.notify(
-                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]: {str(e)}",
+                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
                 title="Replace",
                 severity="error",
             )
+            self.log(f"Error in interactive replace: {str(e)}")
 
     def _show_next_replace_confirmation(self) -> None:
         """Show confirmation for next replacement."""
@@ -2502,12 +2744,12 @@ class DataFrameTable(DataTable):
         # Move cursor to next match
         ridx = state.rows[state.current_rpos]
         cidx = state.cols_per_row[state.current_rpos][state.current_cpos]
-        self.move_cursor(row=ridx, column=cidx)
+        self.move_cursor_to(ridx, cidx)
 
         state.current_occurrence += 1
 
         # Show confirmation
-        label = f"Replace [$warning]{state.term_find}[/] with [$success]{state.term_replace}[/] (Occurrence {state.current_occurrence} of {state.total_occurrence})?"
+        label = f"Replace [$warning]{state.term_find}[/] with [$success]{state.term_replace}[/] ({state.current_occurrence} of {state.total_occurrence})?"
 
         self.app.push_screen(
             ConfirmScreen("Replace", label=label, maybe="Skip"),
@@ -2572,15 +2814,16 @@ class DataFrameTable(DataTable):
         if state.current_rpos >= len(state.rows):
             state.done = True
 
-        # Recreate the table display
+        # Recreate table for display
         self._setup_table()
 
         # Show next confirmation
         self._show_next_replace_confirmation()
 
+    # Selection & Match
     def _toggle_selections(self) -> None:
         """Toggle selected rows highlighting on/off."""
-        # Save current state to history
+        # Add to history
         self._add_history("Toggled row selection")
 
         if False in self.visible_rows:
@@ -2596,34 +2839,34 @@ class DataFrameTable(DataTable):
 
         # Check if we're highlighting or un-highlighting
         if new_selected_count := self.selected_rows.count(True):
-            self.notify(
-                f"Toggled selection for [$accent]{new_selected_count}[/] rows",
-                title="Toggle",
-            )
+            self.notify(f"Toggled selection for [$accent]{new_selected_count}[/] rows", title="Toggle")
 
-        # Refresh the highlighting
-        self._do_highlight(force=True)
+        # Recreate table for display
+        self._setup_table()
 
-    def _make_selections(self) -> None:
-        """Make selections based on current matches or toggle current row selection."""
-        # Save current state to history
+    def _toggle_row_selection(self) -> None:
+        """Select/deselect current row."""
+        # Add to history
         self._add_history("Toggled row selection")
 
-        if self.matches:
-            # There are matched cells - select rows with matches
-            for ridx in self.matches.keys():
-                self.selected_rows[ridx] = True
-        else:
-            # No matched cells - select/deselect the current row
-            ridx = self.cursor_row_idx
-            self.selected_rows[ridx] = not self.selected_rows[ridx]
+        ridx = self.cursor_row_idx
+        self.selected_rows[ridx] = not self.selected_rows[ridx]
 
-        # Check if we're highlighting or un-highlighting
-        if new_selected_count := self.selected_rows.count(True):
-            self.notify(f"Selected [$accent]{new_selected_count}[/] rows", title="Toggle")
+        row_key = str(ridx)
+        match_cols = self.matches.get(ridx, set())
+        for col_idx, col in enumerate(self.ordered_columns):
+            col_key = col.key
+            cell_text: Text = self.get_cell(row_key, col_key)
+
+            if self.selected_rows[ridx] or (col_idx in match_cols):
+                cell_text.style = HIGHLIGHT_COLOR
+            else:
+                # Reset to default style based on dtype
+                dtype = self.df.dtypes[col_idx]
+                dc = DtypeConfig(dtype)
+                cell_text.style = dc.style
 
-        # Refresh the highlighting (also restores default styles for unselected rows)
-        self._do_highlight(force=True)
+            self.update_cell(row_key, col_key, cell_text)
 
     def _clear_selections_and_matches(self) -> None:
         """Clear all selected rows and matches without removing them from the dataframe."""
@@ -2636,50 +2879,61 @@ class DataFrameTable(DataTable):
             1 if (selected or idx in self.matches) else 0 for idx, selected in enumerate(self.selected_rows)
         )
 
-        # Save current state to history
+        # Add to history
         self._add_history("Cleared all selected rows")
 
         # Clear all selections
         self.selected_rows = [False] * len(self.df)
         self.matches = defaultdict(set)
 
-        # Refresh the highlighting to remove all highlights
-        self._do_highlight(force=True)
+        # Recreate table for display
+        self._setup_table()
 
         self.notify(f"Cleared selections for [$accent]{row_count}[/] rows", title="Clear")
 
-    def _filter_selected_rows(self) -> None:
-        """Keep only the selected rows and remove unselected ones."""
-        selected_count = self.selected_rows.count(True)
-        if selected_count == 0:
-            self.notify("No rows selected to filter", title="Filter", severity="warning")
+    # Filter & View
+    def _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")
             return
 
-        # Save current state to history
-        self._add_history("Filtered to selected rows")
+        filter_expr = [
+            True if (selected or ridx in self.matches) else False for ridx, selected in enumerate(self.selected_rows)
+        ]
+
+        # Add to history
+        self._add_history("Filtered to selections and matches")
+
+        # Apply filter to dataframe with row indices
+        df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
+
+        # Update selections and matches
+        self.selected_rows = [self.selected_rows[ridx] for ridx in df_filtered[RIDX]]
+        self.matches = {
+            idx: self.matches[ridx].copy() for idx, ridx in enumerate(df_filtered[RIDX]) if ridx in self.matches
+        }
 
-        # Update dataframe to only include selected rows
-        self.df = self.df.filter(self.selected_rows)
-        self.selected_rows = [True] * len(self.df)
+        # Update dataframe
+        self.df = df_filtered.drop(RIDX)
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
         self.notify(
-            f"Removed unselected rows. Now showing [$accent]{selected_count}[/] rows",
-            title="Filter",
+            f"Removed rows without selections or matches. Now showing [$accent]{len(self.df)}[/] rows", title="Filter"
         )
 
     def _view_rows(self) -> None:
         """View rows.
 
-        If there are selected rows, view those rows.
+        If there are selected rows or matches, view those rows.
         Otherwise, view based on the value of the currently selected cell.
         """
 
         cidx = self.cursor_col_idx
 
-        # If there are selected rows or matches, use those
+        # 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)
@@ -2689,7 +2943,7 @@ class DataFrameTable(DataTable):
             ridx = self.cursor_row_idx
             term = str(self.df.item(ridx, cidx))
 
-        self._do_view_rows((term, cidx, False, False))
+        self._do_view_rows((term, cidx, False, True))
 
     def _view_rows_expr(self) -> None:
         """Open the filter screen to enter an expression."""
@@ -2703,7 +2957,7 @@ class DataFrameTable(DataTable):
         )
 
     def _do_view_rows(self, result) -> None:
-        """Show only those matching rows and hide others. Do not modify the dataframe."""
+        """Show only rows with selections or matches, and do hide others. Do not modify the dataframe."""
         if result is None:
             return
         term, cidx, match_nocase, match_whole = result
@@ -2718,11 +2972,10 @@ class DataFrameTable(DataTable):
         elif tentative_expr(term):
             # Support for polars expressions
             try:
-                expr = validate_expr(term, self.df, cidx)
+                expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
-                self.notify(
-                    f"Error validating Polars expression [$error]{term}[/]: {str(e)}", title="Filter", severity="error"
-                )
+                self.notify(f"Error validating expression [$error]{term}[/]", title="Filter", severity="error")
+                self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
         else:
             dtype = self.df.dtypes[cidx]
@@ -2743,9 +2996,7 @@ class DataFrameTable(DataTable):
                         term = f"(?i){term}"
                     expr = pl.col(col_name).cast(pl.String).str.contains(term)
                     self.notify(
-                        f"Unknown column type [$warning]{dtype}[/]. Cast to string.",
-                        title="Filter",
-                        severity="warning",
+                        f"Unknown column type [$warning]{dtype}[/]. Cast to string.", title="Filter", severity="warning"
                     )
 
         # Lazyframe with row indices
@@ -2759,17 +3010,14 @@ class DataFrameTable(DataTable):
         try:
             df_filtered = lf.filter(expr).collect()
         except Exception as e:
-            self.notify(f"Failed to apply filter [$error]{expr}[/]: {str(e)}", title="Filter", severity="error")
             self.histories.pop()  # Remove last history entry
+            self.notify(f"Error applying filter [$error]{expr}[/]", title="Filter", severity="error")
+            self.log(f"Error applying filter `{expr}`: {str(e)}")
             return
 
         matched_count = len(df_filtered)
         if not matched_count:
-            self.notify(
-                f"No rows match the expression: [$success]{expr}[/]",
-                title="Filter",
-                severity="warning",
-            )
+            self.notify(f"No rows match the expression: [$success]{expr}[/]", title="Filter", severity="warning")
             return
 
         # Add to history
@@ -2782,21 +3030,12 @@ class DataFrameTable(DataTable):
                 if ridx not in filtered_row_indices:
                     self.visible_rows[ridx] = False
 
-        # Recreate the table for display
+        # Recreate table for display
         self._setup_table()
 
-        self.notify(
-            f"Filtered to [$accent]{matched_count}[/] matching rows",
-            title="Filter",
-        )
-
-    def _cycle_cursor_type(self) -> None:
-        """Cycle through cursor types: cell -> row -> column -> cell."""
-        next_type = get_next_item(CURSOR_TYPES, self.cursor_type)
-        self.cursor_type = next_type
-
-        # self.notify(f"Changed cursor type to [$success]{next_type}[/]", title="Cursor")
+        self.notify(f"Filtered to [$accent]{matched_count}[/] matching rows", title="Filter")
 
+    # Copy & Save
     def _copy_to_clipboard(self, content: str, message: str) -> None:
         """Copy content to clipboard using pbcopy (macOS) or xclip (Linux).
 
@@ -2862,6 +3101,9 @@ class DataFrameTable(DataTable):
         filepath = Path(filename)
         ext = filepath.suffix.lower()
 
+        # Add to history
+        self._add_history(f"Saved dataframe to [$success]{filename}[/]")
+
         try:
             if ext in (".xlsx", ".xls"):
                 self._do_save_excel(filename)
@@ -2874,17 +3116,14 @@ class DataFrameTable(DataTable):
             else:
                 self.df.write_csv(filename)
 
-            self.lazyframe = self.df.lazy()  # Update original dataframe
+            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",
-                )
+                self.notify(f"Saved {extra}[$accent]{len(self.df)}[/] rows to [$success]{filename}[/]", title="Save")
         except Exception as e:
-            self.notify(f"Failed to save: {str(e)}", title="Save", severity="error")
-            raise e
+            self.notify(f"Error saving [$error]{filename}[/]", title="Save", severity="error")
+            self.log(f"Error saving file `{filename}`: {str(e)}")
 
     def _do_save_excel(self, filename: str) -> None:
         """Save to an Excel file."""
@@ -2903,47 +3142,71 @@ class DataFrameTable(DataTable):
 
         # From ConfirmScreen callback, so notify accordingly
         if self._all_tabs is True:
-            self.notify(
-                f"Saved all tabs to [$success]{filename}[/]",
-                title="Save",
-            )
+            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",
+                f"Saved current tab with [$accent]{len(self.df)}[/] rows to [$success]{filename}[/]", title="Save"
             )
 
-    def _make_cell_clickable(self) -> None:
-        """Make cells with URLs in the current column clickable.
+    # SQL Interface
+    def _simple_sql(self) -> None:
+        """Open the SQL interface screen."""
+        self.app.push_screen(
+            SimpleSqlScreen(self),
+            callback=self._do_simple_sql,
+        )
 
-        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.
+    def _do_simple_sql(self, result) -> None:
+        """Handle SQL result result from SimpleSqlScreen."""
+        if result is None:
+            return
+        columns, where = result
 
-        Returns:
-            None
+        sql = f"SELECT {columns} FROM self"
+        if where:
+            sql += f" WHERE {where}"
+
+        self._do_sql(sql)
+
+    def _advanced_sql(self) -> None:
+        """Open the advanced SQL interface screen."""
+        self.app.push_screen(
+            AdvancedSqlScreen(self),
+            callback=self._do_advanced_sql,
+        )
+
+    def _do_advanced_sql(self, result) -> None:
+        """Handle SQL result result from AdvancedSqlScreen."""
+        if result is None:
+            return
+
+        self._do_sql(result)
+
+    def _do_sql(self, sql: str) -> None:
+        """Execute a SQL query directly.
+
+        Args:
+            sql: The SQL query string to execute.
         """
-        cidx = self.cursor_col_idx
-        col_key = self.cursor_col_key
-        dtype = self.df.dtypes[cidx]
+        # Add to history
+        self._add_history(f"SQL Query:\n[$accent]{sql}[/]")
 
-        # Only process string columns
-        if dtype != pl.String:
+        # Execute the SQL query
+        try:
+            self.df = self.df.sql(sql)
+        except Exception as e:
+            self.notify(f"Error executing SQL query [$error]{sql}[/]", title="SQL Query", severity="error")
+            self.log(f"Error executing SQL query `{sql}`: {str(e)}")
             return
 
-        # Count how many URLs were made clickable
-        url_count = 0
+        if not len(self.df):
+            self.notify(f"SQL query returned no results for [$warning]{sql}[/]", title="SQL Query", severity="warning")
+            return
 
-        # 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
+        # Recreate table for display
+        self._setup_table()
 
-        if url_count:
-            self.notify(
-                f"Made [$accent]{url_count}[/] cell(s) clickable in column [$success]{col_key.value}[/]",
-                title="Make Clickable",
-            )
+        self.notify(
+            f"SQL query executed successfully. Now showing [$accent]{len(self.df)}[/] rows and [$accent]{len(self.df.columns)}[/] columns.",
+            title="SQL Query",
+        )