Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(grid): set selected cell to null on bare delete or backspace

lxk955b67eaa58a086
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index c795f099a3..3a823cb952 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -9957,6 +9957,19 @@ function fillSelectionWithValue(value: string | null, options: { preserveEmptySt
const allowDraftSelectionValue = selectedRangeTargetsOnlyDraftRow();
beginBatch();
try {
+ if (selectedCellKeys.value.size > 0) {
+ for (const key of selectedCellKeys.value) {
+ const [rStr, cStr] = key.split(":");
+ const rowIndex = Number(rStr);
+ const visibleCol = Number(cStr);
+ if (Number.isNaN(rowIndex) || Number.isNaN(visibleCol)) continue;
+ const item = displayItemAt(rowIndex);
+ if (!item) continue;
+ if (cellIsSelected(rowIndex, visibleCol)) applied = applyVisibleSelectedCellValue(item, visibleCol, value, allowDraftSelectionValue, options) || applied;
+ }
+ return applied;
+ }
+
if (range) {
for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex++) {
const item = displayItemAt(rowIndex);
@@ -9985,6 +9998,19 @@ function fillSelectionWithValue(value: string | null, options: { preserveEmptySt
}
function selectionHasEditableCells(): boolean {
+ if (selectedCellKeys.value.size > 0) {
+ for (const key of selectedCellKeys.value) {
+ const [rStr, cStr] = key.split(":");
+ const rowIndex = Number(rStr);
+ const visibleCol = Number(cStr);
+ if (Number.isNaN(rowIndex) || Number.isNaN(visibleCol)) continue;
+ const item = displayItemAt(rowIndex);
+ if (!item) continue;
+ if (transposeIncludesRow(item.id) && cellIsSelected(rowIndex, visibleCol) && canEditCellItem(item, actualColumnIndex(visibleCol))) return true;
+ }
+ return false;
+ }
+
const range = selectedRange.value;
if (range) {
for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex++) {
@@ -10943,9 +10969,24 @@ async function onGridKeydown(event: KeyboardEvent) {
event.preventDefault();
return;
}
- if (isDeleteCurrentRowShortcut(event, settingsStore.editorSettings.shortcuts) && deleteCurrentRow()) {
- event.preventDefault();
- return;
+ const isBareDelete = !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && (event.key === "Delete" || event.key === "Backspace");
+ if (isBareDelete) {
+ if (hasRowSelection.value && selectedRowCount.value > 0) {
+ if (deleteCurrentRow()) {
+ event.preventDefault();
+ }
+ return;
+ }
+ if (hasCellSelection.value || hasColumnSelection.value || !!selectedRange.value || selectedCellCount.value > 0 || !!currentSelectedCellPosition()) {
+ event.preventDefault();
+ setSelectionNull();
+ return;
+ }
+ } else if (isDeleteCurrentRowShortcut(event, settingsStore.editorSettings.shortcuts)) {
+ if (deleteCurrentRow()) {
+ event.preventDefault();
+ return;
+ }
}
if (isToggleTransposeShortcut(event, settingsStore.editorSettings.shortcuts) && toggleKeyboardTranspose()) {
event.preventDefault();
@@ -13571,6 +13612,12 @@ defineExpose({
focusWhere,
editSelectedCell,
selectSingleCell,
+ selectRow,
+ hasRowSelection,
+ displayItems,
+ hasPendingChanges,
+ showDeleteRowConfirm,
+ pendingDeleteRowIds,
openGoToColumn,
visibleColumnCount,
displayableColumnCount,
diff --git a/apps/desktop/src/components/grid/__tests__/DataGridDeleteShortcut.spec.ts b/apps/desktop/src/components/grid/__tests__/DataGridDeleteShortcut.spec.ts
new file mode 100644
index 0000000000..b2973be6c9
--- /dev/null
+++ b/apps/desktop/src/components/grid/__tests__/DataGridDeleteShortcut.spec.ts
@@ -0,0 +1,275 @@
+// @vitest-environment happy-dom
+
+import { createApp, defineComponent, h, markRaw, nextTick, ref, type App, type PropType } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import i18n from "@/i18n";
+import type { ColumnInfo, DatabaseType, QueryResult } from "@/types/database";
+import { TooltipProvider } from "@/components/ui/tooltip";
+
+vi.mock("@/composables/useDataGridColumnResize", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("@/composables/useDataGridColumnResize")>();
+ const { ref } = await import("vue");
+ return {
+ ...actual,
+ useDataGridColumnResize: () => ({
+ initColumnWidths: vi.fn(),
+ onResizeStart: vi.fn(),
+ autoFitColumn: vi.fn(),
+ renderedColumnWidths: ref([120, 120]),
+ totalWidth: ref(240),
+ columnVars: ref({ "--total-w": "240px" }),
+ getIsResizing: () => false,
+ }),
+ };
+});
+
+import DataGrid from "../DataGrid.vue";
+import { useSettingsStore } from "@/stores/settingsStore";
+
+const mountedApps: Array<{ app: App; host: HTMLElement }> = [];
+
+const RecycleScroller = defineComponent({
+ props: {
+ items: {
+ type: Array as PropType<unknown[]>,
+ default: () => [],
+ },
+ },
+ setup(props, { attrs, slots }) {
+ return () =>
+ h(
+ "div",
+ attrs,
+ props.items.map((item) => slots.default?.({ item })),
+ );
+ },
+});
+
+interface TableMeta {
+ catalog?: string;
+ schema?: string;
+ tableName: string;
+ columns: ColumnInfo[];
+ primaryKeys: string[];
+}
+
+function mountGrid(
+ options: {
+ context?: "results" | "table-data";
+ databaseType?: DatabaseType;
+ connectionId?: string;
+ database?: string;
+ tableMeta?: TableMeta | null;
+ deleteRowShortcut?: string;
+ editable?: boolean;
+ } = {},
+) {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ const settingsStore = useSettingsStore();
+ settingsStore.updateEditorSettings({
+ dataGridRenderMode: "canvas",
+ shortcuts: {
+ ...settingsStore.editorSettings.shortcuts,
+ ...(options.deleteRowShortcut ? { deleteCurrentRow: options.deleteRowShortcut } : {}),
+ },
+ });
+ const result = markRaw<QueryResult>({
+ columns: ["id", "name"],
+ rows: [
+ [1, "Alice"],
+ [2, "Bob"],
+ ],
+ affected_rows: 0,
+ execution_time_ms: 0,
+ });
+ const defaultTableMeta: TableMeta = {
+ catalog: "warehouse",
+ schema: "public",
+ tableName: "users",
+ columns: [
+ { name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+ { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+ ],
+ primaryKeys: ["id"],
+ };
+
+ const host = document.createElement("div");
+ const grid = ref<{
+ selectSingleCell: (row: number, col: number) => void;
+ selectRow: (rowIndex: number) => void;
+ hasRowSelection: boolean;
+ displayItems: Array<{ id: number; data: unknown[]; isDirtyCol: boolean[] }>;
+ hasPendingChanges: boolean;
+ showDeleteRowConfirm: boolean;
+ pendingDeleteRowIds: number[];
+ }>();
+ document.body.append(host);
+ const Root = defineComponent({
+ setup() {
+ return () =>
+ h(
+ TooltipProvider,
+ { delayDuration: 0 },
+ {
+ default: () =>
+ h(DataGrid, {
+ ref: grid,
+ result,
+ databaseType: options.databaseType ?? "mysql",
+ context: options.context ?? "table-data",
+ editable: options.editable ?? true,
+ connectionId: options.connectionId ?? "connection-1",
+ database: options.database ?? "app",
+ tableMeta: options.tableMeta === null ? undefined : (options.tableMeta ?? defaultTableMeta),
+ }),
+ },
+ );
+ },
+ });
+ const app = createApp(Root);
+ app.use(pinia);
+ app.use(i18n);
+ app.component("RecycleScroller", RecycleScroller);
+ app.mount(host);
+ mountedApps.push({ app, host });
+ return { host, grid };
+}
+
+async function settle() {
+ await nextTick();
+ await Promise.resolve();
+ await nextTick();
+}
+
+function gridRoot(host: HTMLElement): HTMLElement {
+ const root = host.querySelector<HTMLElement>("[data-grid-root]");
+ if (!root) throw new Error("Data grid root not found");
+ return root;
+}
+
+function dispatchKey(target: HTMLElement, key: string, modifiers: { ctrlKey?: boolean; metaKey?: boolean; altKey?: boolean; shiftKey?: boolean } = {}): KeyboardEvent {
+ const event = new KeyboardEvent("keydown", { bubbles: true, cancelable: true, key, ...modifiers });
+ target.dispatchEvent(event);
+ return event;
+}
+
+afterEach(() => {
+ window.getSelection()?.removeAllRanges();
+ for (const { app, host } of mountedApps.splice(0)) {
+ app.unmount();
+ host.remove();
+ }
+});
+
+describe("DataGrid delete key cell null and row delete behavior", () => {
+ it("sets selected cell value to null when Delete key is pressed without deleting the row (#11958)", async () => {
+ const { host, grid } = mountGrid();
+ await settle();
+ const root = gridRoot(host);
+ grid.value?.selectSingleCell(0, 1);
+ await settle();
+
+ expect(grid.value?.displayItems[0]?.data[1]).toBe("Alice");
+ expect(grid.value?.hasRowSelection).toBe(false);
+
+ const event = dispatchKey(root, "Delete");
+ await settle();
+
+ expect(event.defaultPrevented).toBe(true);
+ expect(grid.value?.displayItems[0]?.data[1]).toBeNull();
+ expect(grid.value?.displayItems[0]?.isDirtyCol[1]).toBe(true);
+ expect(grid.value?.displayItems.length).toBe(2);
+ expect(grid.value?.showDeleteRowConfirm).toBe(false);
+ });
+
+ it("sets selected cell value to null when Backspace key is pressed (macOS delete key) (#11958)", async () => {
+ const { host, grid } = mountGrid();
+ await settle();
+ const root = gridRoot(host);
+ grid.value?.selectSingleCell(1, 1);
+ await settle();
+
+ expect(grid.value?.displayItems[1]?.data[1]).toBe("Bob");
+ expect(grid.value?.hasRowSelection).toBe(false);
+
+ const event = dispatchKey(root, "Backspace");
+ await settle();
+
+ expect(event.defaultPrevented).toBe(true);
+ expect(grid.value?.displayItems[1]?.data[1]).toBeNull();
+ expect(grid.value?.displayItems[1]?.isDirtyCol[1]).toBe(true);
+ expect(grid.value?.displayItems.length).toBe(2);
+ expect(grid.value?.showDeleteRowConfirm).toBe(false);
+ });
+
+ it("triggers row deletion when a whole row is selected and Delete is pressed", async () => {
+ const { host, grid } = mountGrid();
+ await settle();
+ const root = gridRoot(host);
+ grid.value?.selectRow(0);
+ await settle();
+
+ expect(grid.value?.hasRowSelection).toBe(true);
+
+ const event = dispatchKey(root, "Delete");
+ await settle();
+
+ expect(event.defaultPrevented).toBe(true);
+ expect(grid.value?.showDeleteRowConfirm).toBe(true);
+ expect(grid.value?.pendingDeleteRowIds.length).toBeGreaterThan(0);
+ // Cell value is not set to null
+ expect(grid.value?.displayItems[0]?.data[1]).toBe("Alice");
+ });
+
+ it("does not modify cell or delete row when the grid is read-only", async () => {
+ const { host, grid } = mountGrid({ editable: false });
+ await settle();
+ const root = gridRoot(host);
+ grid.value?.selectSingleCell(0, 1);
+ await settle();
+
+ const event = dispatchKey(root, "Delete");
+ await settle();
+
+ expect(event.defaultPrevented).toBe(true);
+ expect(grid.value?.displayItems[0]?.data[1]).toBe("Alice");
+ expect(grid.value?.displayItems.length).toBe(2);
+ expect(grid.value?.showDeleteRowConfirm).toBe(false);
+ });
+
+ it("leaves editable input targets untouched on Delete key", async () => {
+ const { host } = mountGrid();
+ await settle();
+ const root = gridRoot(host);
+ const input = document.createElement("input");
+ root.append(input);
+
+ const event = dispatchKey(input, "Delete");
+ await settle();
+
+ expect(event.defaultPrevented).toBe(false);
+ });
+
+ it("supports custom deleteCurrentRow shortcut while still allowing Delete key on cells", async () => {
+ const { host, grid } = mountGrid({ deleteRowShortcut: "Mod+Shift+K" });
+ await settle();
+ const root = gridRoot(host);
+ grid.value?.selectSingleCell(0, 1);
+ await settle();
+
+ // Plain Delete still clears cell to null
+ const deleteEvent = dispatchKey(root, "Delete");
+ await settle();
+ expect(deleteEvent.defaultPrevented).toBe(true);
+ expect(grid.value?.displayItems[0]?.data[1]).toBeNull();
+ expect(grid.value?.showDeleteRowConfirm).toBe(false);
+
+ // Custom shortcut Mod+Shift+K triggers row deletion
+ const customEvent = dispatchKey(root, "K", { ctrlKey: true, shiftKey: true });
+ await settle();
+ expect(customEvent.defaultPrevented).toBe(true);
+ expect(grid.value?.showDeleteRowConfirm).toBe(true);
+ });
+});