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。

feat(dataGrid): MySQL添加删除列按钮

Yifeng Xuf2e488979f4c
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index e09cc40cf1..764ae5a98e 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -397,7 +397,7 @@ import { useDataGridAsyncSurface } from "@/composables/useDataGridAsyncSurface";
import { createDataGridFilterConditionCache, useDataGridFilterBuilder, type DataGridStructuredFilterRule } from "@/composables/useDataGridFilterBuilder";
import { DATA_GRID_DISTINCT_VALUE_DEFAULT_LIMIT, useDataGridDistinctValueLoader } from "@/composables/useDataGridDistinctValueLoader";
import { dataGridDistinctValueKey, dataGridNullSuggestionFilterMode, toggleAllDataGridDistinctValueOptions, type DataGridDistinctValueSource, type DataGridDistinctValueSuggestionState, type DataGridDistinctValueSuggestionTarget } from "@/lib/dataGrid/dataGridDistinctValueSuggestions";
-import { cloneDataGridStructuredFilterRules, loadDataGridStructuredFilterState, saveDataGridStructuredFilterState, type DataGridCachedServerColumnFilter, type DataGridStructuredFilterCacheState } from "@/lib/dataGrid/dataGridFilterBuilderPersistence";
+import { cloneDataGridStructuredFilterRules, loadDataGridStructuredFilterState, removeDataGridStructuredFilterColumnsForTab, saveDataGridStructuredFilterState, type DataGridCachedServerColumnFilter, type DataGridStructuredFilterCacheState } from "@/lib/dataGrid/dataGridFilterBuilderPersistence";
import { createDataGridSearchScopeKey } from "@/lib/dataGrid/dataGridSearchStatePersistence";
import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
import { useCellDetailEditor, type UseCellDetailEditorReturn } from "@/composables/useCellDetailEditor";
@@ -423,6 +423,25 @@ import {
type DataGridToolbarAutoRefreshCapability,
type DataGridToolbarSaveCapability,
} from "@/lib/dataGrid/dataGridToolbar";
+import {
+ dataGridColumnNameKey,
+ dataGridDroppedColumnNames,
+ dataGridDropColumnToolbarState,
+ dataGridDropColumnVisibleIndexes,
+ dataGridDropTabsHavePending,
+ dataGridDropTargetTabs,
+ dataGridSqlTextReferencesAnyColumn,
+ isDataGridColumnNameCaseSensitive,
+ isDataGridViewTable,
+ sameOptionalScope as sameOptionalDropScope,
+ type DataGridDropColumnCandidate,
+} from "@/lib/dataGrid/dataGridDropColumn";
+import { buildDropTableChildObjectSql } from "@/lib/database/dbAdminSql";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { invalidateTableMetadataCache } from "@/lib/metadata/tableMetadataCache";
+import { invalidateObjectMetadataCache } from "@/lib/metadata/objectMetadataCache";
+import { isProtectedManticoreIdColumn } from "@/lib/table/tableStructureEditorState";
+import { queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
import { getTableMetadataCapabilities } from "@/lib/table/tableMetadataCapabilities";
import { getTableStructureCapabilities } from "@/lib/table/tableStructureCapabilities";
import { constraintsForConstraintsTab } from "@/lib/table/constraintPresentation";
@@ -1948,6 +1967,7 @@ function loadStructuredFilterStateForScope() {
}
appliedStructuredWhereInput.value = "";
serverColumnFilters.value = {};
+ whereFilterInput.value = props.initialWhereInput ?? "";
structuredFilterRules.value = filterBuilderColumnOptions.value.length > 0 ? [defaultStructuredFilterRule()] : [];
markConditionInputsApplied();
structuredFilterHydrationReady.value = true;
@@ -5503,6 +5523,342 @@ const deleteRowToolbarCapability = computed<DataGridToolbarActionCapability>(()
deleteCurrentRow();
},
}));
+const showDropColumnConfirm = ref(false);
+const dropColumnLoading = ref(false);
+const dropColumnPreviewSql = ref("");
+const pendingDropColumnNames = ref<string[]>([]);
+const pendingDropColumnStatements = ref<string[]>([]);
+interface DropColumnTarget {
+ connectionId: string;
+ database: string;
+ schema: string;
+ catalog: string;
+ tableName: string;
+ /** Schema argument for getColumns, which falls back to the database for non-schema-aware engines. */
+ columnsSchema: string;
+}
+// Snapshot of the table the confirm dialog was opened for; the props may move on before confirm.
+const pendingDropColumnTarget = ref<DropColumnTarget | null>(null);
+let dropColumnRequestId = 0;
+
+function currentDropColumnTarget(): DropColumnTarget | null {
+ const table = props.tableMeta;
+ const database = table?.database || props.database;
+ if (!table?.tableName || !props.connectionId || !database) return null;
+ const schema = table.schema ?? props.schema ?? "";
+ return {
+ connectionId: props.connectionId,
+ database,
+ schema,
+ catalog: table.catalog ?? "",
+ tableName: table.tableName,
+ columnsSchema: schema || (isSchemaAware(resolvedDatabaseType.value) ? "" : database),
+ };
+}
+
+function sameDropColumnTarget(left: DropColumnTarget | null, right: DropColumnTarget | null): boolean {
+ return !!left && !!right && left.connectionId === right.connectionId && left.database === right.database && left.schema === right.schema && left.catalog === right.catalog && left.tableName === right.tableName;
+}
+
+// Table or connection changed under an open confirm: drop it so the user reselects.
+watch(
+ () => {
+ const target = currentDropColumnTarget();
+ return target ? [target.connectionId, target.database, target.schema, target.catalog, target.tableName].join("\u0000") : "";
+ },
+ () => {
+ if (!showDropColumnConfirm.value || dropColumnLoading.value) return;
+ if (sameDropColumnTarget(pendingDropColumnTarget.value, currentDropColumnTarget())) return;
+ dropColumnRequestId++;
+ showDropColumnConfirm.value = false;
+ },
+);
+// Replaced once selection state exists. Toolbar computeds read it lazily on render.
+let dropColumnCandidatesNow = (): DataGridDropColumnCandidate[] => [];
+
+// ponytail: MySQL only. Doris/StarRocks external catalogs need catalog-aware DDL, so they stay hidden.
+const dropColumnCaseSensitive = () => isDataGridColumnNameCaseSensitive(tableStructureCapabilities.value.dialect);
+const dropColumnKey = (name: string) => dataGridColumnNameKey(name, dropColumnCaseSensitive());
+// Unsaved rows or a cell draft in ANY open page of this table: the post-drop refresh would wipe them.
+const dropColumnOpenTabsPending = () => {
+ const target = currentDropColumnTarget();
+ return !!target && dataGridDropTabsHavePending(dataGridDropTargetTabs(queryStore.tabs, target));
+};
+
+const dropColumnToolbarState = computed(() =>
+ dataGridDropColumnToolbarState({
+ available: props.context === "table-data" && resolvedDatabaseType.value === "mysql" && !!props.tableMeta?.tableName && !!props.connectionId && !!props.database && !isDataGridViewTable(props.tableMeta.tableType) && tableStructureCapabilities.value.dropColumn,
+ busy: props.loading === true || isSaving.value || dropColumnLoading.value,
+ pendingChanges: hasPendingChanges.value || dropColumnOpenTabsPending(),
+ tableColumnCount: props.tableMeta?.columns.length ?? 0,
+ targets: dropColumnCandidatesNow(),
+ }),
+);
+const dropColumnToolbarTooltip = computed(() => {
+ switch (dropColumnToolbarState.value.blockedReason) {
+ case "pending":
+ return t("grid.deleteColumnPendingChanges");
+ case "primary-key":
+ return t("grid.deleteColumnPrimaryKey");
+ case "protected":
+ return t("grid.deleteColumnProtected");
+ case "last-column":
+ return t("grid.deleteColumnLastColumn");
+ case "no-target":
+ return t("grid.deleteColumnSelectColumn");
+ default:
+ return t("grid.deleteColumnTooltip");
+ }
+});
+const deleteColumnToolbarCapability = computed<DataGridToolbarActionCapability>(() => {
+ const count = dropColumnCandidatesNow().length;
+ return {
+ label: count > 1 ? t("grid.deleteColumns", { count }) : t("grid.deleteColumn"),
+ tooltip: dropColumnToolbarTooltip.value,
+ visible: dropColumnToolbarState.value.visible,
+ disabled: dropColumnToolbarState.value.disabled,
+ onTrigger: () => {
+ void requestDropColumns();
+ },
+ };
+});
+const dropColumnConfirmMessage = computed(() => {
+ const table = pendingDropColumnTarget.value?.tableName ?? "";
+ if (pendingDropColumnNames.value.length > 1) {
+ return t("grid.deleteColumnsMessage", {
+ table,
+ count: pendingDropColumnNames.value.length,
+ columns: pendingDropColumnNames.value.join(", "),
+ });
+ }
+ return t("grid.deleteColumnMessage", { table, column: pendingDropColumnNames.value[0] ?? "" });
+});
+
+async function requestDropColumns() {
+ if (dropColumnToolbarState.value.disabled || dropColumnLoading.value || showDropColumnConfirm.value) return;
+ const target = currentDropColumnTarget();
+ if (!target || !props.database) return;
+ const names = dropColumnCandidatesNow().map((candidate) => candidate.name);
+ if (names.length === 0) return;
+ const requestId = ++dropColumnRequestId;
+ pendingDropColumnTarget.value = target;
+ pendingDropColumnNames.value = names;
+ pendingDropColumnStatements.value = [];
+ dropColumnPreviewSql.value = "";
+ showDropColumnConfirm.value = true;
+ try {
+ const statements = await Promise.all(
+ names.map((name) =>
+ buildDropTableChildObjectSql({
+ databaseType: resolvedDatabaseType.value,
+ objectType: "COLUMN",
+ schema: target.schema || undefined,
+ tableName: target.tableName,
+ name,
+ }),
+ ),
+ );
+ if (requestId !== dropColumnRequestId || !showDropColumnConfirm.value) return;
+ pendingDropColumnStatements.value = statements.filter((statement) => statement.trim());
+ dropColumnPreviewSql.value = pendingDropColumnStatements.value.join("\n");
+ } catch (error: unknown) {
+ if (requestId !== dropColumnRequestId) return;
+ showDropColumnConfirm.value = false;
+ const message = error instanceof Error ? error.message : String(error);
+ toast(t("grid.deleteColumnFailed", { message }), 5000);
+ }
+}
+
+async function forgetDroppedColumnQueryState(names: string[]): Promise<boolean> {
+ const dropped = new Set(names.map(dropColumnKey));
+ let cleared = false;
+ const nextServerFilters = { ...serverColumnFilters.value };
+ for (const [index, filter] of Object.entries(serverColumnFilters.value)) {
+ const columnName = props.result.columns[Number(index)];
+ if (!columnName || !dropped.has(dropColumnKey(columnName))) continue;
+ whereFilterInput.value = removeColumnValueFilterCondition(whereFilterInput.value, filter.condition);
+ delete nextServerFilters[Number(index)];
+ cleared = true;
+ }
+ if (cleared) serverColumnFilters.value = nextServerFilters;
+ if (dataGridSqlTextReferencesAnyColumn(whereFilterInput.value, names, dropColumnCaseSensitive())) {
+ whereFilterInput.value = "";
+ cleared = true;
+ }
+ const remainingRules = structuredFilterRules.value.filter((rule) => !rule.columnName || !dropped.has(dropColumnKey(rule.columnName)));
+ if (remainingRules.length !== structuredFilterRules.value.length) {
+ structuredFilterRules.value = remainingRules.length > 0 ? remainingRules : [defaultStructuredFilterRule()];
+ try {
+ appliedStructuredWhereInput.value = await buildStructuredWhereFromRules(structuredFilterRules.value);
+ } catch {
+ appliedStructuredWhereInput.value = "";
+ }
+ cleared = true;
+ }
+ if (sortCol.value && dropped.has(dropColumnKey(sortCol.value))) {
+ clearSort();
+ syncOrderByInputWithSort(null, null);
+ cleared = true;
+ } else if (dataGridSqlTextReferencesAnyColumn(orderByInput.value, names, dropColumnCaseSensitive())) {
+ orderByInput.value = "";
+ cleared = true;
+ }
+ const droppedIndexes = new Set<number>();
+ props.result.columns.forEach((columnName, index) => {
+ if (columnName && dropped.has(dropColumnKey(columnName))) droppedIndexes.add(index);
+ });
+ if ([...droppedIndexes].some((index) => localColumnFilters.value[index])) {
+ const nextLocalFilters: Record<number, Set<string>> = {};
+ for (const [index, values] of Object.entries(localColumnFilters.value)) {
+ if (!droppedIndexes.has(Number(index))) nextLocalFilters[Number(index)] = values;
+ }
+ localColumnFilters.value = nextLocalFilters;
+ cleared = true;
+ }
+ return cleared;
+}
+
+async function patchOpenDataTabsAfterColumnDrop(target: DropColumnTarget, names: string[]) {
+ if (names.length === 0) return;
+ // Flush the current grid's cleaned visual rules before migrating their scope.
+ persistStructuredFilterState();
+ const dropped = new Set(names.map(dropColumnKey));
+ const keep = (name: string) => !dropped.has(dropColumnKey(name));
+ for (const tab of dataGridDropTargetTabs(queryStore.tabs, target)) {
+ const meta = tab.tableMeta!;
+ // Other tabs keep their query inputs in QueryTab. Clear references before
+ // refreshing them, otherwise refreshDataTab would execute SQL against the
+ // column that was just removed.
+ if (dataGridSqlTextReferencesAnyColumn(tab.whereInput, names, dropColumnCaseSensitive())) tab.whereInput = "";
+ if (dataGridSqlTextReferencesAnyColumn(tab.orderByInput, names, dropColumnCaseSensitive())) tab.orderByInput = undefined;
+ if (dataGridSqlTextReferencesAnyColumn(tab.structuredOrderByInput, names, dropColumnCaseSensitive())) tab.structuredOrderByInput = undefined;
+ const cached = await removeDataGridStructuredFilterColumnsForTab(
+ tab.id,
+ meta.columns.map((column) => column.name),
+ names,
+ dropColumnCaseSensitive(),
+ buildStructuredWhereFromRules,
+ );
+ if (cached) tab.whereInput = combineWhereInputs(cached.manualWhereInput, cached.appliedWhereInput) ?? "";
+ if (tab.result?.local_column_filters) {
+ // The stored result still has its old columns. Keep indexes paired with
+ // that snapshot; the result lifecycle resets local filters on schema change.
+ const columns = tab.result.columns;
+ queryStore.updateDataGridLocalColumnFilters(tab.id, Object.fromEntries(Object.entries(tab.result.local_column_filters).filter(([index]) => keep(columns[Number(index)] ?? ""))));
+ }
+ queryStore.setTableMeta(tab.id, {
+ ...meta,
+ columns: meta.columns.filter((column) => keep(column.name)),
+ primaryKeys: meta.primaryKeys.filter(keep),
+ ...(meta.virtualPrimaryKeys ? { virtualPrimaryKeys: meta.virtualPrimaryKeys.filter(keep) } : {}),
+ });
+ // Pending state appearing since the confirm would be lost on refresh; leave that page for the user to reload.
+ if (tab.id !== props.cacheKey && tab.id !== queryStore.activeTabId && !dataGridDropTabsHavePending([tab])) void queryStore.refreshDataTab(tab.id);
+ }
+}
+
+/**
+ * Refreshes caches, tabs, sidebar and the grid after a drop attempt, trusting the
+ * server's column list over the attempt: `executeBatch` runs one ALTER per column, so a
+ * failure part-way leaves some columns dropped. `fallback` is used when the list can't be read.
+ */
+async function publishColumnDrop(target: DropColumnTarget, attempted: string[], fallback: string[]): Promise<{ dropped: string[]; cleared: boolean }> {
+ const { connectionId, database, tableName } = target;
+ const schema = target.schema || undefined;
+ const catalog = target.catalog || undefined;
+ invalidateTableMetadataCache({ connectionId, database, tableName });
+ const metadataMatch = { connectionId, database, schema, tableName, catalog };
+ void invalidateObjectMetadataCache(metadataMatch).catch((error: unknown) => {
+ console.warn("[DBX][drop-column:metadata]", error);
+ });
+ connectionStore.invalidateCompletionTableCache(connectionId, database, tableName, schema, catalog);
+ queryStore.invalidateTableStructure(connectionId, database, schema, tableName);
+ let dropped = fallback;
+ try {
+ const remaining = (await api.getColumns(connectionId, database, target.columnsSchema, tableName, catalog)).map((column) => column.name);
+ dropped = dataGridDroppedColumnNames(attempted, remaining, dropColumnCaseSensitive());
+ } catch (error: unknown) {
+ console.warn("[DBX][drop-column:verify]", error);
+ }
+ const stillCurrent = sameDropColumnTarget(target, currentDropColumnTarget());
+ const cleared = stillCurrent && dropped.length > 0 ? await forgetDroppedColumnQueryState(dropped) : false;
+ await patchOpenDataTabsAfterColumnDrop(target, dropped);
+ const groups: typeof connectionStore.treeNodes = [];
+ const visit = (nodes: typeof connectionStore.treeNodes | undefined) => {
+ if (!nodes) return;
+ for (const node of nodes) {
+ if (node.type === "group-columns" && node.connectionId === connectionId && node.tableName === tableName && (node.database || "") === database && sameOptionalDropScope(node.schema, target.schema) && sameOptionalDropScope(node.catalog, target.catalog)) {
+ groups.push(node);
+ }
+ visit(node.children);
+ visit(node.hiddenChildren);
+ }
+ };
+ visit(connectionStore.treeNodes);
+ for (const group of groups) {
+ try {
+ await connectionStore.refreshTreeNode(group);
+ } catch (error: unknown) {
+ console.warn("[DBX][drop-column:sidebar-refresh]", error);
+ }
+ }
+ if (stillCurrent) await reloadTableData("refresh");
+ return { dropped, cleared };
+}
+
+function toastColumnsDropped(names: string[]) {
+ if (names.length === 0) return;
+ toast(names.length > 1 ? t("grid.deleteColumnsSuccess", { count: names.length }) : t("grid.deleteColumnSuccess", { column: names[0] ?? "" }), 4000);
+}
+
+async function confirmDropColumns() {
+ if (dropColumnLoading.value) return;
+ const target = pendingDropColumnTarget.value;
+ const names = pendingDropColumnNames.value.slice();
+ const statements = pendingDropColumnStatements.value.slice();
+ if (!target || statements.length === 0) return;
+ if (!sameDropColumnTarget(target, currentDropColumnTarget())) {
+ showDropColumnConfirm.value = false;
+ return;
+ }
+ if (hasPendingChanges.value || dropColumnOpenTabsPending()) {
+ showDropColumnConfirm.value = false;
+ toast(t("grid.deleteColumnPendingChanges"), 5000);
+ return;
+ }
+ dropColumnLoading.value = true;
+ const sql = statements.join("\n");
+ let started = false;
+ try {
+ const connection = connectionStore.getConfig(target.connectionId);
+ const result = await executeWithProductionSqlGuard({
+ connection,
+ database: target.database,
+ sql,
+ source: t("production.sourceDataGrid"),
+ execute: () => {
+ started = true;
+ return api.executeBatch(target.connectionId, target.database, statements, target.schema || undefined, queryTimeoutSecsForConnection(connection, settingsStore.editorSettings.globalQueryTimeoutSecs), false);
+ },
+ });
+ if (!started || result === undefined) return;
+ showDropColumnConfirm.value = false;
+ const { dropped, cleared } = await publishColumnDrop(target, names, names);
+ toastColumnsDropped(dropped);
+ if (cleared) toast(t("grid.deleteColumnFilterCleared"), 4000);
+ } catch (error: unknown) {
+ const message = error instanceof Error ? error.message : String(error);
+ toast(t("grid.deleteColumnFailed", { message }), 5000);
+ if (started) {
+ showDropColumnConfirm.value = false;
+ // Earlier columns may already be gone; if the list can't be read, assume none.
+ const { dropped } = await publishColumnDrop(target, names, []);
+ toastColumnsDropped(dropped);
+ }
+ } finally {
+ dropColumnLoading.value = false;
+ }
+}
const previewToolbarCapability = computed<DataGridToolbarActionCapability>(() => ({
label: t(previewLabelKey.value),
visible: saveToolbarState.value.showActions && pendingChangeCount.value > 0,
@@ -6161,6 +6517,25 @@ const {
isRowSelected,
} = selection;
+dropColumnCandidatesNow = () => {
+ const selected = hasColumnSelection.value ? [...selectedColumnIndexes.value].filter((index) => index >= 0 && index < visibleColumnIndexes.value.length) : [];
+ const seen = new Set<string>();
+ const targets: DataGridDropColumnCandidate[] = [];
+ // A row selection is about rows. Don't treat its leftover cell focus as a column to drop.
+ const focusVisibleIndex = hasColumnSelection.value || hasRowSelection.value ? undefined : selectionFocus.value?.colIndex;
+ for (const visibleIndex of dataGridDropColumnVisibleIndexes(selected, focusVisibleIndex)) {
+ const column = tableColumnForGridColumn(actualColumnIndex(visibleIndex));
+ if (!column?.name || seen.has(column.name)) continue;
+ seen.add(column.name);
+ targets.push({
+ name: column.name,
+ primaryKey: column.is_primary_key,
+ protectedColumn: isProtectedManticoreIdColumn(resolvedDatabaseType.value, column.name),
+ });
+ }
+ return targets;
+};
+
// 行列十字高亮目标:以 selectionFocus(原始坐标系)为中心解析,整行/整列选中时从
// lastClickedRowIndex / selectedRowIds / selectedColumnIndexes 派生。开关关闭时恒为 null。
const crosshairTarget = computed<CrosshairTarget | null>(() => {
@@ -14947,6 +15322,7 @@ useUpdateBlocker(() => (hasPendingChanges.value || hasPendingDataEditorDraft.val
:auto-refresh="autoRefreshToolbarCapability"
:add-row="addRowToolbarCapability"
:delete-row="deleteRowToolbarCapability"
+ :delete-column="deleteColumnToolbarCapability"
:layer-preview="layerPreviewToolbarCapability"
:preview="previewToolbarCapability"
:save="saveToolbarCapability"
@@ -17205,6 +17581,17 @@ useUpdateBlocker(() => (hasPendingChanges.value || hasPendingDataEditorDraft.val
<div v-if="isConditionalUpdateActive" class="absolute inset-0 z-50 flex items-center justify-center bg-background/75 backdrop-blur-[1px]">
<QueryLoadingState class="p-6" :show-cancel="true" :cancelling="conditionalUpdateExecution?.cancelling" @cancel="cancelRunningConditionalBulkEdit" />
</div>
+ <DangerConfirmDialog
+ v-model:open="showDropColumnConfirm"
+ :title="pendingDropColumnNames.length > 1 ? t('grid.deleteColumns', { count: pendingDropColumnNames.length }) : t('grid.deleteColumn')"
+ :message="dropColumnConfirmMessage"
+ :sql="dropColumnPreviewSql"
+ :confirm-label="pendingDropColumnNames.length > 1 ? t('grid.deleteColumns', { count: pendingDropColumnNames.length }) : t('grid.deleteColumn')"
+ :confirm-disabled="pendingDropColumnStatements.length === 0"
+ :loading="dropColumnLoading"
+ :close-on-confirm="false"
+ @confirm="confirmDropColumns"
+ />
<DangerConfirmDialog
v-model:open="showDeleteRowConfirm"
:message="
diff --git a/apps/desktop/src/components/grid/DataGridToolbar.vue b/apps/desktop/src/components/grid/DataGridToolbar.vue
index ab952736bd..135f8747a5 100644
--- a/apps/desktop/src/components/grid/DataGridToolbar.vue
+++ b/apps/desktop/src/components/grid/DataGridToolbar.vue
@@ -34,6 +34,7 @@ const props = defineProps<{
autoRefresh?: DataGridToolbarAutoRefreshCapability;
addRow?: DataGridToolbarAddRowCapability;
deleteRow?: DataGridToolbarActionCapability;
+ deleteColumn?: DataGridToolbarActionCapability;
copyData?: DataGridToolbarCopyCapability;
exportData?: DataGridToolbarExportCapability;
transpose?: DataGridToolbarActionCapability;
@@ -64,6 +65,7 @@ const visibleActionOrder = computed<DataGridToolbarActionKey[]>(() => {
copyData: isDataGridToolbarCapabilityVisible(props.copyData),
addRow: isDataGridToolbarCapabilityVisible(props.addRow),
deleteRow: isDataGridToolbarCapabilityVisible(props.deleteRow),
+ deleteColumn: isDataGridToolbarCapabilityVisible(props.deleteColumn),
exportData: isDataGridToolbarCapabilityVisible(props.exportData),
transpose: isDataGridToolbarCapabilityVisible(props.transpose),
tableInfo: isDataGridToolbarCapabilityVisible(props.tableInfo),
@@ -205,6 +207,23 @@ function actionLabelClass(action: DataGridToolbarActionKey) {
<TooltipContent side="bottom">{{ deleteRow?.tooltip ?? deleteRow?.label }}</TooltipContent>
</Tooltip>
+ <Tooltip v-if="isDataGridToolbarCapabilityVisible(deleteColumn)">
+ <TooltipTrigger as-child>
+ <Button
+ data-toolbar-action="deleteColumn"
+ variant="ghost"
+ size="sm"
+ :class="[...actionButtonClass('deleteColumn'), 'text-destructive hover:bg-destructive/10 hover:text-destructive']"
+ :disabled="isDataGridToolbarCapabilityDisabled(deleteColumn)"
+ @click="void triggerDataGridToolbarAction(deleteColumn)"
+ >
+ <Trash2 class="data-grid-topbar-action-icon h-3 w-3" />
+ <span class="data-grid-topbar-action-label" :class="actionLabelClass('deleteColumn')">{{ deleteColumn?.label }}</span>
+ </Button>
+ </TooltipTrigger>
+ <TooltipContent side="bottom">{{ deleteColumn?.tooltip ?? deleteColumn?.label }}</TooltipContent>
+ </Tooltip>
+
<DropdownMenu v-if="isDataGridToolbarCapabilityVisible(exportData)">
<Tooltip>
<TooltipTrigger as-child>
diff --git a/apps/desktop/src/components/grid/__tests__/DataGridDropColumn.spec.ts b/apps/desktop/src/components/grid/__tests__/DataGridDropColumn.spec.ts
new file mode 100644
index 0000000000..c588520655
--- /dev/null
+++ b/apps/desktop/src/components/grid/__tests__/DataGridDropColumn.spec.ts
@@ -0,0 +1,168 @@
+// @vitest-environment happy-dom
+import { createApp, defineComponent, h, ref, nextTick, type App } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import i18n from "@/i18n";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { clearDataGridStructuredFilterStates, saveDataGridStructuredFilterState, loadDataGridStructuredFilterState } from "@/lib/dataGrid/dataGridFilterBuilderPersistence";
+const mocks = vi.hoisted(() => ({
+ executeBatch: vi.fn(async () => []),
+ getColumns: vi.fn(),
+ buildDropTableChildObjectSql: vi.fn(async () => "ALTER TABLE users DROP COLUMN status"),
+ buildDataGridContextFilterCondition: vi.fn(async ({ columnName, value }: { columnName: string; value: unknown }) => `${columnName} = ${value}`),
+ loadEditorSettings: vi.fn(async () => ({})),
+ saveEditorSettings: vi.fn(async () => undefined),
+ saveOpenTabsState: vi.fn(async () => undefined),
+ loadOpenTabsState: vi.fn(async () => null),
+ closeClientConnectionSession: vi.fn(async () => undefined),
+ closeQuerySession: vi.fn(async () => undefined),
+}));
+vi.mock("@/lib/backend/api", async (importOriginal) => ({ ...(await importOriginal<typeof import("@/lib/backend/api")>()), ...mocks }));
+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 { useQueryStore } from "@/stores/queryStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+const mounted: Array<{ app: App; host: HTMLElement }> = [];
+const col = (name: string) => ({ name, data_type: "int", is_nullable: false, is_primary_key: name === "id", extra: null, column_default: null });
+const scope = (columns: string[]) => ["mysql-1", "app", "", "table-data", "", "users", columns.join("\0")].join("\u0001");
+async function settle() {
+ for (let i = 0; i < 8; i++) {
+ await nextTick();
+ await Promise.resolve();
+ }
+}
+afterEach(() => {
+ for (const { app, host } of mounted.splice(0)) {
+ app.unmount();
+ host.remove();
+ }
+ clearDataGridStructuredFilterStates();
+ vi.restoreAllMocks();
+ vi.clearAllMocks();
+});
+describe("DataGrid drop column cross-tab refresh", () => {
+ it.each([false, true])("cleans another tab before refresh and reopening (mounted sibling: %s)", async (mountedSibling) => {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ useSettingsStore().updateEditorSettings({ dataGridRenderMode: "canvas" });
+ const query = useQueryStore();
+ vi.spyOn(useConnectionStore(), "getConfig").mockReturnValue({ id: "mysql-1", name: "mysql", database: "app", db_type: "mysql" } as never);
+ const firstId = query.createTab("mysql-1", "app", "users", "data");
+ // createTab deduplicates identical titles; both tabs have the same tableMeta.
+ const otherId = query.createTab("mysql-1", "app", "users copy", "data");
+ expect(otherId).not.toBe(firstId);
+ for (const id of [firstId, otherId]) {
+ query.setTableMeta(id, { tableName: "users", database: "app", columns: [col("id"), col("status"), col("score")], primaryKeys: ["id"] });
+ query.tabs.find((tab) => tab.id === id)!.result = { columns: ["id", "status", "score"], rows: [[1, 2, 3]], affected_rows: 0, execution_time_ms: 0 };
+ }
+ query.activateTab(firstId);
+ const first = query.tabs.find((tab) => tab.id === firstId)!;
+ const other = query.tabs.find((tab) => tab.id === otherId)!;
+ other.whereInput = "status = 2 AND score = 3";
+ other.orderByInput = "status DESC";
+ other.result!.local_column_filters = { "1": ["2"], "2": ["3"] };
+ saveDataGridStructuredFilterState(otherId, {
+ scopeKey: scope(["id", "status", "score"]),
+ manualWhereInput: "status = 2",
+ appliedWhereInput: "score = 3",
+ rules: [{ id: "score-rule", columnName: "score", mode: "equals", rawValue: "3", rawEndValue: "", conjunction: "AND" }],
+ serverColumnFilters: {},
+ });
+ mocks.getColumns.mockResolvedValue([col("id"), col("score")]);
+ const refresh = vi.spyOn(query, "refreshDataTab").mockImplementation(async (id) => {
+ const tab = query.tabs.find((tab) => tab.id === id)!;
+ expect(tab.whereInput).not.toContain("status");
+ expect(tab.whereInput).toContain("score");
+ expect(tab.orderByInput).toBeUndefined();
+ expect(tab.result!.local_column_filters).toEqual({ "2": ["3"] });
+ return true;
+ });
+ const grid = ref<{ selectSingleCell(row: number, column: number): void; onToolbarRefresh(): Promise<void> }>();
+ const secondGrid = ref<{ onToolbarRefresh(): Promise<void> }>();
+ const shownTab = ref(firstId);
+ const onReload = vi.fn();
+ const Root = defineComponent({
+ setup: () => () => {
+ const tabs = shownTab.value === firstId ? [first, ...(mountedSibling ? [other] : [])] : [other];
+ return h(
+ TooltipProvider,
+ { delayDuration: 0 },
+ {
+ default: () =>
+ tabs.map((tab, index) =>
+ h(DataGrid, {
+ key: tab.id,
+ ref: index === 0 ? grid : secondGrid,
+ cacheKey: tab.id,
+ result: tab.result!,
+ databaseType: "mysql",
+ context: "table-data",
+ connectionId: tab.connectionId,
+ database: tab.database,
+ tableMeta: tab.tableMeta,
+ initialWhereInput: tab.whereInput,
+ initialOrderByInput: tab.orderByInput,
+ "onUpdate:whereInput": (value: string) => {
+ tab.whereInput = value;
+ },
+ "onUpdate:orderByInput": (value: string) => {
+ tab.orderByInput = value;
+ },
+ onReload,
+ }),
+ ),
+ },
+ );
+ },
+ });
+ const host = document.createElement("div");
+ document.body.append(host);
+ const app = createApp(Root);
+ app.use(pinia);
+ app.use(i18n);
+ app.mount(host);
+ mounted.push({ app, host });
+ await settle();
+ grid.value!.selectSingleCell(0, 1);
+ await settle();
+ const drop = host.querySelector<HTMLButtonElement>('[data-toolbar-action="deleteColumn"]')!;
+ expect(drop.disabled).toBe(false);
+ drop.click();
+ await settle();
+ const confirm = [...document.querySelectorAll<HTMLButtonElement>('[role="dialog"] button')].find((button) => button.textContent?.trim() === i18n.global.t("grid.deleteColumn"))!;
+ expect(confirm).toBeDefined();
+ expect(confirm.disabled).toBe(false);
+ confirm.click();
+ await vi.waitFor(() => expect(mocks.executeBatch).toHaveBeenCalledOnce());
+ await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce());
+ await settle();
+ expect(loadDataGridStructuredFilterState(otherId, scope(["id", "score"]))?.rules.map((rule) => rule.columnName)).toEqual(["score"]);
+ if (mountedSibling) {
+ await secondGrid.value!.onToolbarRefresh();
+ expect(onReload.mock.lastCall?.[2]).toContain("score");
+ expect(onReload.mock.lastCall?.[2]).not.toContain("status");
+ }
+ shownTab.value = otherId;
+ await settle();
+ await grid.value!.onToolbarRefresh();
+ expect(onReload.mock.lastCall?.[2]).toContain("score");
+ expect(onReload.mock.lastCall?.[2]).not.toContain("status");
+ });
+});
diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.ts
index d1d83eee1a..2b46b4ca7c 100644
--- a/apps/desktop/src/i18n/locales/az.ts
+++ b/apps/desktop/src/i18n/locales/az.ts
@@ -2401,6 +2401,20 @@ export default withEnglishFallback({
cloneRow: "Yeni sətir kimi klonla",
deleteRow: "Sətri sil",
deleteRows: "{count} sətri sil",
+ deleteColumn: "Sütunu sil",
+ deleteColumns: "{count} sütunu sil",
+ deleteColumnTooltip: "Cari sütunu və onda saxlanan dəyərləri sil",
+ deleteColumnSelectColumn: "Silinəcək sütunu seçin",
+ deleteColumnPrimaryKey: "Əsas açar sütununu burada silmək olmaz",
+ deleteColumnProtected: "Bu sütun qorunur və silinə bilməz",
+ deleteColumnLastColumn: "Cədvəldə ən azı bir sütun qalmalıdır",
+ deleteColumnPendingChanges: "Sütunu silməzdən əvvəl gözləyən dəyişiklikləri saxlayın və ya ləğv edin",
+ deleteColumnMessage: "«{table}» cədvəlindən «{column}» sütunu dərhal silinəcək. Bu sütunda saxlanan bütün dəyərlər onunla birlikdə silinir. Digər sütunlardakı dəyərlər qalır. Cədvəl geri qaytarması bunu geri ala bilməz.",
+ deleteColumnsMessage: "«{table}» cədvəlindən {count} sütun ({columns}) dərhal silinəcək. Bu sütunlarda saxlanan bütün dəyərlər onlarla birlikdə silinir. Digər sütunlardakı dəyərlər qalır. Cədvəl geri qaytarması bunu geri ala bilməz.",
+ deleteColumnSuccess: "«{column}» sütunu silindi. Dəyərləri də onunla birlikdə silindi.",
+ deleteColumnsSuccess: "{count} sütun silindi. Dəyərləri də onlarla birlikdə silindi.",
+ deleteColumnFailed: "Sütunu silmək alınmadı: {message}",
+ deleteColumnFilterCleared: "Silinən sütundan istifadə edən filtr və ya çeşidləmə götürüldü",
cloneRows: "{count} sətri yeni sətirlər kimi klonla",
restoreRows: "{count} sətri bərpa et",
copyRows: "{count} sətri kopyala (JSON massivi)",
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index a0992eb0ca..0e8be22807 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -3553,6 +3553,20 @@ export default {
cloneRow: "Clone as New Row",
deleteRow: "Delete Row",
deleteRows: "Delete {count} Rows",
+ deleteColumn: "Delete Column",
+ deleteColumns: "Delete {count} Columns",
+ deleteColumnTooltip: "Drop the current column and the values stored in it",
+ deleteColumnSelectColumn: "Select the column to drop",
+ deleteColumnPrimaryKey: "A primary key column cannot be dropped here",
+ deleteColumnProtected: "This column is protected and cannot be dropped",
+ deleteColumnLastColumn: "A table must keep at least one column",
+ deleteColumnPendingChanges: "Save or discard pending changes before dropping a column",
+ deleteColumnMessage: 'This immediately drops column "{column}" from "{table}". Every value stored in that column is deleted with it. Values in the other columns stay. Grid rollback cannot undo this.',
+ deleteColumnsMessage: 'This immediately drops {count} columns from "{table}" ({columns}). Every value stored in those columns is deleted with them. Values in the other columns stay. Grid rollback cannot undo this.',
+ deleteColumnSuccess: 'Dropped column "{column}". Its values were deleted with it.',
+ deleteColumnsSuccess: "Dropped {count} columns. Their values were deleted with them.",
+ deleteColumnFailed: "Failed to drop the column: {message}",
+ deleteColumnFilterCleared: "Removed filters or sorting that used the dropped column",
cloneRows: "Clone {count} as New Rows",
restoreRows: "Restore {count} Rows",
copyRows: "Copy {count} Rows (JSON Array)",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index d5bf69a3c0..e3a2ab12e1 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -3110,6 +3110,20 @@ export default withEnglishFallback({
cloneRow: "Clonar como fila nueva",
deleteRow: "Eliminar fila",
deleteRows: "Eliminar {count} filas",
+ deleteColumn: "Eliminar columna",
+ deleteColumns: "Eliminar {count} columnas",
+ deleteColumnTooltip: "Elimina la columna actual y los valores almacenados en ella",
+ deleteColumnSelectColumn: "Selecciona la columna que quieres eliminar",
+ deleteColumnPrimaryKey: "Una columna de clave primaria no se puede eliminar aquí",
+ deleteColumnProtected: "Esta columna está protegida y no se puede eliminar",
+ deleteColumnLastColumn: "La tabla debe conservar al menos una columna",
+ deleteColumnPendingChanges: "Guarda o descarta los cambios pendientes antes de eliminar una columna",
+ deleteColumnMessage: 'Se eliminará de inmediato la columna "{column}" de "{table}". Todos los valores almacenados en ella se eliminan junto con la columna. Los valores de las demás columnas se conservan. La reversión de la cuadrícula no puede deshacer esto.',
+ deleteColumnsMessage: 'Se eliminarán de inmediato {count} columnas de "{table}" ({columns}). Todos los valores almacenados en ellas se eliminan junto con las columnas. Los valores de las demás columnas se conservan. La reversión de la cuadrícula no puede deshacer esto.',
+ deleteColumnSuccess: 'Se eliminó la columna "{column}". Sus valores también se eliminaron.',
+ deleteColumnsSuccess: "Se eliminaron {count} columnas. Sus valores también se eliminaron.",
+ deleteColumnFailed: "No se pudo eliminar la columna: {message}",
+ deleteColumnFilterCleared: "Se quitaron los filtros o el orden que usaban la columna eliminada",
cloneRows: "Clonar {count} como filas nuevas",
restoreRows: "Restaurar {count} filas",
copyRows: "Copiar {count} filas (array JSON)",
diff --git a/apps/desktop/src/i18n/locales/id.ts b/apps/desktop/src/i18n/locales/id.ts
index b1ff426bcd..8e4d8b3aaf 100644
--- a/apps/desktop/src/i18n/locales/id.ts
+++ b/apps/desktop/src/i18n/locales/id.ts
@@ -2710,6 +2710,20 @@ export default withEnglishFallback({
cloneRow: "Klon sebagai Baris Baru",
deleteRow: "Hapus Baris",
deleteRows: "Hapus {count} Baris",
+ deleteColumn: "Hapus Kolom",
+ deleteColumns: "Hapus {count} Kolom",
+ deleteColumnTooltip: "Hapus kolom saat ini beserta nilai yang tersimpan di dalamnya",
+ deleteColumnSelectColumn: "Pilih kolom yang akan dihapus",
+ deleteColumnPrimaryKey: "Kolom kunci utama tidak dapat dihapus di sini",
+ deleteColumnProtected: "Kolom ini dilindungi dan tidak dapat dihapus",
+ deleteColumnLastColumn: "Tabel harus menyisakan sedikitnya satu kolom",
+ deleteColumnPendingChanges: "Simpan atau buang perubahan yang tertunda sebelum menghapus kolom",
+ deleteColumnMessage: 'Kolom "{column}" akan segera dihapus dari "{table}". Semua nilai di kolom itu ikut terhapus. Nilai di kolom lain tetap ada. Rollback kisi tidak dapat membatalkan ini.',
+ deleteColumnsMessage: '{count} kolom akan segera dihapus dari "{table}" ({columns}). Semua nilai di kolom itu ikut terhapus. Nilai di kolom lain tetap ada. Rollback kisi tidak dapat membatalkan ini.',
+ deleteColumnSuccess: 'Kolom "{column}" telah dihapus. Nilainya ikut terhapus.',
+ deleteColumnsSuccess: "{count} kolom telah dihapus. Nilainya ikut terhapus.",
+ deleteColumnFailed: "Gagal menghapus kolom: {message}",
+ deleteColumnFilterCleared: "Filter atau pengurutan yang memakai kolom yang dihapus telah dibuang",
cloneRows: "Klon {count} sebagai Baris Baru",
restoreRows: "Pulihkan {count} Baris",
copyRows: "Salin {count} Baris (Larik JSON)",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index b66c9ca09b..8f76aad22f 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -3003,6 +3003,20 @@ export default withEnglishFallback({
cloneRow: "Clona come Nuova Riga",
deleteRow: "Elimina Riga",
deleteRows: "Elimina {count} Righe",
+ deleteColumn: "Elimina Colonna",
+ deleteColumns: "Elimina {count} Colonne",
+ deleteColumnTooltip: "Elimina la colonna corrente e i valori in essa memorizzati",
+ deleteColumnSelectColumn: "Seleziona la colonna da eliminare",
+ deleteColumnPrimaryKey: "Una colonna chiave primaria non può essere eliminata qui",
+ deleteColumnProtected: "Questa colonna è protetta e non può essere eliminata",
+ deleteColumnLastColumn: "La tabella deve conservare almeno una colonna",
+ deleteColumnPendingChanges: "Salva o annulla le modifiche in sospeso prima di eliminare una colonna",
+ deleteColumnMessage: 'La colonna "{column}" viene eliminata subito da "{table}". Tutti i valori memorizzati in essa vengono eliminati insieme. I valori delle altre colonne restano. Il rollback della griglia non può annullare questa operazione.',
+ deleteColumnsMessage: '{count} colonne vengono eliminate subito da "{table}" ({columns}). Tutti i valori memorizzati in esse vengono eliminati insieme. I valori delle altre colonne restano. Il rollback della griglia non può annullare questa operazione.',
+ deleteColumnSuccess: 'Colonna "{column}" eliminata. Anche i suoi valori sono stati eliminati.',
+ deleteColumnsSuccess: "{count} colonne eliminate. Anche i loro valori sono stati eliminati.",
+ deleteColumnFailed: "Impossibile eliminare la colonna: {message}",
+ deleteColumnFilterCleared: "Rimossi filtri o ordinamento che usavano la colonna eliminata",
cloneRows: "Clona {count} come Nuove Righe",
restoreRows: "Ripristina {count} Righe",
copyRows: "Copia {count} righe (array JSON)",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index d5be2efe6c..f6cce68a65 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -3008,6 +3008,20 @@ export default withEnglishFallback({
cloneRow: "新しい行として複製",
deleteRow: "行を削除",
deleteRows: "{count}行を削除",
+ deleteColumn: "列を削除",
+ deleteColumns: "{count}列を削除",
+ deleteColumnTooltip: "現在の列と、その列に保存されている値を削除します",
+ deleteColumnSelectColumn: "削除する列を選択してください",
+ deleteColumnPrimaryKey: "主キー列はここでは削除できません",
+ deleteColumnProtected: "この列は保護されているため削除できません",
+ deleteColumnLastColumn: "テーブルには少なくとも1つの列が必要です",
+ deleteColumnPendingChanges: "列を削除する前に、未保存の変更を保存するか破棄してください",
+ deleteColumnMessage: "「{table}」から列「{column}」を直ちに削除します。その列に保存されている値も一緒に削除されます。他の列の値は残ります。グリッドのロールバックでは元に戻せません。",
+ deleteColumnsMessage: "「{table}」から{count}列({columns})を直ちに削除します。それらの列に保存されている値も一緒に削除されます。他の列の値は残ります。グリッドのロールバックでは元に戻せません。",
+ deleteColumnSuccess: "列「{column}」を削除しました。その値も一緒に削除されました。",
+ deleteColumnsSuccess: "{count}列を削除しました。その値も一緒に削除されました。",
+ deleteColumnFailed: "列の削除に失敗しました:{message}",
+ deleteColumnFilterCleared: "削除した列を使っていたフィルターまたは並べ替えを外しました",
cloneRows: "{count}行を新しい行として複製",
restoreRows: "{count}行を復元",
copyRows: "{count}行をコピー(JSON 配列)",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index fe8b89d5d9..50c0f4407c 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -3125,6 +3125,20 @@ export default withEnglishFallback({
cloneRow: "새 행으로 복제",
deleteRow: "행 삭제",
deleteRows: "{count}행 삭제",
+ deleteColumn: "열 삭제",
+ deleteColumns: "{count}열 삭제",
+ deleteColumnTooltip: "현재 열과 그 열에 저장된 값을 삭제합니다",
+ deleteColumnSelectColumn: "삭제할 열을 선택하세요",
+ deleteColumnPrimaryKey: "기본 키 열은 여기서 삭제할 수 없습니다",
+ deleteColumnProtected: "이 열은 보호되어 있어 삭제할 수 없습니다",
+ deleteColumnLastColumn: "테이블에는 열이 하나 이상 남아 있어야 합니다",
+ deleteColumnPendingChanges: "열을 삭제하기 전에 저장되지 않은 변경을 저장하거나 취소하세요",
+ deleteColumnMessage: '"{table}"에서 열 "{column}"을 즉시 삭제합니다. 그 열에 저장된 값은 함께 삭제됩니다. 다른 열의 값은 유지됩니다. 그리드 롤백으로는 되돌릴 수 없습니다.',
+ deleteColumnsMessage: '"{table}"에서 {count}개 열({columns})을 즉시 삭제합니다. 그 열에 저장된 값은 함께 삭제됩니다. 다른 열의 값은 유지됩니다. 그리드 롤백으로는 되돌릴 수 없습니다.',
+ deleteColumnSuccess: '열 "{column}"을 삭제했습니다. 값도 함께 삭제되었습니다.',
+ deleteColumnsSuccess: "{count}개 열을 삭제했습니다. 값도 함께 삭제되었습니다.",
+ deleteColumnFailed: "열을 삭제하지 못했습니다: {message}",
+ deleteColumnFilterCleared: "삭제된 열을 쓰던 필터 또는 정렬을 제거했습니다",
cloneRows: "{count}개를 새 행으로 복제",
restoreRows: "{count}행 복원",
copyRows: "{count}행 복사(JSON 배열)",
diff --git a/apps/desktop/src/i18n/locales/pl.ts b/apps/desktop/src/i18n/locales/pl.ts
index 0501d71545..7ab1f6028e 100644
--- a/apps/desktop/src/i18n/locales/pl.ts
+++ b/apps/desktop/src/i18n/locales/pl.ts
@@ -2776,6 +2776,20 @@ export default withEnglishFallback({
cloneRow: "Duplikuj jako nowy wiersz",
deleteRow: "Usuń wiersz",
deleteRows: "Usuń {count} wierszy",
+ deleteColumn: "Usuń kolumnę",
+ deleteColumns: "Usuń {count} kolumn",
+ deleteColumnTooltip: "Usuwa bieżącą kolumnę i zapisane w niej wartości",
+ deleteColumnSelectColumn: "Wybierz kolumnę do usunięcia",
+ deleteColumnPrimaryKey: "Kolumny klucza głównego nie można tu usunąć",
+ deleteColumnProtected: "Ta kolumna jest chroniona i nie można jej usunąć",
+ deleteColumnLastColumn: "Tabela musi zachować co najmniej jedną kolumnę",
+ deleteColumnPendingChanges: "Zapisz lub odrzuć oczekujące zmiany przed usunięciem kolumny",
+ deleteColumnMessage: "Kolumna „{column}” zostanie natychmiast usunięta z „{table}”. Wszystkie zapisane w niej wartości zostaną usunięte razem z nią. Wartości w pozostałych kolumnach zostaną. Cofnięcie w siatce nie cofnie tej operacji.",
+ deleteColumnsMessage: "{count} kolumn zostanie natychmiast usuniętych z „{table}” ({columns}). Wszystkie zapisane w nich wartości zostaną usunięte razem z nimi. Wartości w pozostałych kolumnach zostaną. Cofnięcie w siatce nie cofnie tej operacji.",
+ deleteColumnSuccess: "Usunięto kolumnę „{column}”. Jej wartości też zostały usunięte.",
+ deleteColumnsSuccess: "Usunięto {count} kolumn. Ich wartości też zostały usunięte.",
+ deleteColumnFailed: "Nie udało się usunąć kolumny: {message}",
+ deleteColumnFilterCleared: "Usunięto filtry lub sortowanie używające usuniętej kolumny",
cloneRows: "Duplikuj {count} wierszy jako nowe",
restoreRows: "Przywróć {count} wierszy",
copyRows: "Kopiuj {count} wierszy (tablica JSON)",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 6c01d51db7..d7e1f9f65e 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -3004,6 +3004,20 @@ export default withEnglishFallback({
cloneRow: "Clonar como Nova Linha",
deleteRow: "Excluir Linha",
deleteRows: "Excluir {count} Linhas",
+ deleteColumn: "Excluir Coluna",
+ deleteColumns: "Excluir {count} Colunas",
+ deleteColumnTooltip: "Exclui a coluna atual e os valores armazenados nela",
+ deleteColumnSelectColumn: "Selecione a coluna a excluir",
+ deleteColumnPrimaryKey: "Uma coluna de chave primária não pode ser excluída aqui",
+ deleteColumnProtected: "Esta coluna está protegida e não pode ser excluída",
+ deleteColumnLastColumn: "A tabela precisa manter pelo menos uma coluna",
+ deleteColumnPendingChanges: "Salve ou descarte as alterações pendentes antes de excluir uma coluna",
+ deleteColumnMessage: 'A coluna "{column}" será excluída imediatamente de "{table}". Todos os valores armazenados nela são excluídos junto. Os valores das outras colunas permanecem. A reversão da grade não pode desfazer isso.',
+ deleteColumnsMessage: '{count} colunas serão excluídas imediatamente de "{table}" ({columns}). Todos os valores armazenados nelas são excluídos junto. Os valores das outras colunas permanecem. A reversão da grade não pode desfazer isso.',
+ deleteColumnSuccess: 'Coluna "{column}" excluída. Os valores dela também foram excluídos.',
+ deleteColumnsSuccess: "{count} colunas excluídas. Os valores delas também foram excluídos.",
+ deleteColumnFailed: "Falha ao excluir a coluna: {message}",
+ deleteColumnFilterCleared: "Filtros ou ordenação que usavam a coluna excluída foram removidos",
cloneRows: "Clonar {count} como Novas Linhas",
restoreRows: "Restaurar {count} Linhas",
copyRows: "Copiar {count} linhas (array JSON)",
diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts
index db9afcb206..469a2e26ea 100644
--- a/apps/desktop/src/i18n/locales/ru.ts
+++ b/apps/desktop/src/i18n/locales/ru.ts
@@ -3245,6 +3245,20 @@ export default withEnglishFallback({
cloneRow: "Клонировать как новую строку",
deleteRow: "Удалить строку",
deleteRows: "Удалить {count} строк",
+ deleteColumn: "Удалить столбец",
+ deleteColumns: "Удалить {count} столбцов",
+ deleteColumnTooltip: "Удалить текущий столбец и хранящиеся в нём значения",
+ deleteColumnSelectColumn: "Выберите столбец для удаления",
+ deleteColumnPrimaryKey: "Столбец первичного ключа нельзя удалить здесь",
+ deleteColumnProtected: "Этот столбец защищён и не может быть удалён",
+ deleteColumnLastColumn: "В таблице должен остаться хотя бы один столбец",
+ deleteColumnPendingChanges: "Сохраните или отмените несохранённые изменения перед удалением столбца",
+ deleteColumnMessage: "Столбец «{column}» будет немедленно удалён из «{table}». Все значения в этом столбце удаляются вместе с ним. Значения в остальных столбцах сохраняются. Откат сетки не может отменить это действие.",
+ deleteColumnsMessage: "{count} столбцов будут немедленно удалены из «{table}» ({columns}). Все значения в этих столбцах удаляются вместе с ними. Значения в остальных столбцах сохраняются. Откат сетки не может отменить это действие.",
+ deleteColumnSuccess: "Столбец «{column}» удалён. Его значения тоже удалены.",
+ deleteColumnsSuccess: "Удалено столбцов: {count}. Их значения тоже удалены.",
+ deleteColumnFailed: "Не удалось удалить столбец: {message}",
+ deleteColumnFilterCleared: "Удалены фильтры или сортировка, использовавшие удалённый столбец",
cloneRows: "Клонировать {count} как новые строки",
restoreRows: "Восстановить {count} строк",
copyRows: "Копировать {count} строк (массив JSON)",
diff --git a/apps/desktop/src/i18n/locales/th.ts b/apps/desktop/src/i18n/locales/th.ts
index 7395ed8420..4506ad517c 100644
--- a/apps/desktop/src/i18n/locales/th.ts
+++ b/apps/desktop/src/i18n/locales/th.ts
@@ -3395,6 +3395,20 @@ export default withEnglishFallback({
cloneRow: "โคลนเป็นแถวใหม่",
deleteRow: "ลบแถว",
deleteRows: "ลบ {count} แถว",
+ deleteColumn: "ลบคอลัมน์",
+ deleteColumns: "ลบ {count} คอลัมน์",
+ deleteColumnTooltip: "ลบคอลัมน์ปัจจุบันและค่าที่เก็บอยู่ในคอลัมน์นั้น",
+ deleteColumnSelectColumn: "เลือกคอลัมน์ที่จะลบ",
+ deleteColumnPrimaryKey: "ลบคอลัมน์คีย์หลักที่นี่ไม่ได้",
+ deleteColumnProtected: "คอลัมน์นี้ถูกป้องกันไว้ ลบไม่ได้",
+ deleteColumnLastColumn: "ตารางต้องเหลืออย่างน้อยหนึ่งคอลัมน์",
+ deleteColumnPendingChanges: "บันทึกหรือยกเลิกการเปลี่ยนแปลงที่ค้างอยู่ก่อนลบคอลัมน์",
+ deleteColumnMessage: 'จะลบคอลัมน์ "{column}" ออกจาก "{table}" ทันที ค่าทั้งหมดในคอลัมน์นี้จะถูกลบไปด้วย ค่าในคอลัมน์อื่นยังอยู่ การย้อนกลับของตารางไม่สามารถเลิกทำรายการนี้ได้',
+ deleteColumnsMessage: 'จะลบ {count} คอลัมน์ออกจาก "{table}" ({columns}) ทันที ค่าทั้งหมดในคอลัมน์เหล่านี้จะถูกลบไปด้วย ค่าในคอลัมน์อื่นยังอยู่ การย้อนกลับของตารางไม่สามารถเลิกทำรายการนี้ได้',
+ deleteColumnSuccess: 'ลบคอลัมน์ "{column}" แล้ว ค่าในคอลัมน์ก็ถูกลบไปด้วย',
+ deleteColumnsSuccess: "ลบ {count} คอลัมน์แล้ว ค่าในคอลัมน์ก็ถูกลบไปด้วย",
+ deleteColumnFailed: "ลบคอลัมน์ไม่สำเร็จ: {message}",
+ deleteColumnFilterCleared: "นำตัวกรองหรือการจัดเรียงที่ใช้คอลัมน์ที่ถูกลบออกแล้ว",
cloneRows: "โคลน {count} เป็นแถวใหม่",
restoreRows: "คืนค่า {count} แถว",
copyRows: "คัดลอก {count} แถว (Array JSON)",
diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.ts
index 26ad4a4a1b..0d241b2585 100644
--- a/apps/desktop/src/i18n/locales/tr.ts
+++ b/apps/desktop/src/i18n/locales/tr.ts
@@ -2393,6 +2393,20 @@ export default withEnglishFallback({
cloneRow: "Yeni Satır Olarak Çoğalt",
deleteRow: "Satırı Sil",
deleteRows: "{count} Satırı Sil",
+ deleteColumn: "Sütunu Sil",
+ deleteColumns: "{count} Sütunu Sil",
+ deleteColumnTooltip: "Geçerli sütunu ve içinde kayıtlı değerleri sil",
+ deleteColumnSelectColumn: "Silinecek sütunu seçin",
+ deleteColumnPrimaryKey: "Birincil anahtar sütunu burada silinemez",
+ deleteColumnProtected: "Bu sütun korunuyor ve silinemez",
+ deleteColumnLastColumn: "Tabloda en az bir sütun kalmalıdır",
+ deleteColumnPendingChanges: "Sütunu silmeden önce bekleyen değişiklikleri kaydedin veya vazgeçin",
+ deleteColumnMessage: '"{column}" sütunu "{table}" tablosundan hemen silinir. Bu sütunda kayıtlı tüm değerler onunla birlikte silinir. Diğer sütunlardaki değerler kalır. Izgara geri alması bunu geri alamaz.',
+ deleteColumnsMessage: '{count} sütun "{table}" tablosundan hemen silinir ({columns}). Bu sütunlarda kayıtlı tüm değerler onlarla birlikte silinir. Diğer sütunlardaki değerler kalır. Izgara geri alması bunu geri alamaz.',
+ deleteColumnSuccess: '"{column}" sütunu silindi. Değerleri de onunla birlikte silindi.',
+ deleteColumnsSuccess: "{count} sütun silindi. Değerleri de onlarla birlikte silindi.",
+ deleteColumnFailed: "Sütun silinemedi: {message}",
+ deleteColumnFilterCleared: "Silinen sütunu kullanan filtre veya sıralama kaldırıldı",
cloneRows: "{count} Satırı Yeni Satır Olarak Çoğalt",
restoreRows: "{count} Satırı Geri Yükle",
copyRows: "{count} Satırı Kopyala (JSON Dizisi)",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index df3a5704fd..70df2ad40a 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -3484,6 +3484,20 @@ export default withEnglishFallback({
cloneRow: "克隆为新行",
deleteRow: "删除行",
deleteRows: "删除 {count} 行",
+ deleteColumn: "删除列",
+ deleteColumns: "删除 {count} 列",
+ deleteColumnTooltip: "删除当前字段,这一列里的数据会一起删除",
+ deleteColumnSelectColumn: "先选中要删除的字段",
+ deleteColumnPrimaryKey: "主键字段不能在这里删除",
+ deleteColumnProtected: "这个字段受保护,不能删除",
+ deleteColumnLastColumn: "表至少要保留一个字段",
+ deleteColumnPendingChanges: "请先保存或放弃当前待保存修改,再删除字段",
+ deleteColumnMessage: "将立即从「{table}」删除字段「{column}」。这一列里的全部数据会一起删除,其他列的数据保留。表格上的回滚不能撤销这次删除。",
+ deleteColumnsMessage: "将立即从「{table}」删除 {count} 个字段({columns})。这些列里的全部数据会一起删除,其他列的数据保留。表格上的回滚不能撤销这次删除。",
+ deleteColumnSuccess: "已删除字段「{column}」,这一列的数据也已删除",
+ deleteColumnsSuccess: "已删除 {count} 个字段,这些列的数据也已删除",
+ deleteColumnFailed: "删除字段失败:{message}",
+ deleteColumnFilterCleared: "已去掉引用被删字段的筛选或排序",
cloneRows: "克隆 {count} 行为新行",
restoreRows: "恢复 {count} 行",
copyRows: "复制 {count} 行(JSON 数组)",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index ea4b499db0..e93e0e5dbf 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -2975,6 +2975,20 @@ export default withEnglishFallback({
cloneRow: "複製為新資料",
deleteRow: "刪除資料",
deleteRows: "刪除 {count} 筆",
+ deleteColumn: "刪除欄位",
+ deleteColumns: "刪除 {count} 欄",
+ deleteColumnTooltip: "刪除目前欄位,這一欄裡的資料會一起刪除",
+ deleteColumnSelectColumn: "請先選取要刪除的欄位",
+ deleteColumnPrimaryKey: "主鍵欄位不能在這裡刪除",
+ deleteColumnProtected: "這個欄位受保護,不能刪除",
+ deleteColumnLastColumn: "資料表至少要保留一個欄位",
+ deleteColumnPendingChanges: "請先儲存或放棄目前待儲存的修改,再刪除欄位",
+ deleteColumnMessage: "將立即從「{table}」刪除欄位「{column}」。這一欄裡的全部資料會一起刪除,其他欄的資料保留。表格上的回滾不能復原這次刪除。",
+ deleteColumnsMessage: "將立即從「{table}」刪除 {count} 個欄位({columns})。這些欄裡的全部資料會一起刪除,其他欄的資料保留。表格上的回滾不能復原這次刪除。",
+ deleteColumnSuccess: "已刪除欄位「{column}」,這一欄的資料也已刪除",
+ deleteColumnsSuccess: "已刪除 {count} 個欄位,這些欄的資料也已刪除",
+ deleteColumnFailed: "刪除欄位失敗:{message}",
+ deleteColumnFilterCleared: "已移除引用被刪欄位的篩選或排序",
cloneRows: "複製 {count} 筆為新資料",
restoreRows: "復原 {count} 筆",
copyRows: "複製 {count} 筆(JSON 陣列)",
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridDropColumn.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridDropColumn.spec.ts
new file mode 100644
index 0000000000..cdb0bd688d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridDropColumn.spec.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { clearDataGridStructuredFilterStates, loadDataGridStructuredFilterState, removeDataGridStructuredFilterColumnsForTab, saveDataGridStructuredFilterState } from "@/lib/dataGrid/dataGridFilterBuilderPersistence";
+import {
+ dataGridDroppedColumnNames,
+ dataGridDropColumnToolbarState,
+ dataGridDropColumnVisibleIndexes,
+ dataGridDropTabsHavePending,
+ dataGridDropTargetTabs,
+ dataGridSqlTextReferencesAnyColumn,
+ dataGridSqlTextReferencesColumn,
+ isDataGridColumnNameCaseSensitive,
+ isDataGridViewTable,
+} from "@/lib/dataGrid/dataGridDropColumn";
+
+const status = { name: "status", primaryKey: false, protectedColumn: false };
+
+describe("data grid drop column", () => {
+ it("treats view table types as views", () => {
+ expect(isDataGridViewTable("VIEW")).toBe(true);
+ expect(isDataGridViewTable("MATERIALIZED VIEW")).toBe(true);
+ expect(isDataGridViewTable("BASE TABLE")).toBe(false);
+ expect(isDataGridViewTable(undefined)).toBe(false);
+ });
+
+ it("uses the selected columns, otherwise the focused column", () => {
+ expect(dataGridDropColumnVisibleIndexes([2, 0, 2], 4)).toEqual([0, 2]);
+ expect(dataGridDropColumnVisibleIndexes([], 3)).toEqual([3]);
+ expect(dataGridDropColumnVisibleIndexes([-1], null)).toEqual([]);
+ });
+
+ it("hides the action outside a droppable table and blocks unsafe targets", () => {
+ expect(dataGridDropColumnToolbarState({ available: false, busy: false, pendingChanges: false, tableColumnCount: 3, targets: [status] }).visible).toBe(false);
+ expect(dataGridDropColumnToolbarState({ available: true, busy: false, pendingChanges: false, tableColumnCount: 3, targets: [] }).blockedReason).toBe("no-target");
+ expect(dataGridDropColumnToolbarState({ available: true, busy: false, pendingChanges: false, tableColumnCount: 3, targets: [{ ...status, protectedColumn: true }] }).blockedReason).toBe("protected");
+ expect(dataGridDropColumnToolbarState({ available: true, busy: false, pendingChanges: false, tableColumnCount: 3, targets: [{ ...status, primaryKey: true }] }).blockedReason).toBe("primary-key");
+ expect(dataGridDropColumnToolbarState({ available: true, busy: false, pendingChanges: false, tableColumnCount: 1, targets: [status] }).blockedReason).toBe("last-column");
+ expect(dataGridDropColumnToolbarState({ available: true, busy: false, pendingChanges: true, tableColumnCount: 3, targets: [status] }).blockedReason).toBe("pending");
+ expect(dataGridDropColumnToolbarState({ available: true, busy: true, pendingChanges: false, tableColumnCount: 3, targets: [status] })).toEqual({ visible: true, disabled: true, blockedReason: "busy" });
+ expect(dataGridDropColumnToolbarState({ available: true, busy: false, pendingChanges: false, tableColumnCount: 3, targets: [status, { name: "note", primaryKey: false, protectedColumn: false }] })).toEqual({
+ visible: true,
+ disabled: false,
+ blockedReason: "none",
+ });
+ });
+
+ it("matches a column identifier without matching a longer name", () => {
+ expect(dataGridSqlTextReferencesColumn("gid = 1 AND status = 'open'", "gid")).toBe(true);
+ expect(dataGridSqlTextReferencesColumn("`status` IS NULL", "status")).toBe(true);
+ expect(dataGridSqlTextReferencesColumn("[status] > 0", "status")).toBe(true);
+ expect(dataGridSqlTextReferencesColumn("user_id = 1", "id")).toBe(false);
+ expect(dataGridSqlTextReferencesColumn("status_code = 1", "status")).toBe(false);
+ expect(dataGridSqlTextReferencesColumn("", "status")).toBe(false);
+ });
+
+ it("matches bare names at the start, after punctuation, and case-sensitively when asked", () => {
+ expect(dataGridSqlTextReferencesColumn("status", "status")).toBe(true);
+ expect(dataGridSqlTextReferencesColumn("t.status = 1", "status")).toBe(true);
+ expect(dataGridSqlTextReferencesColumn("$status = 1", "status")).toBe(false);
+ expect(dataGridSqlTextReferencesColumn("STATUS = 1", "status")).toBe(true);
+ expect(dataGridSqlTextReferencesColumn("STATUS = 1", "status", true)).toBe(false);
+ expect(dataGridSqlTextReferencesColumn('"Foo" = 1', "foo", true)).toBe(false);
+ });
+
+ it("keeps quoted Foo and foo apart on case-sensitive dialects and reports partial success", () => {
+ expect(isDataGridColumnNameCaseSensitive("postgres")).toBe(true);
+ expect(isDataGridColumnNameCaseSensitive("mysql")).toBe(false);
+ expect(dataGridDroppedColumnNames(["Foo", "foo"], ["foo"], true)).toEqual(["Foo"]);
+ expect(dataGridDroppedColumnNames(["Foo", "foo"], ["foo"], false)).toEqual([]);
+ expect(dataGridDroppedColumnNames(["a", "b", "c"], ["c"], false)).toEqual(["a", "b"]);
+ });
+
+ it("blocks on any open page of the table that has unsaved rows or a draft", () => {
+ const target = { connectionId: "c1", database: "db", schema: "", catalog: "", tableName: "t" };
+ const meta = { tableName: "t", database: "db" };
+ const tabs = [
+ { id: "a", mode: "data", connectionId: "c1", database: "db", tableMeta: meta },
+ { id: "b", mode: "data", connectionId: "c1", database: "db", tableMeta: meta, pendingDataChangeCount: 2 },
+ { id: "c", mode: "data", connectionId: "c1", database: "db", tableMeta: meta, hasPendingDataEditorDraft: true },
+ { id: "d", mode: "data", connectionId: "c1", database: "db", tableMeta: { tableName: "other", database: "db" }, pendingDataChangeCount: 5 },
+ { id: "e", mode: "data", connectionId: "c2", database: "db", tableMeta: meta, pendingDataChangeCount: 5 },
+ ];
+ const same = dataGridDropTargetTabs(tabs, target);
+ expect(same.map((tab) => tab.id)).toEqual(["a", "b", "c"]);
+ expect(dataGridDropTabsHavePending(same)).toBe(true);
+ expect(dataGridDropTabsHavePending([same[0]!])).toBe(false);
+ expect(dataGridDropTabsHavePending([same[2]!])).toBe(true);
+ });
+
+ it("detects dropped columns in another tab's query inputs before refresh", () => {
+ expect(dataGridSqlTextReferencesAnyColumn('status = 1 AND "archived" = 0', ["status", "archived"])).toBe(true);
+ expect(dataGridSqlTextReferencesAnyColumn("status_code = 1", ["status"])).toBe(false);
+ });
+
+ it("removes dropped columns from cached structured filters", async () => {
+ clearDataGridStructuredFilterStates();
+ saveDataGridStructuredFilterState("tab-1", {
+ scopeKey: "scope\u0001id\0status\0name",
+ manualWhereInput: "status = 1",
+ rules: [{ id: "r1", columnName: "status", mode: "equals", rawValue: "1", rawEndValue: "", conjunction: "AND" }],
+ appliedWhereInput: "status = 1",
+ serverColumnFilters: { 1: { condition: "status = 1", keys: ["1"], labels: ["1"] } },
+ });
+ await removeDataGridStructuredFilterColumnsForTab("tab-1", ["id", "status", "name"], ["status"], false, async () => "");
+ expect(loadDataGridStructuredFilterState("tab-1", "scope\u0001id\0name")).toMatchObject({ manualWhereInput: "", rules: [], appliedWhereInput: "", serverColumnFilters: {} });
+ });
+
+ it("preserves remaining rules and remaps server filters after a partial drop", async () => {
+ clearDataGridStructuredFilterStates();
+ const state = {
+ scopeKey: "connection\u0001db\u0001\u0001table-data\u0001\u0001t\u0001id\0status\0score",
+ manualWhereInput: "id > 0",
+ rules: ["status", "score"].map((columnName) => ({ id: columnName, columnName, mode: "equals" as const, rawValue: "1", rawEndValue: "", conjunction: "AND" as const })),
+ appliedWhereInput: "status = 1 AND score = 1",
+ serverColumnFilters: { 2: { condition: "score = 1", keys: ["1"], labels: ["1"] } },
+ };
+ saveDataGridStructuredFilterState("tab-a", state);
+ saveDataGridStructuredFilterState("tab-b", state);
+ const result = await removeDataGridStructuredFilterColumnsForTab("tab-a", ["id", "status", "score"], ["status"], false, async (rules) => rules.map((rule) => `${rule.columnName} = ${rule.rawValue}`).join(" AND "));
+ expect(result).toMatchObject({ manualWhereInput: "id > 0", appliedWhereInput: "score = 1", rules: [{ columnName: "score" }], serverColumnFilters: { 1: state.serverColumnFilters[2] } });
+ expect(loadDataGridStructuredFilterState("tab-a", state.scopeKey)).toBeUndefined();
+ expect(loadDataGridStructuredFilterState("tab-a", result!.scopeKey)).toEqual(result);
+ expect(loadDataGridStructuredFilterState("tab-b", state.scopeKey)).toEqual(state);
+ });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridToolbar.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridToolbar.spec.ts
index 67e7f0fcd7..886be61864 100644
--- a/apps/desktop/src/lib/__tests__/dataGrid/dataGridToolbar.spec.ts
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridToolbar.spec.ts
@@ -94,6 +94,7 @@ describe("data grid toolbar capabilities", () => {
const visibleActions = ["refresh", "navigation", "addRow", "preview", "save", "rollback"] as const;
expect(DATA_GRID_TOOLBAR_ACTION_COLLAPSE_ORDER.slice(-3)).toEqual(["preview", "save", "rollback"]);
+ expect(DATA_GRID_TOOLBAR_ACTION_COLLAPSE_ORDER.indexOf("deleteColumn")).toBe(DATA_GRID_TOOLBAR_ACTION_COLLAPSE_ORDER.indexOf("deleteRow") + 1);
expect(isDataGridToolbarActionCompact("refresh", visibleActions, 3)).toBe(true);
expect(isDataGridToolbarActionCompact("navigation", visibleActions, 3)).toBe(true);
expect(isDataGridToolbarActionCompact("addRow", visibleActions, 3)).toBe(true);
diff --git a/apps/desktop/src/lib/dataGrid/dataGridDropColumn.ts b/apps/desktop/src/lib/dataGrid/dataGridDropColumn.ts
new file mode 100644
index 0000000000..d1a9a9538e
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridDropColumn.ts
@@ -0,0 +1,117 @@
+export interface DataGridDropColumnCandidate {
+ name: string;
+ primaryKey: boolean;
+ protectedColumn: boolean;
+}
+
+export type DataGridDropColumnBlockReason = "unavailable" | "no-target" | "protected" | "primary-key" | "last-column" | "pending" | "busy" | "none";
+
+export interface DataGridDropColumnToolbarState {
+ visible: boolean;
+ disabled: boolean;
+ blockedReason: DataGridDropColumnBlockReason;
+}
+
+/** Same view check as `isViewTableType` in table editing: views have no DROP COLUMN target. */
+export function isDataGridViewTable(tableType?: string): boolean {
+ return tableType?.toUpperCase().includes("VIEW") === true;
+}
+
+/**
+ * Column-header selection wins. A focused cell is the target only when no
+ * column is selected, so a cell range does not drop every column it touches.
+ */
+export function dataGridDropColumnVisibleIndexes(selectedVisibleIndexes: readonly number[], focusVisibleIndex: number | null | undefined): number[] {
+ const selected = [...new Set(selectedVisibleIndexes.filter((index) => Number.isInteger(index) && index >= 0))].sort((left, right) => left - right);
+ if (selected.length > 0) return selected;
+ if (typeof focusVisibleIndex === "number" && Number.isInteger(focusVisibleIndex) && focusVisibleIndex >= 0) return [focusVisibleIndex];
+ return [];
+}
+
+export function dataGridDropColumnToolbarState(options: { available: boolean; busy: boolean; pendingChanges: boolean; tableColumnCount: number; targets: readonly DataGridDropColumnCandidate[] }): DataGridDropColumnToolbarState {
+ if (!options.available) return { visible: false, disabled: true, blockedReason: "unavailable" };
+ if (options.targets.length === 0) return { visible: true, disabled: true, blockedReason: "no-target" };
+ if (options.targets.some((target) => target.protectedColumn)) return { visible: true, disabled: true, blockedReason: "protected" };
+ if (options.targets.some((target) => target.primaryKey)) return { visible: true, disabled: true, blockedReason: "primary-key" };
+ if (options.tableColumnCount > 0 && options.targets.length >= options.tableColumnCount) return { visible: true, disabled: true, blockedReason: "last-column" };
+ if (options.pendingChanges) return { visible: true, disabled: true, blockedReason: "pending" };
+ if (options.busy) return { visible: true, disabled: true, blockedReason: "busy" };
+ return { visible: true, disabled: false, blockedReason: "none" };
+}
+
+function escapeRegExp(value: string): string {
+ return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** Dialects whose quoted identifiers differ by case ("Foo" and "foo" are two columns). */
+export function isDataGridColumnNameCaseSensitive(dialect: string | undefined): boolean {
+ return dialect === "postgres" || dialect === "oracle" || dialect === "h2";
+}
+
+export function dataGridColumnNameKey(name: string, caseSensitive: boolean): string {
+ return caseSensitive ? name : name.toLowerCase();
+}
+
+/** Attempted columns that are no longer in the server's column list. */
+export function dataGridDroppedColumnNames(attempted: readonly string[], remaining: readonly string[], caseSensitive: boolean): string[] {
+ const left = new Set(remaining.map((name) => dataGridColumnNameKey(name, caseSensitive)));
+ return attempted.filter((name) => !left.has(dataGridColumnNameKey(name, caseSensitive)));
+}
+
+/** True when `sql` cites `column` as its own identifier, quoted or bare. */
+export function dataGridSqlTextReferencesColumn(sql: string | undefined, column: string, caseSensitive = false): boolean {
+ const text = sql ?? "";
+ const name = column.trim();
+ if (!text.trim() || !name) return false;
+ const escaped = escapeRegExp(name);
+ const quoted = `"${escaped}"|\`${escaped}\`|\\[${escaped}\\]`;
+ // No lookbehind (unsupported by old WebViews): consume the preceding char instead.
+ const bare = `(?:^|[^\\w$])${escaped}(?![\\w$])`;
+ return new RegExp(`${quoted}|${bare}`, caseSensitive ? "" : "i").test(text);
+}
+
+/** True when a query fragment references any of the columns being dropped. */
+export function dataGridSqlTextReferencesAnyColumn(sql: string | undefined, columns: readonly string[], caseSensitive = false): boolean {
+ return columns.some((column) => dataGridSqlTextReferencesColumn(sql, column, caseSensitive));
+}
+
+export interface DataGridDropTarget {
+ connectionId: string;
+ database: string;
+ schema: string;
+ catalog: string;
+ tableName: string;
+}
+
+interface DataGridDropTab {
+ mode?: string;
+ connectionId: string;
+ database?: string;
+ schema?: string;
+ tableMeta?: { tableName: string; database?: string; schema?: string; catalog?: string };
+ pendingDataChangeCount?: number;
+ hasPendingDataEditorDraft?: boolean;
+}
+
+export function sameOptionalScope(left?: string, right?: string): boolean {
+ const normalizedLeft = left?.trim() ?? "";
+ const normalizedRight = right?.trim() ?? "";
+ if (!normalizedLeft || !normalizedRight) return true;
+ return normalizedLeft === normalizedRight;
+}
+
+/** Open data tabs (any pane) showing the table a drop targets. */
+export function dataGridDropTargetTabs<T extends DataGridDropTab>(tabs: readonly T[], target: DataGridDropTarget): T[] {
+ return tabs.filter((tab) => {
+ const meta = tab.tableMeta;
+ if (tab.mode !== "data" || tab.connectionId !== target.connectionId || !meta || meta.tableName !== target.tableName) return false;
+ const tabDatabase = meta.database || tab.database;
+ if (tabDatabase !== target.database && tab.database !== target.database) return false;
+ return sameOptionalScope(meta.schema || tab.schema, target.schema) && sameOptionalScope(meta.catalog, target.catalog);
+ });
+}
+
+/** A refresh of these tabs would discard unsaved rows or an open cell draft. */
+export function dataGridDropTabsHavePending(tabs: readonly DataGridDropTab[]): boolean {
+ return tabs.some((tab) => (tab.pendingDataChangeCount ?? 0) > 0 || tab.hasPendingDataEditorDraft === true);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridFilterBuilderPersistence.ts b/apps/desktop/src/lib/dataGrid/dataGridFilterBuilderPersistence.ts
index e6c2bb17f0..7aded39acd 100644
--- a/apps/desktop/src/lib/dataGrid/dataGridFilterBuilderPersistence.ts
+++ b/apps/desktop/src/lib/dataGrid/dataGridFilterBuilderPersistence.ts
@@ -1,6 +1,7 @@
import type { DataGridStructuredFilterRule } from "@/composables/useDataGridFilterBuilder";
import { safeLocalStorageGet, safeLocalStorageRemove, safeLocalStorageSet } from "@/lib/backend/safeStorage";
import type { DataGridContextFilterMode } from "@/lib/dataGrid/dataGridSql";
+import { dataGridColumnNameKey, dataGridSqlTextReferencesAnyColumn } from "@/lib/dataGrid/dataGridDropColumn";
export type DataGridCachedServerColumnFilter = {
condition: string;
@@ -189,6 +190,33 @@ export function clearDataGridStructuredFilterStatesForTab(tabId: string) {
persistToStorage();
}
+/** Migrate a table tab's filters before its metadata and refresh SQL change. */
+export async function removeDataGridStructuredFilterColumnsForTab(tabId: string, columns: readonly string[], droppedColumns: readonly string[], caseSensitive: boolean, buildWhere: (rules: DataGridStructuredFilterRule[]) => Promise<string>): Promise<DataGridStructuredFilterCacheState | undefined> {
+ ensureHydrated();
+ const state = structuredFilterStateCache.get(tabId);
+ if (!state || droppedColumns.length === 0) return undefined;
+ const key = (name: string) => dataGridColumnNameKey(name, caseSensitive);
+ const dropped = new Set(droppedColumns.map(key));
+ const remainingColumns = columns.filter((name) => !dropped.has(key(name)));
+ const rules = state.rules.filter((rule) => !dropped.has(key(rule.columnName)));
+ const manualWhereInput = dataGridSqlTextReferencesAnyColumn(state.manualWhereInput, droppedColumns, caseSensitive) ? "" : state.manualWhereInput;
+ const serverColumnFilters: Record<number, DataGridCachedServerColumnFilter> = {};
+ for (const [indexText, filter] of Object.entries(state.serverColumnFilters)) {
+ const column = columns[Number(indexText)];
+ if (!column || dropped.has(key(column)) || dataGridSqlTextReferencesAnyColumn(filter.condition, droppedColumns, caseSensitive)) continue;
+ serverColumnFilters[remainingColumns.indexOf(column)] = filter;
+ }
+ const appliedWhereInput = rules.length === state.rules.length ? state.appliedWhereInput : await buildWhere(cloneDataGridStructuredFilterRules(rules));
+ // The last scope component is the column list; preserve the tab's own schema
+ // and connection components instead of reconstructing them from another pane.
+ const scopeParts = state.scopeKey.split("\u0001");
+ scopeParts[scopeParts.length - 1] = remainingColumns.join("\0");
+ const next = { scopeKey: scopeParts.join("\u0001"), rules, manualWhereInput, appliedWhereInput, serverColumnFilters };
+ structuredFilterStateCache.set(tabId, cloneState(next));
+ persistToStorage();
+ return next;
+}
+
export function clearDataGridStructuredFilterStates() {
structuredFilterStateCache.clear();
hydrated = true;
diff --git a/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts b/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts
index 7faec2541f..4e79ec5cbf 100644
--- a/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts
+++ b/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts
@@ -4,7 +4,7 @@ const DATA_GRID_COMPACT_TOPBAR_VIEWPORT_RATIO = 0.75;
const DATA_GRID_TOOLBAR_ACTION_COLLAPSE_STEP = 40;
export const DATA_GRID_CONDITION_TOOLBAR_MIN_WIDTH = DATA_GRID_COMPACT_TOPBAR_MAX_WIDTH;
-export const DATA_GRID_TOOLBAR_ACTION_COLLAPSE_ORDER = ["refresh", "autoRefresh", "copyData", "addRow", "deleteRow", "exportData", "transpose", "tableInfo", "layerPreview", "preview", "save", "rollback"] as const;
+export const DATA_GRID_TOOLBAR_ACTION_COLLAPSE_ORDER = ["refresh", "autoRefresh", "copyData", "addRow", "deleteRow", "deleteColumn", "exportData", "transpose", "tableInfo", "layerPreview", "preview", "save", "rollback"] as const;
export type DataGridToolbarActionKey = (typeof DATA_GRID_TOOLBAR_ACTION_COLLAPSE_ORDER)[number];