Initial Codes

app/ui/table_viewer.py

@@ -0,0 +1,716 @@
+"""
+Full table data viewer — paginated grid with full CRUD support.
+
+Features:
+  • Page-size selector: 50 / 100 / 500 / All
+  • Add Row  — dialog pre-filled with column names
+  • Edit Row — double-click any cell to edit inline; dirty cells highlighted
+  • Delete Row(s) — delete selected rows with confirmation
+  • Filter (WHERE clause), Refresh
+  • Commit / Rollback pending changes
+"""
+from PyQt6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QTableView, QLabel, QPushButton,
+    QLineEdit, QHeaderView, QAbstractItemView, QMessageBox, QDialog,
+    QFormLayout, QDialogButtonBox, QComboBox, QScrollArea,
+    QMenu, QApplication,
+)
+from PyQt6.QtCore import (
+    Qt, QAbstractTableModel, QModelIndex, pyqtSignal,
+)
+from PyQt6.QtGui import QColor, QBrush, QFont, QKeySequence, QShortcut
+
+from app.utils.worker import TableDataWorker
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Editable table model
+# ─────────────────────────────────────────────────────────────────────────────
+
+class EditableTableModel(QAbstractTableModel):
+    """
+    Tracks inline cell edits (dirty cells highlighted orange),
+    new rows (pending insert), and rows marked for deletion.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._columns: list = []
+        self._original: list = []   # pristine tuples
+        self._data: list = []       # mutable lists
+        self._dirty: set = set()    # (row, col) changed cells
+        self._pending_new: list = []   # list of dicts  {col: val}
+        self._pending_delete: list = []  # list of original tuples
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def set_data(self, columns: list, rows: list) -> None:
+        self.beginResetModel()
+        self._columns  = list(columns)
+        self._original = [tuple(r) for r in rows]
+        self._data     = [list(r)  for r in rows]
+        self._dirty.clear()
+        self._pending_new.clear()
+        self._pending_delete.clear()
+        self.endResetModel()
+
+    def clear(self) -> None:
+        self.set_data([], [])
+
+    @property
+    def has_changes(self) -> bool:
+        return bool(self._dirty or self._pending_new or self._pending_delete)
+
+    def column_names(self) -> list:
+        return list(self._columns)
+
+    def get_row_original(self, logical_row: int) -> tuple:
+        return self._original[logical_row]
+
+    def get_row_current(self, logical_row: int) -> list:
+        return self._data[logical_row]
+
+    def get_dirty_rows(self) -> list:
+        """Return list of (new_data_list, original_tuple) for modified rows.
+        Rows pending deletion are excluded — they don't need an UPDATE."""
+        rows_changed = set(r for r, _ in self._dirty)
+        return [
+            (self._data[r], self._original[r])
+            for r in sorted(rows_changed)
+            if not self._is_deleted_row(r)
+        ]
+
+    def get_pending_new(self) -> list:
+        return list(self._pending_new)
+
+    def get_pending_delete(self) -> list:
+        return list(self._pending_delete)
+
+    def discard_changes(self) -> None:
+        for row, col in self._dirty:
+            if row < len(self._data):
+                self._data[row][col] = self._original[row][col]
+        self._dirty.clear()
+        self._pending_new.clear()
+        self._pending_delete.clear()
+        self.layoutChanged.emit()
+
+    def mark_rows_deleted(self, logical_rows: list) -> None:
+        """Mark rows for deletion (they stay visible but tinted red until commit)."""
+        for r in sorted(logical_rows, reverse=True):
+            self._pending_delete.append(self._original[r])
+            # Mark every cell in that row dirty-red via a special sentinel
+            for c in range(len(self._columns)):
+                self._dirty.add((r, c))  # will be styled via _pending_delete set
+        self.layoutChanged.emit()
+
+    def add_pending_new(self, row_dict: dict) -> None:
+        """Queue a new row for insert."""
+        self._pending_new.append(row_dict)
+
+    # ── QAbstractTableModel interface ─────────────────────────────────────────
+
+    def rowCount(self, _parent=QModelIndex()) -> int:
+        return len(self._data)
+
+    def columnCount(self, _parent=QModelIndex()) -> int:
+        return len(self._columns)
+
+    def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
+        if role == Qt.ItemDataRole.DisplayRole:
+            if orientation == Qt.Orientation.Horizontal:
+                return self._columns[section] if section < len(self._columns) else ""
+            return str(section + 1)
+        if role == Qt.ItemDataRole.FontRole and orientation == Qt.Orientation.Horizontal:
+            f = QFont()
+            f.setBold(True)
+            return f
+        return None
+
+    def _is_deleted_row(self, row: int) -> bool:
+        if row >= len(self._original):
+            return False
+        return self._original[row] in self._pending_delete
+
+    def data(self, index: QModelIndex, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid():
+            return None
+        r, c = index.row(), index.column()
+        if r >= len(self._data) or c >= len(self._columns):
+            return None
+        val = self._data[r][c]
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            return "NULL" if val is None else str(val)
+
+        if role == Qt.ItemDataRole.EditRole:
+            return "" if val is None else str(val)
+
+        if role == Qt.ItemDataRole.ForegroundRole:
+            if self._is_deleted_row(r):
+                return QBrush(QColor("#f38ba8"))   # red — pending delete
+            if (r, c) in self._dirty:
+                return QBrush(QColor("#fab387"))   # orange — edited
+            if val is None:
+                return QBrush(QColor("#6c7086"))   # grey — NULL
+
+        if role == Qt.ItemDataRole.BackgroundRole:
+            if self._is_deleted_row(r):
+                return QBrush(QColor("#2a1a1e"))
+            if (r, c) in self._dirty:
+                return QBrush(QColor("#2a1f1a"))
+
+        return None
+
+    def setData(self, index: QModelIndex, value, role=Qt.ItemDataRole.EditRole) -> bool:
+        if not index.isValid() or role != Qt.ItemDataRole.EditRole:
+            return False
+        r, c = index.row(), index.column()
+        if self._is_deleted_row(r):
+            return False          # don't allow editing a row queued for delete
+        old = self._data[r][c]
+        new = value if value.strip() != "" else None
+        if str(old) == str(new):
+            return False
+        self._data[r][c] = new
+        self._dirty.add((r, c))
+        self.dataChanged.emit(index, index, [role])
+        return True
+
+    def flags(self, _index: QModelIndex):
+        return Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Password helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+_PASSWORD_COL_NAMES = frozenset({
+    "password", "passwd", "pwd", "pass",
+    "password_hash", "hashed_password", "passhash", "pass_hash",
+    "user_password", "account_password",
+})
+
+def _is_password_col(col_name: str) -> bool:
+    n = col_name.lower()
+    return n in _PASSWORD_COL_NAMES or n.endswith(("_password", "_passwd", "_pwd"))
+
+def _hash_password(plain: str) -> str:
+    """Hash a plain-text password with bcrypt (falls back to PBKDF2)."""
+    try:
+        import bcrypt
+        return bcrypt.hashpw(plain.encode("utf-8"), bcrypt.gensalt()).decode()
+    except ImportError:
+        import hashlib, os, base64
+        salt = os.urandom(16)
+        key  = hashlib.pbkdf2_hmac("sha256", plain.encode("utf-8"), salt, 260_000)
+        return "pbkdf2:sha256:" + base64.b64encode(salt + key).decode()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Add / Edit row dialog
+# ─────────────────────────────────────────────────────────────────────────────
+
+class RowDialog(QDialog):
+    """
+    Form dialog for adding or editing a single row.
+
+    Password-like columns (password, passwd, pwd, …) are shown with masked
+    input.  On save the plain text is hashed automatically with bcrypt.
+
+    In *edit* mode an empty password field means "keep the existing hash" —
+    the column is omitted from the returned values dict entirely.
+    """
+
+    def __init__(self, columns: list, initial: dict = None,
+                 title: str = "Add Row", mode: str = "add", parent=None):
+        super().__init__(parent)
+        self._mode = mode           # "add" | "edit"
+        self.setWindowTitle(title)
+        self.setMinimumWidth(420)
+        self.setModal(True)
+
+        root = QVBoxLayout(self)
+
+        # Scrollable form area (for tables with many columns)
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+        form_widget = QWidget()
+        form = QFormLayout(form_widget)
+        form.setSpacing(8)
+        form.setContentsMargins(8, 8, 8, 8)
+
+        self._fields: dict[str, QLineEdit] = {}
+        for col in columns:
+            le = QLineEdit()
+            if _is_password_col(col):
+                le.setEchoMode(QLineEdit.EchoMode.Password)
+                if mode == "edit":
+                    le.setPlaceholderText("Leave blank to keep current password")
+                else:
+                    le.setPlaceholderText("Enter password")
+            else:
+                le.setPlaceholderText("NULL")
+                if initial and col in initial and initial[col] is not None:
+                    le.setText(str(initial[col]))
+            form.addRow(f"{col}:", le)
+            self._fields[col] = le
+
+        scroll.setWidget(form_widget)
+        root.addWidget(scroll)
+
+        bbox = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok |
+            QDialogButtonBox.StandardButton.Cancel
+        )
+        bbox.accepted.connect(self.accept)
+        bbox.rejected.connect(self.reject)
+        root.addWidget(bbox)
+
+    @property
+    def values(self) -> dict:
+        """Return {col: value_or_None} for all fields.
+
+        Rules for password columns:
+          • Non-empty  → hash the plain text and store the hash.
+          • Empty + add mode  → store None (let the DB default apply).
+          • Empty + edit mode → column is *omitted* (caller must not update it).
+        """
+        result = {}
+        for col, le in self._fields.items():
+            txt = le.text()
+            if _is_password_col(col):
+                if txt:
+                    result[col] = _hash_password(txt)
+                elif self._mode == "add":
+                    result[col] = None
+                # edit + empty → omit; caller preserves existing hash
+            else:
+                stripped = txt.strip()
+                result[col] = stripped if stripped else None
+        return result
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main TableViewer widget
+# ─────────────────────────────────────────────────────────────────────────────
+
+_PAGE_OPTIONS = [("50", 50), ("100", 100), ("All", 0)]
+
+
+class TableViewer(QWidget):
+    status_message = pyqtSignal(str)
+
+    def __init__(self, driver, database: str, table: str, parent=None):
+        super().__init__(parent)
+        self._driver   = driver
+        self._database = database
+        self._table    = table
+        self._offset   = 0
+        self._total    = 0
+        self._page_size = 100          # default
+        self._model    = EditableTableModel()
+        self._worker: TableDataWorker | None = None
+        self._build_ui()
+        self._load_page()
+
+    # ── UI construction ───────────────────────────────────────────────────────
+
+    def _build_ui(self):
+        root = QVBoxLayout(self)
+        root.setContentsMargins(0, 0, 0, 0)
+        root.setSpacing(0)
+
+        # ── Top toolbar ────────────────────────────────────────────────────────
+        tb = QHBoxLayout()
+        tb.setContentsMargins(8, 6, 8, 4)
+        tb.setSpacing(6)
+
+        # Filter input
+        self._filter_input = QLineEdit()
+        self._filter_input.setPlaceholderText("WHERE … (e.g.  id > 100)")
+        self._filter_input.setFixedWidth(260)
+        self._filter_btn = QPushButton("🔍")
+        self._filter_btn.setFixedWidth(34)
+        self._filter_btn.setToolTip("Apply filter")
+        self._filter_btn.clicked.connect(self._apply_filter)
+        self._filter_input.returnPressed.connect(self._apply_filter)
+
+        clear_filter_btn = QPushButton("✕")
+        clear_filter_btn.setFixedWidth(30)
+        clear_filter_btn.setToolTip("Clear filter")
+        clear_filter_btn.clicked.connect(self._clear_filter)
+
+        self._refresh_btn = QPushButton("🔄 Refresh")
+        self._refresh_btn.clicked.connect(self._load_page)
+
+        # Separator
+        sep = QLabel("|")
+        sep.setStyleSheet("color:#45475a; padding:0 4px;")
+
+        # CRUD buttons
+        self._add_btn    = QPushButton("➕ Add")
+        self._edit_btn   = QPushButton("✏️ Edit")
+        self._delete_btn = QPushButton("🗑️ Delete")
+        self._add_btn.setObjectName("crudAddBtn")
+        self._delete_btn.setObjectName("crudDeleteBtn")
+        self._add_btn.setFixedWidth(74)
+        self._edit_btn.setFixedWidth(74)
+        self._delete_btn.setFixedWidth(80)
+        self._edit_btn.setEnabled(False)
+        self._delete_btn.setEnabled(False)
+        self._add_btn.clicked.connect(self._add_row)
+        self._edit_btn.clicked.connect(self._edit_selected)
+        self._delete_btn.clicked.connect(self._delete_selected)
+
+        tb.addWidget(self._filter_input)
+        tb.addWidget(self._filter_btn)
+        tb.addWidget(clear_filter_btn)
+        tb.addWidget(self._refresh_btn)
+        tb.addWidget(sep)
+        tb.addWidget(self._add_btn)
+        tb.addWidget(self._edit_btn)
+        tb.addWidget(self._delete_btn)
+        tb.addStretch()
+        root.addLayout(tb)
+
+        # ── Table view ─────────────────────────────────────────────────────────
+        self._table_view = QTableView()
+        self._table_view.setModel(self._model)
+        self._table_view.setAlternatingRowColors(True)
+        self._table_view.setSortingEnabled(False)
+        self._table_view.setSelectionBehavior(
+            QAbstractItemView.SelectionBehavior.SelectRows)
+        self._table_view.setSelectionMode(
+            QAbstractItemView.SelectionMode.ExtendedSelection)
+        self._table_view.horizontalHeader().setSectionResizeMode(
+            QHeaderView.ResizeMode.Interactive)
+        self._table_view.horizontalHeader().setStretchLastSection(True)
+        self._table_view.verticalHeader().setDefaultSectionSize(24)
+        self._table_view.setContextMenuPolicy(
+            Qt.ContextMenuPolicy.CustomContextMenu)
+        self._table_view.customContextMenuRequested.connect(self._context_menu)
+        self._table_view.doubleClicked.connect(self._on_double_click)
+        # Track selection to enable/disable Edit/Delete buttons.
+        # Use both signals: clicked covers mouse, selectionChanged covers keyboard.
+        self._table_view.clicked.connect(lambda _: self._refresh_action_states())
+        self._table_view.selectionModel().selectionChanged.connect(
+            self._on_selection_changed)
+
+        # Keyboard shortcuts
+        QShortcut(QKeySequence("Delete"), self._table_view,
+                  self._delete_selected)
+        QShortcut(QKeySequence("Ins"), self._table_view, self._add_row)
+
+        root.addWidget(self._table_view, 1)
+
+        # ── Pagination bar (prominent, always visible) ─────────────────────────
+        pg_frame = QWidget()
+        pg_frame.setObjectName("paginationBar")
+        pg = QHBoxLayout(pg_frame)
+        pg.setContentsMargins(10, 6, 10, 6)
+        pg.setSpacing(4)
+
+        self._first_btn = QPushButton("⏮ First")
+        self._prev_btn  = QPushButton("◀ Prev")
+        self._next_btn  = QPushButton("Next ▶")
+        self._last_btn  = QPushButton("Last ⏭")
+        for b in (self._first_btn, self._prev_btn,
+                  self._next_btn, self._last_btn):
+            b.setFixedWidth(80)
+            b.setObjectName("pgBtn")
+        self._first_btn.clicked.connect(self._first_page)
+        self._prev_btn.clicked.connect(self._prev_page)
+        self._next_btn.clicked.connect(self._next_page)
+        self._last_btn.clicked.connect(self._last_page)
+
+        self._page_lbl = QLabel("Page 1 / ?")
+        self._page_lbl.setObjectName("pageLbl")
+        self._page_lbl.setMinimumWidth(110)
+        self._page_lbl.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        # Page jump
+        self._goto_input = QLineEdit()
+        self._goto_input.setPlaceholderText("Jump to page…")
+        self._goto_input.setFixedWidth(110)
+        self._goto_input.returnPressed.connect(self._goto_page)
+        goto_btn = QPushButton("Go")
+        goto_btn.setFixedWidth(40)
+        goto_btn.clicked.connect(self._goto_page)
+
+        # Page size selector
+        self._page_size_combo = QComboBox()
+        for label, _ in _PAGE_OPTIONS:
+            self._page_size_combo.addItem(label)
+        self._page_size_combo.setCurrentIndex(1)   # default = 100
+        self._page_size_combo.setFixedWidth(72)
+        self._page_size_combo.setToolTip("Rows per page")
+        self._page_size_combo.currentIndexChanged.connect(self._on_page_size_changed)
+
+        self._total_lbl = QLabel("")
+        self._total_lbl.setObjectName("rowCountLbl")
+
+        pg.addWidget(self._first_btn)
+        pg.addWidget(self._prev_btn)
+        pg.addWidget(self._page_lbl)
+        pg.addWidget(self._next_btn)
+        pg.addWidget(self._last_btn)
+        pg.addSpacing(10)
+        pg.addWidget(self._goto_input)
+        pg.addWidget(goto_btn)
+        pg.addStretch()
+        pg.addWidget(QLabel("Rows / page:"))
+        pg.addWidget(self._page_size_combo)
+        pg.addSpacing(8)
+        pg.addWidget(self._total_lbl)
+        root.addWidget(pg_frame)
+
+    # ── Page size ──────────────────────────────────────────────────────────────
+
+    def _on_page_size_changed(self, idx: int):
+        self._page_size = _PAGE_OPTIONS[idx][1]
+        self._offset = 0
+        self._load_page()
+
+    # ── Data loading ───────────────────────────────────────────────────────────
+
+    def _load_page(self):
+        where = self._filter_input.text().strip()
+        limit = self._page_size if self._page_size > 0 else 999_999_999
+        self._worker = TableDataWorker(
+            self._driver, self._database, self._table,
+            where=where, limit=limit, offset=self._offset
+        )
+        self._worker.finished.connect(self._on_data)
+        self._worker.error.connect(self._on_error)
+        self._worker.start()
+
+    def _on_data(self, cols: list, rows: list, total: int):
+        self._model.set_data(cols, rows)
+        self._total = total
+        self._refresh_pagination()
+        self._refresh_action_states()
+        self._table_view.resizeColumnsToContents()
+        self._table_view.horizontalHeader().setStretchLastSection(True)
+
+    def _on_error(self, msg: str):
+        self._total_lbl.setText(f"Error: {msg[:80]}")
+        self.status_message.emit(f"Error: {msg}")
+
+    def _refresh_pagination(self):
+        ps = self._page_size if self._page_size > 0 else max(self._total, 1)
+        rows_loaded   = self._model.rowCount()
+        current_page  = (self._offset // ps + 1) if ps else 1
+
+        if self._total > 0:
+            total_pages = max(1, (self._total + ps - 1) // ps)
+            page_str    = f"Page {current_page} / {total_pages}"
+            # showing X – Y of N
+            row_from = self._offset + 1
+            row_to   = min(self._offset + rows_loaded, self._total)
+            info_str = f"Showing {row_from:,} – {row_to:,} of {self._total:,} rows"
+        else:
+            # total count unavailable – use row count as best guess
+            total_pages = current_page  # don't know max
+            page_str    = f"Page {current_page}"
+            info_str    = f"{rows_loaded:,} rows loaded"
+
+        self._page_lbl.setText(page_str)
+        self._total_lbl.setText(info_str)
+
+        at_first = (self._offset == 0)
+        # Next is allowed if: we have a known total and haven't reached it,
+        # OR if a full page was returned (more rows might exist)
+        if self._page_size > 0:
+            if self._total > 0:
+                at_last = (self._offset + ps) >= self._total
+            else:
+                at_last = rows_loaded < ps   # partial page → must be last
+        else:
+            at_last = True   # "All" mode
+
+        self._first_btn.setEnabled(not at_first)
+        self._prev_btn.setEnabled(not at_first)
+        self._next_btn.setEnabled(not at_last)
+        self._last_btn.setEnabled(not at_last)
+
+    # ── Pagination controls ────────────────────────────────────────────────────
+
+    def _first_page(self):
+        self._offset = 0
+        self._load_page()
+
+    def _prev_page(self):
+        ps = self._page_size if self._page_size > 0 else self._total
+        self._offset = max(0, self._offset - ps)
+        self._load_page()
+
+    def _next_page(self):
+        ps = self._page_size if self._page_size > 0 else self._total
+        self._offset = min(self._offset + ps,
+                           max(0, self._total - ps))
+        self._load_page()
+
+    def _last_page(self):
+        ps = self._page_size if self._page_size > 0 else self._total
+        self._offset = max(0, ((self._total - 1) // ps) * ps) if ps else 0
+        self._load_page()
+
+    def _goto_page(self):
+        ps = self._page_size if self._page_size > 0 else max(self._total, 1)
+        try:
+            page = int(self._goto_input.text().strip())
+            total_pages = max(1, (self._total + ps - 1) // ps)
+            page = max(1, min(page, total_pages))
+            self._offset = (page - 1) * ps
+            self._goto_input.clear()
+            self._load_page()
+        except ValueError:
+            pass
+
+    def _apply_filter(self):
+        self._offset = 0
+        self._load_page()
+
+    def _clear_filter(self):
+        self._filter_input.clear()
+        self._offset = 0
+        self._load_page()
+
+    # ── Selection tracking ─────────────────────────────────────────────────────
+
+    def _on_selection_changed(self, *_):
+        has_sel = bool(self._table_view.selectionModel().selectedRows())
+        self._edit_btn.setEnabled(has_sel)
+        self._delete_btn.setEnabled(has_sel)
+
+    def _refresh_action_states(self, *_):
+        self._on_selection_changed()
+
+    def _selected_logical_rows(self) -> list:
+        """Return sorted list of logical (source model) row indices."""
+        return sorted(set(
+            idx.row() for idx in self._table_view.selectionModel().selectedRows()
+        ))
+
+    # ── Context menu ───────────────────────────────────────────────────────────
+
+    def _context_menu(self, pos):
+        rows = self._selected_logical_rows()
+        menu = QMenu(self)
+        menu.addAction("➕ Add Row",    self._add_row)
+        if rows:
+            menu.addAction("✏️ Edit Row",   self._edit_selected)
+            menu.addAction("🗑️ Delete Row", self._delete_selected)
+        menu.addSeparator()
+        menu.addAction("📋 Copy cell value", lambda: self._copy_cell(pos))
+        menu.addAction("📋 Copy row",        self._copy_selected_rows)
+        menu.exec(self._table_view.viewport().mapToGlobal(pos))
+
+    # ── Double-click: edit ────────────────────────────────────────────────────
+
+    def _on_double_click(self, index: QModelIndex):
+        """Open edit dialog for the double-clicked row."""
+        row = index.row()
+        cols = self._model.column_names()
+        current = {cols[c]: self._model.get_row_current(row)[c]
+                   for c in range(len(cols))}
+        dlg = RowDialog(cols, initial=current, title=f"Edit Row — {self._table}",
+                        mode="edit", parent=self)
+        if dlg.exec():
+            new_vals = dlg.values
+            original = self._model.get_row_original(row)
+            where    = {cols[i]: original[i] for i in range(len(cols))}
+            try:
+                self._driver.update_row(
+                    self._database, self._table, new_vals, where
+                )
+                self.status_message.emit("Row updated.")
+                self._load_page()
+            except Exception as e:
+                QMessageBox.critical(self, "Update Error", str(e))
+
+    # ── CRUD actions ──────────────────────────────────────────────────────────
+
+    def _add_row(self):
+        cols = self._model.column_names()
+        if not cols:
+            # No data loaded yet — try fetching column names
+            try:
+                col_infos = self._driver.get_columns(self._database, self._table)
+                cols = [c.name for c in col_infos]
+            except Exception as e:
+                QMessageBox.critical(self, "Error", str(e))
+                return
+
+        dlg = RowDialog(cols, title=f"Add Row — {self._table}", mode="add", parent=self)
+        if dlg.exec():
+            row_data = {k: v for k, v in dlg.values.items()}
+            # Remove purely empty optional fields (let DB use defaults)
+            row_data = {k: v for k, v in row_data.items() if v is not None}
+            try:
+                self._driver.insert_row(self._database, self._table, row_data)
+                self.status_message.emit("Row inserted.")
+                self._load_page()
+            except Exception as e:
+                QMessageBox.critical(self, "Insert Error", str(e))
+
+    def _edit_selected(self):
+        rows = self._selected_logical_rows()
+        if not rows:
+            return
+        if len(rows) > 1:
+            QMessageBox.information(self, "Edit Row",
+                                    "Please select a single row to edit.")
+            return
+        self._on_double_click(self._model.index(rows[0], 0))
+
+    def _delete_selected(self):
+        rows = self._selected_logical_rows()
+        if not rows:
+            return
+        n = len(rows)
+        btn = QMessageBox.warning(
+            self, "Delete Row(s)",
+            f"Are you sure you want to delete {n} row(s)?\n"
+            "This action will be sent to the database immediately.",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No,
+        )
+        if btn != QMessageBox.StandardButton.Yes:
+            return
+
+        cols   = self._model.column_names()
+        errors = []
+        for r in rows:
+            original = self._model.get_row_original(r)
+            where    = {cols[i]: original[i] for i in range(len(cols))}
+            try:
+                self._driver.delete_row(self._database, self._table, where)
+            except Exception as e:
+                errors.append(str(e))
+
+        if errors:
+            QMessageBox.critical(self, "Delete Error", "\n".join(errors))
+        else:
+            self.status_message.emit(f"{n} row(s) deleted.")
+        self._load_page()
+
+
+    # ── Copy helpers ──────────────────────────────────────────────────────────
+
+    def _copy_cell(self, pos):
+        idx = self._table_view.indexAt(pos)
+        if idx.isValid():
+            val = self._model.data(idx, Qt.ItemDataRole.DisplayRole) or ""
+            QApplication.clipboard().setText(str(val))
+
+    def _copy_selected_rows(self):
+        rows = self._selected_logical_rows()
+        cols = self._model.column_names()
+        lines = ["\t".join(cols)]
+        for r in rows:
+            row_data = self._model.get_row_current(r)
+            lines.append("\t".join("" if v is None else str(v) for v in row_data))
+        QApplication.clipboard().setText("\n".join(lines))