From aa6d60533c5542b23ff0f06c412b0ac7d69a5c30 Mon Sep 17 00:00:00 2001
From: jearhe <0verme7753@gmail.com>
Date: Mon, 17 Aug 2026 16:31:44 +0800
Subject: [PATCH] feat(postgres): support concurrent index creation

---
 .../TableStructureEditor.primaryKey.spec.ts   |   6 +
 .../structure/TableStructureEditor.vue        | 246 ++++++++-
 .../TableStructureEditor.concurrent.spec.ts   | 114 +++++
 ...ructureEditor.concurrentTransition.spec.ts | 378 ++++++++++++++
 apps/desktop/src/i18n/locales/en.ts           |   9 +
 apps/desktop/src/i18n/locales/es.ts           |   9 +
 apps/desktop/src/i18n/locales/it.ts           |   9 +
 apps/desktop/src/i18n/locales/ja.ts           |   9 +
 apps/desktop/src/i18n/locales/ko.ts           |   8 +
 apps/desktop/src/i18n/locales/pt-BR.ts        |   9 +
 apps/desktop/src/i18n/locales/zh-CN.ts        |   8 +
 apps/desktop/src/i18n/locales/zh-TW.ts        |   8 +
 .../lib/__tests__/sql/queryTimeout.spec.ts    |  19 +-
 .../table/tableStructureCapabilities.spec.ts  |  16 +
 apps/desktop/src/lib/backend/api.ts           |   2 +
 apps/desktop/src/lib/backend/http.ts          |  16 +-
 apps/desktop/src/lib/backend/tauri.ts         |  23 +
 apps/desktop/src/lib/diagram/draft-table.ts   |   1 +
 apps/desktop/src/lib/sql/queryTimeout.ts      |  28 ++
 .../lib/table/concurrentIndexAvailability.ts  |  78 +++
 .../lib/table/tableStructureCapabilities.ts   |   5 +-
 .../src/lib/table/tableStructureEditorSql.ts  |   6 +
 crates/dbx-core/src/db/postgres.rs            |  24 +
 crates/dbx-core/src/schema.rs                 |  57 +++
 crates/dbx-core/src/table_structure_sql.rs    |   9 +-
 .../src/table_structure_sql/create_table.rs   |   7 +-
 .../src/table_structure_sql/dialect.rs        |  50 +-
 .../src/table_structure_sql/indexes.rs        |  14 +-
 .../src/table_structure_sql/sqlite_rebuild.rs |   3 +
 .../dbx-core/src/table_structure_sql/tests.rs | 467 ++++++++++++++++++
 .../dbx-core/src/table_structure_sql/types.rs |   9 +
 .../src/table_structure_sql/validation.rs     |  34 ++
 .../tests/live_postgres_concurrent_index.rs   | 217 ++++++++
 .../tests/live_sqlserver_completion.rs        |   1 +
 crates/dbx-web/src/main.rs                    |   2 +
 crates/dbx-web/src/routes/schema.rs           |  26 +
 src-tauri/src/commands/schema.rs              |  22 +
 src-tauri/src/lib.rs                          |   2 +
 38 files changed, 1917 insertions(+), 34 deletions(-)
 create mode 100644 apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrent.spec.ts
 create mode 100644 apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrentTransition.spec.ts
 create mode 100644 apps/desktop/src/lib/table/concurrentIndexAvailability.ts
 create mode 100644 crates/dbx-core/tests/live_postgres_concurrent_index.rs

diff --git a/apps/desktop/src/components/structure/TableStructureEditor.primaryKey.spec.ts b/apps/desktop/src/components/structure/TableStructureEditor.primaryKey.spec.ts
index 9c8d90fdfe..8410e1be0d 100644
--- a/apps/desktop/src/components/structure/TableStructureEditor.primaryKey.spec.ts
+++ b/apps/desktop/src/components/structure/TableStructureEditor.primaryKey.spec.ts
@@ -18,6 +18,7 @@ const mocks = vi.hoisted(() => ({
   invalidateObjectDdl: vi.fn(),
   loadObjectMetadataFacet: vi.fn(),
   invalidateTableMetadataCache: vi.fn(),
+  getTablePartitionStatus: vi.fn(),
   toast: vi.fn(),
 }));
 
@@ -218,6 +219,7 @@ vi.mock("@/lib/metadata/tableMetadataCache", () => ({ invalidateTableMetadataCac
 vi.mock("@/lib/backend/api", () => ({
   listDataTypes: mocks.listDataTypes,
   buildTableStructureChangeSql: mocks.buildTableStructureChangeSql,
+  getTablePartitionStatus: mocks.getTablePartitionStatus,
 }));
 
 import TableStructureEditor from "@/components/structure/TableStructureEditor.vue";
@@ -333,6 +335,10 @@ beforeEach(() => {
   mocks.loadObjectDdl.mockResolvedValue({ ddl: "CREATE TABLE users (id bigint)", cacheStatus: "remote" });
   mocks.invalidateObjectDdl.mockResolvedValue(undefined);
   mocks.loadObjectMetadataFacet.mockResolvedValue({ value: [], cacheStatus: "remote" });
+  // TableStructureEditor probes the partition status for PostgreSQL tables
+  // (PR #6361); a resolved non-partitioned result keeps metadata loads on the
+  // original facet expectations unchanged.
+  mocks.getTablePartitionStatus.mockResolvedValue({ isPartitionedParent: false, isPartition: false });
 });
 
 afterEach(() => {
diff --git a/apps/desktop/src/components/structure/TableStructureEditor.vue b/apps/desktop/src/components/structure/TableStructureEditor.vue
index b23596e886..d8a79455c2 100644
--- a/apps/desktop/src/components/structure/TableStructureEditor.vue
+++ b/apps/desktop/src/components/structure/TableStructureEditor.vue
@@ -25,7 +25,7 @@ import { type SqlHighlighter, createShikiSqlHighlighter } from "@/lib/sql/sqlHig
 import { joinSqlStatementsForScript } from "@/lib/sql/sqlBatchScript";
 import { copyToClipboard } from "@/lib/common/clipboard";
 import { formatSqlForDisplay, sqlFormatDialectForDbType } from "@/lib/sql/sqlFormatter";
-import { queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
+import { queryTimeoutSecsForConcurrentIndex, queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
 import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
 import { invalidateObjectDdl, loadObjectDdl } from "@/lib/metadata/objectDdlCache";
 import { loadObjectMetadataFacet, type ObjectMetadataFacet } from "@/lib/metadata/objectMetadataCache";
@@ -38,6 +38,7 @@ import { getSqliteDataTypeHelp } from "@/lib/table/sqliteDataTypeHelp";
 import { getTableMetadataCapabilities, firstStructureMetadataTab, isStructureMetadataTabSupported } from "@/lib/table/tableMetadataCapabilities";
 import { hasTableStructureRefreshWork, unloadedTableStructureRefreshScope, visibleTableStructureRefreshScope, type TableStructureRefreshScope } from "@/lib/table/tableStructureMetadataLoading";
 import { canAddTableStructureColumn, getTableStructureCapabilities, hasLocalTableColumnOrderChange, isPhysicalTableColumnOrderChange, sanitizeStructureIndexesForCapabilities, supportsLocalTableColumnReorder } from "@/lib/table/tableStructureCapabilities";
+import { getConcurrentIndexAvailability, concurrentIndexNamesInStatements, normalizeUnsupportedConcurrentIndexes, type ConcurrentIndexAvailability } from "@/lib/table/concurrentIndexAvailability";
 import { orderedColumnIndexes, uniqueDataGridColumnOrderKeys } from "@/lib/dataGrid/dataGridColumnOrder";
 import { loadTableDataGridColumnOrder, notifyTableDataGridColumnOrderChanged, removeTableDataGridColumnOrder, saveTableDataGridColumnOrder, tableDataGridColumnOrderScopeKey } from "@/lib/dataGrid/dataGridColumnLayoutStorage";
 import { connectionObjectTreeQuerySchema, tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
@@ -207,6 +208,21 @@ const copySourceColumnsLoading = ref(false);
 const copySourceError = ref("");
 let copySourceColumnsRequestId = 0;
 const indexes = ref<EditableStructureIndex[]>([]);
+/** PostgreSQL partitioned parent (`relkind = 'p'`): `CREATE INDEX CONCURRENTLY`
+ * is rejected by the server on such tables, so the option is disabled here and
+ * the SQL builder refuses any concurrent request on it (fail closed). */
+const isPartitionedParent = ref(false);
+/** Whether the last partition-status probe succeeded. When it cannot be
+ * verified (probe failed), Concurrent is disabled — we must not assume a
+ * non-partitioned table we could not check. */
+const partitionStatusKnown = ref(true);
+/** Set when a `concurrently: true` index draft had to be normalized away
+ * because Concurrent availability became unknown/unsupported (partition probe
+ * failure, partitioned parent, capability loss). While set, no SQL is
+ * generated and Save stays blocked until the user re-verifies (the next
+ * successful probe clears it) — a cleared flag must never silently degrade
+ * into a blocking `CREATE INDEX`. */
+const concurrentAvailabilityInvalidated = ref(false);
 const pendingStatements = ref<string[]>([]);
 const warnings = ref<string[]>([]);
 const sqliteSchemaRevision = ref<string>();
@@ -254,7 +270,8 @@ function indexChanged(index: EditableStructureIndex): boolean {
     !sameText(index.filter, original.filter) ||
     !sameStructureIndexType(index.indexType, original.index_type) ||
     !sameList(index.includedColumns, original.included_columns) ||
-    !sameText(index.comment, original.comment)
+    !sameText(index.comment, original.comment) ||
+    !!index.concurrently
   );
 }
 
@@ -303,7 +320,7 @@ const STRUCTURE_COLUMNS_WIDTHS_STORAGE_KEY = "dbx-structure-editor-column-widths
 const STRUCTURE_INDEX_COLUMNS_WIDTHS_STORAGE_KEY = "dbx-structure-editor-index-column-widths";
 const STRUCTURE_SQL_PREVIEW_COLLAPSED_STORAGE_KEY = "dbx-structure-editor-sql-preview-collapsed";
 const STRUCTURE_COLUMN_WIDTH_COUNT = 12;
-const STRUCTURE_INDEX_COLUMN_WIDTH_COUNT = 8;
+const STRUCTURE_INDEX_COLUMN_WIDTH_COUNT = 9;
 const PERSISTED_STRUCTURE_INDEX_COLUMN_WIDTHS = new Set([0, 1, 6]);
 const structureDensityMetrics: Record<
   StructureEditorDensity,
@@ -328,7 +345,7 @@ const structureDensityMetrics: Record<
 > = {
   compact: {
     columns: [28, 168, 136, 82, 60, 52, 108, 220, 80, 120, 144, 108],
-    indexes: [120, 180, 60, 88, 124, 144, 120, 70],
+    indexes: [120, 180, 60, 88, 124, 144, 120, 84, 70],
     minColumnWidth: 24,
     minLengthColumnWidth: 140,
     minIndexColumnWidth: 48,
@@ -346,7 +363,7 @@ const structureDensityMetrics: Record<
   },
   standard: {
     columns: [32, 200, 160, 104, 72, 64, 128, 260, 90, 140, 160, 136],
-    indexes: [148, 224, 72, 108, 148, 180, 148, 84],
+    indexes: [148, 224, 72, 108, 148, 180, 148, 100, 84],
     minColumnWidth: 28,
     minLengthColumnWidth: 156,
     minIndexColumnWidth: 60,
@@ -364,7 +381,7 @@ const structureDensityMetrics: Record<
   },
   comfortable: {
     columns: [36, 232, 188, 116, 84, 76, 152, 300, 100, 160, 188, 148],
-    indexes: [176, 260, 84, 124, 176, 216, 176, 104],
+    indexes: [176, 260, 84, 124, 176, 216, 176, 116, 104],
     minColumnWidth: 32,
     minLengthColumnWidth: 176,
     minIndexColumnWidth: 64,
@@ -825,7 +842,17 @@ const colLabels = computed(() => {
   labels.push({ key: "actions", label: t("structureEditor.actions"), widthIndex: 11 });
   return labels;
 });
-const indexColLabels = computed(() => [t("structureEditor.indexName"), t("structureEditor.indexColumns"), t("structureEditor.unique"), t("structureEditor.indexType"), t("structureEditor.includedColumns"), t("structureEditor.filter"), t("structureEditor.comment"), t("structureEditor.actions")]);
+const indexColLabels = computed(() => [
+  t("structureEditor.indexName"),
+  t("structureEditor.indexColumns"),
+  t("structureEditor.unique"),
+  t("structureEditor.indexType"),
+  t("structureEditor.includedColumns"),
+  t("structureEditor.filter"),
+  t("structureEditor.comment"),
+  t("structureEditor.concurrent"),
+  t("structureEditor.actions"),
+]);
 const filteredColumnRowIds = computed(() => {
   const query = columnSearchText.value.trim().toLowerCase();
   if (!query) return new Set<string>();
@@ -1089,7 +1116,15 @@ function restoreDraft(draft: TableStructureEditorDraft) {
   tableComment.value = draft.tableComment || "";
   originalTableComment.value = draft.originalTableComment || "";
   columns.value = cloneDraftValue(draft.columns || []);
-  indexes.value = cloneDraftValue(draft.indexes || []);
+  // Existing-index edits never support Concurrent (the checkbox is disabled and
+  // the core builder rejects the request), so a stale `concurrently: true`
+  // saved in a restored draft must not be submitted or deadlock the save.
+  indexes.value = cloneDraftValue(draft.indexes || []).map((index) => (index.original ? { ...index, concurrently: false } : index));
+  // Re-run the availability normalization against the current inputs (e.g. a
+  // re-activated editor may already carry an unknown/unsupported partition
+  // status): restored new-index Concurrent choices that became illegal are
+  // normalized away with the same fail-closed invalidation as a probe failure.
+  normalizeConcurrentIndexDraftsForCurrentAvailability();
   foreignKeys.value = cloneDraftValue(draft.foreignKeys || []);
   constraints.value = cloneDraftValue(draft.constraints || []);
   // Drafts created before constraint loading existed have no saved facet.
@@ -1306,11 +1341,23 @@ function structureChangeOptions(): BuildTableStructureChangeSqlOptions {
     triggers: triggers.value,
     tableComment: tableComment.value,
     originalTableComment: isCreateMode.value ? undefined : originalTableComment.value,
+    partitioned: isPartitionedParent.value,
   };
 }
 
 async function refreshSqlPreview() {
   const requestId = ++sqlPreviewRequestId;
+  if (concurrentAvailabilityInvalidated.value) {
+    // Availability gap in effect: never regenerate SQL here — doing so would
+    // turn a lost Concurrent request into a silent blocking CREATE INDEX. Keep
+    // the explicit error visible until a later probe re-verifies the table.
+    pendingStatements.value = [];
+    warnings.value = [t("structureEditor.concurrentUnavailableBlocksSave")];
+    sqliteSchemaRevision.value = undefined;
+    sqlPreviewLoading.value = false;
+    sqlPreviewPending.value = false;
+    return;
+  }
   if (!hasPendingStructureChanges()) {
     pendingStatements.value = [];
     warnings.value = [];
@@ -1319,6 +1366,18 @@ async function refreshSqlPreview() {
     sqlPreviewPending.value = false;
     return;
   }
+  // Layer B: a stale `concurrently: true` whose availability is no longer
+  // enabled must never reach the SQL builder, even if normalization was
+  // skipped (race, restored draft, non-UI caller).
+  const blockingConcurrentWarning = concurrentIndexBlockingWarning();
+  if (blockingConcurrentWarning) {
+    pendingStatements.value = [];
+    warnings.value = [blockingConcurrentWarning];
+    sqliteSchemaRevision.value = undefined;
+    sqlPreviewLoading.value = false;
+    sqlPreviewPending.value = false;
+    return;
+  }
   sqlPreviewLoading.value = true;
   const options = structureChangeOptions();
   try {
@@ -1350,6 +1409,7 @@ const canApply = computed(
     !sqlPreviewPending.value &&
     pendingStatements.value.length > 0 &&
     warnings.value.length === 0 &&
+    !concurrentAvailabilityInvalidated.value &&
     (!hasSqliteTypeChange.value || !!sqliteSchemaRevision.value) &&
     !!props.connectionId &&
     (isCreateMode.value ? !!newTableName.value.trim() : !!props.tableName),
@@ -1371,6 +1431,9 @@ function resetState() {
   constraintsLoading.value = false;
   triggersLoading.value = false;
   errorMessage.value = "";
+  isPartitionedParent.value = false;
+  partitionStatusKnown.value = true;
+  concurrentAvailabilityInvalidated.value = false;
   columns.value = [];
   indexes.value = [];
   pendingStatements.value = [];
@@ -1469,6 +1532,18 @@ async function loadStructure(
 
     const metadataRequest = ddlRequest();
     const forceMetadata = options.forceMetadata === true;
+    const partitionStatusPromise =
+      databaseType.value === "postgres" && !isCreateMode.value
+        ? api
+            .getTablePartitionStatus(connectionId, database, schema, tableName)
+            // No reactive mutation inside the catch: a stale request must not
+            // overwrite a newer probe's result (the structureLoadRequestId
+            // guard below decides). Fail closed — without a verified partition
+            // status we cannot rule out a partitioned parent, so Concurrent is
+            // treated as unavailable until a later reload re-runs the probe.
+            .then((status) => ({ known: true, status }))
+            .catch(() => ({ known: false, status: { isPartitionedParent: false, isPartition: false } }))
+        : Promise.resolve({ known: true, status: { isPartitionedParent: false, isPartition: false } });
     const columnsPromise = scope.columns ? loadObjectMetadataFacet(metadataRequest, "columns", () => api.getColumns(connectionId, database, schema, tableName, catalog), { force: forceMetadata }).then((result) => result.value) : Promise.resolve(undefined);
     const indexesPromise = scope.indexes
       ? tableMetadataCapabilities.value.indexes
@@ -1520,6 +1595,20 @@ async function loadStructure(
       tableComment.value = nextTableComment;
       loadedMetadataFacets.add("comment");
     }
+    const partitionStatus = await partitionStatusPromise;
+    if (requestId === structureLoadRequestId) {
+      partitionStatusKnown.value = partitionStatus.known;
+      isPartitionedParent.value = partitionStatus.status.isPartitionedParent;
+      // Availability inputs changed: fail closed while the status is unknown,
+      // but preserve the user's Concurrent intent so a later successful probe
+      // can regenerate the same SQL. Definitive unsupported states still clear
+      // the flag. A partitioned parent or unknown status keeps Save blocked.
+      normalizeConcurrentIndexDraftsForCurrentAvailability();
+      if (partitionStatus.known && !partitionStatus.status.isPartitionedParent && structureCapabilities.value.indexConcurrent && structureCapabilities.value.createIndex && concurrentAvailabilityInvalidated.value) {
+        concurrentAvailabilityInvalidated.value = false;
+        scheduleSqlPreviewRefresh();
+      }
+    }
     const applySecondaryMetadata = async () => {
       const [nextIndexes, nextForeignKeys, nextConstraints, nextTriggers] = await Promise.all([indexesPromise, foreignKeysPromise, constraintsPromise, triggersPromise]);
       if (requestId !== structureLoadRequestId) return;
@@ -2345,6 +2434,7 @@ function addIndex() {
     indexType: "",
     includedColumns: [],
     comment: "",
+    concurrently: false,
     markedForDrop: false,
   });
   void nextTick(() => {
@@ -2427,6 +2517,89 @@ function canEditIndexDraft(index: EditableStructureIndex): boolean {
   return structureCapabilities.value.rebuildIndex && structureCapabilities.value.createIndex && structureCapabilities.value.dropIndex;
 }
 
+/**
+ * Whether the Concurrent checkbox is actionable for this index draft.
+ *
+ * Plan A scope guard (PR #6361 review): concurrent builds apply only to newly
+ * created indexes on non-partitioned tables. Editing an existing index would
+ * require a `DROP INDEX CONCURRENTLY` + `CREATE INDEX CONCURRENTLY` replace
+ * flow (not implemented yet), PostgreSQL rejects `CREATE INDEX CONCURRENTLY`
+ * on partitioned parents, and an unverifiable partition status fails closed —
+ * all of those disable the checkbox here. The core SQL builder enforces the
+ * same scope as a hard error, so this is only the first layer.
+ */
+function concurrentIndexAvailability(index: EditableStructureIndex): ConcurrentIndexAvailability {
+  if (indexesLoading.value) return { enabled: false, reason: "unknown" };
+  return concurrentIndexAvailabilityState(index);
+}
+
+/** Same decision as [`concurrentIndexAvailability`], independent of the
+ * indexes-loading flag — state-normalization runs while metadata may still be
+ * in flight, and must decide on the availability inputs alone. */
+function concurrentIndexAvailabilityState(index: EditableStructureIndex): ConcurrentIndexAvailability {
+  return getConcurrentIndexAvailability({
+    hasOriginal: !!index.original,
+    isPrimary: index.isPrimary,
+    markedForDrop: index.markedForDrop,
+    isPartitionedParent: isPartitionedParent.value,
+    partitionStatusKnown: partitionStatusKnown.value,
+    supportsIndexConcurrent: structureCapabilities.value.indexConcurrent,
+    supportsCreateIndex: structureCapabilities.value.createIndex,
+  });
+}
+
+/**
+ * Layer A — invalidate `concurrently: true` drafts whenever Concurrent becomes
+ * unavailable. Transiently unknown partition status preserves the flag so a
+ * later successful probe can recover the user's intent; definitive unsupported
+ * states clear it. In both cases, empty pending SQL and keep Save blocked until
+ * availability is verified again.
+ */
+function normalizeConcurrentIndexDraftsForCurrentAvailability(): boolean {
+  // Engines that cannot express Concurrent (non-PostgreSQL dialects) ignore a
+  // stale flag in the core builder and render no checkbox; blocking the save
+  // there would only trap a draft carried over from a PostgreSQL session.
+  if (!structureCapabilities.value.indexConcurrent) return false;
+  const { indexes: normalized, invalidatedIds } = normalizeUnsupportedConcurrentIndexes(indexes.value, concurrentIndexAvailabilityState);
+  if (invalidatedIds.length === 0) return false;
+  indexes.value = normalized;
+  concurrentAvailabilityInvalidated.value = true;
+  pendingStatements.value = [];
+  warnings.value = [t("structureEditor.concurrentUnavailableBlocksSave")];
+  sqlPreviewLoading.value = false;
+  sqlPreviewPending.value = false;
+  errorMessage.value = t("structureEditor.concurrentUnavailableBlocksSave");
+  return true;
+}
+
+/** Layer B — a `concurrently: true` draft whose availability is no longer
+ * enabled must never reach the SQL builder or the execute path. Returns the
+ * blocking message, or null when the request stays legal. */
+function concurrentIndexBlockingWarning(): string | null {
+  // Non-concurrent-capable engines cannot express the request in SQL; the core
+  // builder ignores the flag, so there is no stale-concurrent hazard to block.
+  if (!structureCapabilities.value.indexConcurrent) return null;
+  const stale = indexes.value.find((index) => index.concurrently && !concurrentIndexAvailability(index).enabled);
+  return stale ? t("structureEditor.concurrentUnavailableBlocksSave") : null;
+}
+
+function canEditIndexConcurrent(index: EditableStructureIndex): boolean {
+  return concurrentIndexAvailability(index).enabled;
+}
+
+function concurrentIndexCellTitle(index: EditableStructureIndex): string {
+  switch (concurrentIndexAvailability(index).reason) {
+    case "existing":
+      return t("structureEditor.concurrentExistingIndexTooltip");
+    case "partitioned":
+      return t("structureEditor.concurrentPartitionedTooltip");
+    case "unknown":
+      return t("structureEditor.concurrentUnavailableTooltip");
+    default:
+      return t("structureEditor.concurrentTooltip");
+  }
+}
+
 function canEditIndexFilter(index: EditableStructureIndex): boolean {
   return canEditIndexDraft(index) && structureCapabilities.value.indexFilter;
 }
@@ -2571,6 +2744,14 @@ function toggleSqlPreviewCollapsed() {
 
 async function applyChanges() {
   if (!canApply.value || !props.connectionId || !props.database) return false;
+  // Layer B runtime guard: a stale `concurrently: true` whose availability is
+  // no longer enabled must never be executed — reject the save with an
+  // explicit error even if normalization was skipped (race / non-UI caller).
+  const blockingConcurrentWarning = concurrentIndexBlockingWarning() ?? (concurrentAvailabilityInvalidated.value ? t("structureEditor.concurrentUnavailableBlocksSave") : null);
+  if (blockingConcurrentWarning) {
+    errorMessage.value = blockingConcurrentWarning;
+    return false;
+  }
   const sql = previewSqlText.value;
   const connection = store.getConfig(props.connectionId);
   const productionContext = productionContextForDatabase(connection, props.database);
@@ -2587,6 +2768,27 @@ async function applyChanges() {
   saving.value = true;
   errorMessage.value = "";
   const refreshScope = captureStructureRefreshScope();
+  // Plan A guard: concurrent builds only run with a long-enough query timeout
+  // (a cancelled build leaves an INVALID index behind), and are blocked
+  // up-front when a same-name INVALID index already exists.
+  const hasConcurrentIndexBuild = pendingStatements.value.some((statement) => statement.includes("CONCURRENTLY"));
+  if (hasConcurrentIndexBuild && !isCreateMode.value && databaseType.value === "postgres" && props.tableName) {
+    const concurrentIndexNames = concurrentIndexNamesInStatements(pendingStatements.value);
+    if (concurrentIndexNames.length > 0) {
+      try {
+        const invalidIndexes = await api.listInvalidIndexes(props.connectionId, props.database, metadataSchema.value, props.tableName);
+        const blocked = concurrentIndexNames.filter((name) => invalidIndexes.includes(name));
+        if (blocked.length > 0) {
+          errorMessage.value = t("structureEditor.invalidIndexBlocksSave", { indexNames: blocked.join(", ") });
+          saving.value = false;
+          return false;
+        }
+      } catch {
+        // Metadata probe failure must not block the save; the failure-time
+        // hint below still surfaces leftovers if the build errors out.
+      }
+    }
+  }
   const characterLengthUnitsAfterSave = new Map<string, string>();
   if (supportsCharacterLengthUnits.value) {
     for (const column of columns.value) {
@@ -2596,10 +2798,15 @@ async function applyChanges() {
     }
   }
   const startedAt = Date.now();
+  // Concurrent batches get at least the dedicated 30-minute floor while
+  // preserving an unlimited setting (0) and any larger configured timeout;
+  // non-concurrent batches keep the configured timeout unchanged.
+  const configuredTimeoutSecs = queryTimeoutSecsForConnection(connection, settingsStore.editorSettings.globalQueryTimeoutSecs);
+  const executionTimeoutSecs = queryTimeoutSecsForConcurrentIndex(configuredTimeoutSecs, hasConcurrentIndexBuild);
   try {
     const result = hasSqliteTypeChange.value
       ? await api.applySqliteTableStructureChange(props.connectionId, props.database, structureChangeOptions(), sqliteSchemaRevision.value!)
-      : await api.executeBatch(props.connectionId, props.database, pendingStatements.value, props.schema, queryTimeoutSecsForConnection(connection, settingsStore.editorSettings.globalQueryTimeoutSecs));
+      : await api.executeBatch(props.connectionId, props.database, pendingStatements.value, props.schema, executionTimeoutSecs);
     await recordStructureHistory(sql, startedAt, true, result);
     if (!isCreateMode.value && props.tableName) {
       invalidateTableMetadataCache({ connectionId: props.connectionId, database: props.database, schema: metadataSchema.value, tableName: props.tableName });
@@ -2629,7 +2836,11 @@ async function applyChanges() {
     }
     return true;
   } catch (e: any) {
-    errorMessage.value = e?.message || String(e);
+    const rawMessage = e?.message || String(e);
+    // A cancelled/errored concurrent build leaves a same-name INVALID index
+    // behind; surface that so retries are not silently doomed.
+    const invalidIndexHint = hasConcurrentIndexBuild && /already exists/i.test(rawMessage) ? `\n\n${t("structureEditor.invalidIndexRetryHint")}` : "";
+    errorMessage.value = `${rawMessage}${invalidIndexHint}`;
     await recordStructureHistory(sql, startedAt, false, undefined, errorMessage.value);
     return false;
   } finally {
@@ -2816,6 +3027,14 @@ watch(tableMetadataCapabilities, (capabilities) => {
   if (!localIsStructureMetadataTabSupported(activeTab.value, capabilities)) activeTab.value = localFirstStructureMetadataTab(capabilities);
 });
 
+watch(structureCapabilities, () => {
+  // Capability loss (e.g. PostgreSQL < 11 without concurrent index support)
+  // invalidates any selected Concurrent flag the same way a probe failure
+  // does; the normalization is idempotent and no-ops while availability stays
+  // enabled.
+  normalizeConcurrentIndexDraftsForCurrentAvailability();
+});
+
 watch([() => props.initialTab, () => props.initialTabRequestId, () => props.initialTarget], () => {
   if (props.initialTab) applyInitialStructureTab();
   applyInitialStructureTarget();
@@ -3523,6 +3742,13 @@ watch([activeTab, ddlLoading], ([tab, loading]) => {
                   <td :class="structureCellClass">
                     <Input v-model="index.comment" :class="[structureControlClass, indexSearchFieldClass(index, index.comment)]" :disabled="!canEditIndexComment(index)" />
                   </td>
+                  <td :class="structureCellClass">
+                    <label v-if="structureCapabilities.indexConcurrent" class="flex items-center gap-1.5" :title="concurrentIndexCellTitle(index)">
+                      <input v-model="index.concurrently" type="checkbox" :class="structureCheckboxClass" :disabled="!canEditIndexConcurrent(index)" />
+                      <span>{{ index.concurrently ? t("structureEditor.yes") : t("structureEditor.no") }}</span>
+                    </label>
+                    <span v-else class="text-[length:var(--structure-font-size)] text-muted-foreground">—</span>
+                  </td>
                   <td :class="structureLastCellClass">
                     <Badge v-if="index.isPrimary" variant="outline">{{ t("structureEditor.primary") }}</Badge>
                     <Button v-else-if="index.original" variant="ghost" size="sm" :class="structureToolbarButtonClass" :disabled="!canDropIndex(index)" @click="toggleDropIndex(index)">
diff --git a/apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrent.spec.ts b/apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrent.spec.ts
new file mode 100644
index 0000000000..40d87945b2
--- /dev/null
+++ b/apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrent.spec.ts
@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import { getConcurrentIndexAvailability, concurrentIndexNamesInStatements, normalizeUnsupportedConcurrentIndexes } from "@/lib/table/concurrentIndexAvailability";
+
+describe("getConcurrentIndexAvailability (Plan A scope guards)", () => {
+  const base = {
+    hasOriginal: false,
+    isPrimary: false,
+    markedForDrop: false,
+    isPartitionedParent: false,
+    partitionStatusKnown: true,
+    supportsIndexConcurrent: true,
+    supportsCreateIndex: true,
+  };
+
+  it("enables Concurrent for a new index on a normal non-partitioned PostgreSQL table", () => {
+    expect(getConcurrentIndexAvailability(base)).toEqual({ enabled: true });
+  });
+
+  it("disables Concurrent when editing an existing index", () => {
+    expect(getConcurrentIndexAvailability({ ...base, hasOriginal: true })).toEqual({
+      enabled: false,
+      reason: "existing",
+    });
+  });
+
+  it("disables Concurrent on a partitioned parent table", () => {
+    expect(getConcurrentIndexAvailability({ ...base, isPartitionedParent: true })).toEqual({
+      enabled: false,
+      reason: "partitioned",
+    });
+  });
+
+  it("fails closed when the partition status could not be verified", () => {
+    expect(getConcurrentIndexAvailability({ ...base, partitionStatusKnown: false })).toEqual({
+      enabled: false,
+      reason: "unknown",
+    });
+  });
+
+  it("disables Concurrent for primary indexes and drop-marked rows", () => {
+    expect(getConcurrentIndexAvailability({ ...base, isPrimary: true })).toEqual({
+      enabled: false,
+      reason: "primary",
+    });
+    expect(getConcurrentIndexAvailability({ ...base, markedForDrop: true })).toEqual({
+      enabled: false,
+      reason: "markedForDrop",
+    });
+  });
+
+  it("disables Concurrent when the engine does not advertise the capability (non-PostgreSQL)", () => {
+    expect(getConcurrentIndexAvailability({ ...base, supportsIndexConcurrent: false })).toEqual({
+      enabled: false,
+      reason: "unsupported",
+    });
+    expect(getConcurrentIndexAvailability({ ...base, supportsCreateIndex: false })).toEqual({
+      enabled: false,
+      reason: "unsupported",
+    });
+  });
+});
+
+describe("concurrentIndexNamesInStatements", () => {
+  it("extracts unquoted names from CREATE [UNIQUE] INDEX CONCURRENTLY statements", () => {
+    expect(
+      concurrentIndexNamesInStatements([
+        'CREATE INDEX CONCURRENTLY "idx_users_email" ON "public"."users" ("email");',
+        'CREATE UNIQUE INDEX CONCURRENTLY "uniq_users_name" ON "public"."users" ("name");',
+        'CREATE INDEX "plain_idx" ON "public"."users" ("id");',
+        'CREATE INDEX CONCURRENTLY "orders"."idx_orders_id" ON "orders"."orders" ("id");',
+      ]),
+    ).toEqual(["idx_users_email", "uniq_users_name", "idx_orders_id"]);
+  });
+
+  it("returns an empty list when no concurrent statements are present", () => {
+    expect(concurrentIndexNamesInStatements([])).toEqual([]);
+    expect(concurrentIndexNamesInStatements(['CREATE INDEX "idx" ON "public"."t" ("c");'])).toEqual([]);
+  });
+});
+
+describe("normalizeUnsupportedConcurrentIndexes", () => {
+  const enabled = () => ({ enabled: true });
+  const unavailable = (reason: string) => ({ enabled: false, reason });
+
+  it("keeps Concurrent on drafts whose availability is enabled", () => {
+    const indexes = [
+      { id: "a", concurrently: true },
+      { id: "b", concurrently: false },
+    ];
+    expect(normalizeUnsupportedConcurrentIndexes(indexes, enabled)).toEqual({ indexes, invalidatedIds: [] });
+  });
+
+  it("preserves transiently unavailable intent while clearing definitively unsupported flags", () => {
+    const indexes = [
+      { id: "a", concurrently: true },
+      { id: "b", concurrently: true },
+      { id: "c", concurrently: false },
+    ];
+    const result = normalizeUnsupportedConcurrentIndexes(indexes, (index) => (index.id === "a" ? unavailable("existing") : unavailable("unknown")));
+    expect(result.indexes).toEqual([
+      { id: "a", concurrently: false },
+      { id: "b", concurrently: true },
+      { id: "c", concurrently: false },
+    ]);
+    expect(result.invalidatedIds).toEqual(["a", "b"]);
+  });
+
+  it("clears Concurrent when the table is confirmed partitioned", () => {
+    const indexes = [{ id: "a", concurrently: true }];
+    const result = normalizeUnsupportedConcurrentIndexes(indexes, () => unavailable("partitioned"));
+    expect(result.indexes).toEqual([{ id: "a", concurrently: false }]);
+    expect(result.invalidatedIds).toEqual(["a"]);
+  });
+});
diff --git a/apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrentTransition.spec.ts b/apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrentTransition.spec.ts
new file mode 100644
index 0000000000..03f5a83506
--- /dev/null
+++ b/apps/desktop/src/components/structure/__tests__/TableStructureEditor.concurrentTransition.spec.ts
@@ -0,0 +1,378 @@
+// @vitest-environment happy-dom
+
+import { createApp, nextTick, type App } from "vue";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  connection: {
+    id: "structure-concurrent-transition",
+    name: "PostgreSQL",
+    db_type: "postgres",
+    driver_label: "PostgreSQL",
+  },
+  ensureConnected: vi.fn(),
+  listDataTypes: vi.fn(),
+  buildTableStructureChangeSql: vi.fn(),
+  updateEditorSettings: vi.fn(),
+  loadObjectDdl: vi.fn(),
+  invalidateObjectDdl: vi.fn(),
+  loadObjectMetadataFacet: vi.fn(),
+  invalidateTableMetadataCache: vi.fn(),
+  getTablePartitionStatus: vi.fn(),
+  toast: vi.fn(),
+}));
+
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+
+vi.mock("@lucide/vue", async () => {
+  const { defineComponent, h } = await import("vue");
+  const Icon = defineComponent({ name: "Icon", setup: () => () => h("span") });
+  return {
+    AlertTriangle: Icon,
+    Check: Icon,
+    ChevronDown: Icon,
+    ChevronUp: Icon,
+    Copy: Icon,
+    Database: Icon,
+    Info: Icon,
+    KeyRound: Icon,
+    ListChevronsUpDown: Icon,
+    Loader2: Icon,
+    Maximize2: Icon,
+    Plus: Icon,
+    RefreshCw: Icon,
+    Save: Icon,
+    Search: Icon,
+    Settings: Icon,
+    SlidersHorizontal: Icon,
+    Trash2: Icon,
+    X: Icon,
+  };
+});
+
+vi.mock("@/components/ui/button", async () => {
+  const { defineComponent, h } = await import("vue");
+  return {
+    Button: defineComponent({
+      name: "Button",
+      inheritAttrs: false,
+      setup:
+        (_props, { attrs, slots }) =>
+        () =>
+          h("button", attrs, slots.default?.()),
+    }),
+  };
+});
+vi.mock("@/components/ui/input", async () => {
+  const { defineComponent, h } = await import("vue");
+  return {
+    Input: defineComponent({
+      name: "Input",
+      inheritAttrs: false,
+      props: { modelValue: { type: [String, Number], default: "" } },
+      emits: ["update:modelValue"],
+      setup:
+        (props, { attrs, emit }) =>
+        () =>
+          h("input", {
+            ...attrs,
+            value: props.modelValue,
+            onInput: (event: Event) => emit("update:modelValue", (event.target as HTMLInputElement).value),
+          }),
+    }),
+  };
+});
+vi.mock("@/components/ui/badge", async () => {
+  const { defineComponent, h } = await import("vue");
+  return {
+    Badge: defineComponent({
+      name: "Badge",
+      inheritAttrs: false,
+      setup:
+        (_props, { attrs, slots }) =>
+        () =>
+          h("span", attrs, slots.default?.()),
+    }),
+  };
+});
+// Tabs mock that wires TabsTrigger clicks through `v-model` (the real tabs
+// component does this internally via context; the primaryKey spec mock renders
+// every tab pane unconditionally, which we keep so draft rows stay queryable
+// regardless of the active tab).
+vi.mock("@/components/ui/tabs", async () => {
+  const { defineComponent, h, inject, provide } = await import("vue");
+  const TabsKey = Symbol("tabs:model");
+  const Div = defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_props, { attrs, slots }) =>
+      () =>
+        h("div", attrs, slots.default?.()),
+  });
+  const Tabs = defineComponent({
+    name: "MockTabs",
+    inheritAttrs: false,
+    props: { modelValue: { type: String, default: "" } },
+    emits: ["update:modelValue"],
+    setup: (_props, { attrs, slots, emit }) => {
+      provide(TabsKey, (value: string) => emit("update:modelValue", value));
+      return () => h("div", attrs, slots.default?.());
+    },
+  });
+  const TabsTrigger = defineComponent({
+    name: "MockTabsTrigger",
+    inheritAttrs: false,
+    props: { value: { type: String, required: true } },
+    setup: (props, { attrs, slots }) => {
+      const select = inject<(value: string) => void>(TabsKey, () => {});
+      return () => h("button", { ...attrs, type: "button", onClick: () => select(props.value) }, slots.default?.());
+    },
+  });
+  return { Tabs, TabsContent: Div, TabsList: Div, TabsTrigger };
+});
+vi.mock("@/components/ui/dropdown-menu", async () => {
+  const { defineComponent, h } = await import("vue");
+  const Div = defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_props, { attrs, slots }) =>
+      () =>
+        h("div", attrs, slots.default?.()),
+  });
+  const Button = defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_props, { attrs, slots }) =>
+      () =>
+        h("button", attrs, slots.default?.()),
+  });
+  return { DropdownMenu: Div, DropdownMenuCheckboxItem: Div, DropdownMenuContent: Div, DropdownMenuItem: Button, DropdownMenuTrigger: Div };
+});
+vi.mock("@/components/ui/popover", async () => {
+  const { defineComponent, h } = await import("vue");
+  const Div = defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_props, { attrs, slots }) =>
+      () =>
+        h("div", attrs, slots.default?.()),
+  });
+  return { Popover: Div, PopoverContent: Div, PopoverTrigger: Div };
+});
+vi.mock("@/components/ui/tooltip", async () => {
+  const { defineComponent, h } = await import("vue");
+  const Div = defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_props, { attrs, slots }) =>
+      () =>
+        h("div", attrs, slots.default?.()),
+  });
+  return { Tooltip: Div, TooltipContent: Div, TooltipTrigger: Div };
+});
+vi.mock("@/components/ui/searchable-select", async () => {
+  const { defineComponent, h } = await import("vue");
+  return {
+    SearchableSelect: defineComponent({
+      name: "SearchableSelect",
+      inheritAttrs: false,
+      props: {
+        modelValue: { type: String, default: "" },
+        options: { type: Array, default: () => [] },
+        allowCustom: { type: Boolean, default: false },
+      },
+      emits: ["update:modelValue"],
+      setup:
+        (props, { attrs, emit }) =>
+        () =>
+          h("button", {
+            ...attrs,
+            type: "button",
+            "data-searchable-select": "true",
+            "data-model-value": props.modelValue,
+            "data-options": JSON.stringify(props.options),
+            "data-allow-custom": String(props.allowCustom),
+            onClick: () => emit("update:modelValue", "custom_domain"),
+          }),
+    }),
+  };
+});
+vi.mock("@/components/ui/select", async () => {
+  const { defineComponent, h } = await import("vue");
+  const Div = defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_props, { attrs, slots }) =>
+      () =>
+        h("div", attrs, slots.default?.()),
+  });
+  return { Select: Div, SelectContent: Div, SelectItem: Div, SelectTrigger: Div, SelectValue: Div };
+});
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    ensureConnected: mocks.ensureConnected,
+    getConfig: (connectionId: string) => (connectionId === mocks.connection.id ? mocks.connection : undefined),
+  }),
+}));
+vi.mock("@/stores/productionSafetyStore", () => ({ useProductionSafetyStore: () => ({ requestConfirmation: vi.fn() }) }));
+vi.mock("@/stores/queryStore", () => ({ useQueryStore: () => ({ tableStructureRefreshVersion: () => 0 }) }));
+vi.mock("@/stores/historyStore", () => ({ useHistoryStore: () => ({ add: vi.fn() }) }));
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings: { structureEditorDensity: "compact", sqlFormatter: {}, tableColumnTemplateFields: [] },
+    updateEditorSettings: mocks.updateEditorSettings,
+  }),
+}));
+vi.mock("@/composables/useTheme", () => ({ useTheme: () => ({ isDark: { value: false } }) }));
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
+vi.mock("@/lib/sql/sqlHighlighter", () => ({ createShikiSqlHighlighter: vi.fn(async () => (sql: string) => sql) }));
+vi.mock("@/lib/metadata/objectDdlCache", () => ({
+  loadObjectDdl: mocks.loadObjectDdl,
+  invalidateObjectDdl: mocks.invalidateObjectDdl,
+}));
+vi.mock("@/lib/metadata/objectMetadataCache", () => ({ loadObjectMetadataFacet: mocks.loadObjectMetadataFacet }));
+vi.mock("@/lib/metadata/tableMetadataCache", () => ({ invalidateTableMetadataCache: mocks.invalidateTableMetadataCache }));
+vi.mock("@/lib/backend/api", () => ({
+  listDataTypes: mocks.listDataTypes,
+  buildTableStructureChangeSql: mocks.buildTableStructureChangeSql,
+  getTablePartitionStatus: mocks.getTablePartitionStatus,
+}));
+
+import TableStructureEditor from "@/components/structure/TableStructureEditor.vue";
+
+const mountedApps: App[] = [];
+
+async function mountIndexesEditor() {
+  mocks.connection.db_type = "postgres";
+  mocks.connection.name = "postgres";
+  mocks.connection.driver_label = "postgres";
+  mocks.ensureConnected.mockResolvedValue(undefined);
+  mocks.listDataTypes.mockResolvedValue([]);
+  mocks.getTablePartitionStatus.mockResolvedValue({ isPartitionedParent: false, isPartition: false });
+  mocks.loadObjectDdl.mockResolvedValue({ ddl: "CREATE TABLE users (id bigint)", cacheStatus: "remote" });
+  mocks.loadObjectMetadataFacet.mockImplementation(async (_request, facet: string) => ({
+    value: facet === "comment" ? "" : [],
+    cacheStatus: "remote",
+  }));
+  // The SQL builder mirrors the Concurrent checkbox onto the generated
+  // statement so the enabled phase of the regression is visibly concurrent.
+  mocks.buildTableStructureChangeSql.mockImplementation((options: { indexes?: Array<{ name: string; concurrently?: boolean }> }) => {
+    const newIndex = options.indexes?.[0];
+    const statements = newIndex ? [`${newIndex.concurrently ? "CREATE INDEX CONCURRENTLY" : "CREATE INDEX"} "${newIndex.name || "idx_users_email"}" ON "public"."users" ("email");`] : [];
+    return Promise.resolve({ statements, warnings: [] });
+  });
+
+  const root = document.createElement("div");
+  document.body.append(root);
+  const app = createApp(TableStructureEditor, {
+    connectionId: mocks.connection.id,
+    database: "test",
+    schema: "public",
+    tableName: "users",
+    initialTab: "indexes",
+  });
+  mountedApps.push(app);
+  app.mount(root);
+  await nextTick();
+  await Promise.resolve();
+  await nextTick();
+  return root;
+}
+
+function buttonWithText(root: HTMLElement, text: string): HTMLButtonElement {
+  const button = Array.from(root.querySelectorAll("button")).find((item) => item.textContent?.includes(text));
+  if (!button) throw new Error(`Missing ${text} button`);
+  return button as HTMLButtonElement;
+}
+
+/** The Concurrent checkbox inside the given index row (identified by the
+ * tooltip the cell label carries: concurrentTooltip / ...ExistingIndex /
+ * ...Partitioned / ...Unavailable). */
+function concurrentCheckboxInRow(row: HTMLElement): HTMLInputElement {
+  const input = Array.from(row.querySelectorAll<HTMLInputElement>('label[title*="concurrent"] input[type="checkbox"]'))[0];
+  if (!input) throw new Error("Missing Concurrent checkbox in index row");
+  return input;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.getTablePartitionStatus.mockResolvedValue({ isPartitionedParent: false, isPartition: false });
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  for (const app of mountedApps.splice(0)) app.unmount();
+  document.body.innerHTML = "";
+});
+
+describe("TableStructureEditor concurrent availability transition", () => {
+  it("preserves Concurrent intent across a failed partition probe and restores its SQL after recovery", async () => {
+    const root = await mountIndexesEditor();
+
+    // Enabled phase: new index can select Concurrent and the preview builds
+    // a CREATE INDEX CONCURRENTLY statement.
+    await vi.waitFor(() => expect(buttonWithText(root, "structureEditor.addIndex").disabled).toBe(false), { timeout: 3000 });
+    buttonWithText(root, "structureEditor.addIndex").click();
+    await nextTick();
+    await vi.waitFor(
+      () => {
+        const row = root.querySelector<HTMLElement>('[data-new-index-row="true"]');
+        expect(row).not.toBeNull();
+      },
+      { timeout: 3000 },
+    );
+    const row = root.querySelector<HTMLElement>('[data-new-index-row="true"]')!;
+    const concurrent = concurrentCheckboxInRow(row);
+    expect(concurrent.disabled).toBe(false);
+    expect(concurrent.checked).toBe(false);
+
+    concurrent.checked = true;
+    concurrent.dispatchEvent(new Event("change", { bubbles: true }));
+    await vi.waitFor(() => expect(mocks.buildTableStructureChangeSql.mock.calls.at(-1)?.[0]?.indexes?.[0]?.concurrently).toBe(true), { timeout: 3000 });
+    await vi.waitFor(() => expect(root.textContent).toContain('CREATE INDEX CONCURRENTLY "idx_users_email" ON "public"."users" ("email");'), { timeout: 3000 });
+    expect(buttonWithText(root, "structureEditor.apply").disabled).toBe(false);
+    const callsAtEnabledPhase = mocks.buildTableStructureChangeSql.mock.calls.length;
+
+    // Transition: the very next partition-status probe fails. A reload that
+    // re-runs the probe (here: switching to a tab with an unloaded metadata
+    // facet) must keep the draft index but treat Concurrent as unavailable.
+    mocks.getTablePartitionStatus.mockRejectedValue(new Error("partition probe unavailable"));
+    await vi.waitFor(() => expect(buttonWithText(root, "structureEditor.triggers")).toBeTruthy(), { timeout: 3000 });
+    buttonWithText(root, "structureEditor.triggers").click();
+    await vi.waitFor(() => expect(mocks.getTablePartitionStatus).toHaveBeenCalledTimes(2), { timeout: 3000 });
+
+    // Fail closed while preserving the user's transiently unavailable intent:
+    // no SQL reaches the builder, the checkbox is disabled, and Save stays blocked.
+    await vi.waitFor(() => expect(root.textContent).toContain("structureEditor.concurrentUnavailableBlocksSave"), { timeout: 3000 });
+    const unavailableRow = root.querySelector<HTMLElement>('[data-new-index-row="true"]');
+    expect(unavailableRow).not.toBeNull();
+    const unavailableConcurrent = concurrentCheckboxInRow(unavailableRow!);
+    expect(unavailableConcurrent.checked).toBe(true);
+    expect(unavailableConcurrent.disabled).toBe(true);
+
+    // Neither the stale concurrent request nor a silent blocking downgrade may
+    // reach the SQL builder or the preview after the transition.
+    expect(buttonWithText(root, "structureEditor.apply").disabled).toBe(true);
+    await vi.waitFor(() => expect(mocks.buildTableStructureChangeSql.mock.calls.length).toBe(callsAtEnabledPhase), { timeout: 3000 });
+    expect(root.textContent).not.toContain("CREATE INDEX CONCURRENTLY");
+    expect(root.textContent).not.toContain('CREATE INDEX "idx_users_email"');
+
+    // Recovery: a later successful probe must lift the blocker and regenerate
+    // the preview with the original Concurrent intent, never a blocking CREATE.
+    mocks.getTablePartitionStatus.mockResolvedValue({ isPartitionedParent: false, isPartition: false });
+    buttonWithText(root, "structureEditor.refresh").click();
+    await vi.waitFor(() => expect(mocks.getTablePartitionStatus).toHaveBeenCalledTimes(3), { timeout: 3000 });
+    await vi.waitFor(() => expect(mocks.buildTableStructureChangeSql.mock.calls.length).toBeGreaterThan(callsAtEnabledPhase), { timeout: 3000 });
+
+    const recoveredRow = root.querySelector<HTMLElement>('[data-new-index-row="true"]');
+    expect(recoveredRow).not.toBeNull();
+    const recoveredConcurrent = concurrentCheckboxInRow(recoveredRow!);
+    expect(recoveredConcurrent.checked).toBe(true);
+    expect(recoveredConcurrent.disabled).toBe(false);
+    expect(mocks.buildTableStructureChangeSql.mock.calls.at(-1)?.[0]?.indexes?.[0]?.concurrently).toBe(true);
+    await vi.waitFor(() => expect(root.textContent).toContain('CREATE INDEX CONCURRENTLY "idx_users_email" ON "public"."users" ("email");'), { timeout: 3000 });
+    expect(root.textContent).not.toContain('CREATE INDEX "idx_users_email"');
+    expect(buttonWithText(root, "structureEditor.apply").disabled).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index c1bb657435..90e5a11e98 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -3622,6 +3622,15 @@ export default {
     includedColumns: "Included",
     includedColumnsPlaceholder: "Select columns...",
     filter: "Filter",
+    concurrent: "Concurrent",
+    concurrentTooltip: "Build the index concurrently to avoid blocking writes. This usually takes longer and cannot run inside a transaction block.",
+    concurrentExistingIndexTooltip: "Available only for new indexes. Rebuilding an existing index concurrently (DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY) is not supported yet.",
+    concurrentPartitionedTooltip: "Not available on partitioned parent tables. PostgreSQL rejects concurrent index creation on partitioned parents; build child indexes concurrently and attach them instead.",
+    invalidIndexBlocksSave: 'Save blocked: an INVALID index (left behind by a cancelled concurrent build) already exists with the same name: {indexNames}. Drop it first (e.g. DROP INDEX "schema"."name"), then retry.',
+    concurrentUnavailableTooltip: "Unavailable while the table\u2019s partition status cannot be verified. Concurrent creation is only offered on non-partitioned tables.",
+    concurrentUnavailableBlocksSave:
+      "Concurrent index creation is no longer available (the table's partition status could not be verified). The selected Concurrent option was cleared and this change is blocked until the table is re-verified. Refresh to retry, or remove the index to continue with other changes.",
+    invalidIndexRetryHint: "This may be caused by a same-name INVALID index left behind by a previously cancelled concurrent build. Drop that index first, then retry.",
     foreignKeyName: "Foreign key",
     referencedSchema: "Ref schema",
     referencedTable: "Ref table",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 6944421b25..306b223231 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -3458,6 +3458,15 @@ export default withEnglishFallback({
     includedColumns: "Incluidas",
     includedColumnsPlaceholder: "Seleccionar columnas...",
     filter: "Filtro",
+    concurrent: "Concurrente",
+    concurrentTooltip: "Crea el índice de forma concurrente para evitar bloquear escrituras. Suele tardar más y no puede ejecutarse dentro de un bloque de transacción.",
+    concurrentExistingIndexTooltip: "Solo disponible para índices nuevos. Aún no se admite reconstruir un índice existente de forma concurrente (DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY).",
+    concurrentPartitionedTooltip: "No disponible en tablas padre particionadas. PostgreSQL rechaza la creación concurrente de índices en tablas padre particionadas; cree los índices hijos de forma concurrente y adjúntelos.",
+    invalidIndexBlocksSave: 'Guardado bloqueado: ya existe un índice INVALID con el mismo nombre (residuo de una construcción concurrente cancelada): {indexNames}. Elimínelo primero (p. ej. DROP INDEX "schema"."name") y vuelva a intentarlo.',
+    concurrentUnavailableTooltip: "No disponible mientras no se pueda verificar el estado de partición de la tabla. La creación concurrente solo se ofrece en tablas no particionadas.",
+    concurrentUnavailableBlocksSave:
+      "La creación concurrente de índices ya no está disponible (no se pudo verificar el estado de partición de la tabla). Se canceló la opción Concurrente seleccionada y este cambio está bloqueado hasta que la tabla se vuelva a verificar. Actualice para reintentar o elimine el índice para continuar con otros cambios.",
+    invalidIndexRetryHint: "Esto puede deberse a un índice INVALID con el mismo nombre que dejó una construcción concurrente cancelada anteriormente. Elimine ese índice primero y vuelva a intentarlo.",
     foreignKeyName: "Clave foránea",
     referencedSchema: "Esquema ref",
     referencedTable: "Tabla ref",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 205b4a8900..08b06b0c30 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -3456,6 +3456,15 @@ export default withEnglishFallback({
     includedColumns: "Incluse",
     includedColumnsPlaceholder: "Seleziona colonne...",
     filter: "Filtro",
+    concurrent: "Concorrente",
+    concurrentTooltip: "Crea l'indice in modo concorrente per evitare di bloccare le scritture. Di solito richiede più tempo e non può essere eseguito all'interno di un blocco di transazione.",
+    concurrentExistingIndexTooltip: "Disponibile solo per nuovi indici. La ricostruzione concorrente di un indice esistente (DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY) non è ancora supportata.",
+    concurrentPartitionedTooltip: "Non disponibile sulle tabelle padre partizionate. PostgreSQL rifiuta la creazione concorrente di indici sulle tabelle padre partizionate; crea gli indici figli in modo concorrente e collegalili.",
+    invalidIndexBlocksSave: 'Salvataggio bloccato: esiste già un indice INVALID con lo stesso nome (residuo di una build concorrente annullata): {indexNames}. Eliminalo prima (es. DROP INDEX "schema"."name"), poi riprova.',
+    concurrentUnavailableTooltip: "Non disponibile finché non è possibile verificare lo stato di partizione della tabella. La creazione concorrente è disponibile solo su tabelle non partizionate.",
+    concurrentUnavailableBlocksSave:
+      "La creazione concorrente dell'indice non è più disponibile (lo stato di partizione della tabella non può essere verificato). L'opzione Concurrente selezionata è stata annullata e questa modifica è bloccata finché la tabella non viene riverificata. Aggiorna per riprovare o rimuovi l'indice per continuare con altre modifiche.",
+    invalidIndexRetryHint: "Potrebbe essere causato da un indice INVALID con lo stesso nome lasciato da una build concorrente annullata in precedenza. Elimina prima quell'indice, poi riprova.",
     foreignKeyName: "Chiave esterna",
     referencedSchema: "Schema rif.",
     referencedTable: "Tabella rif.",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index ce06695cf9..fa4f404008 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -3517,6 +3517,15 @@ export default withEnglishFallback({
     includedColumns: "付加列",
     includedColumnsPlaceholder: "列を選択...",
     filter: "フィルター",
+    concurrent: "同時実行",
+    concurrentTooltip: "書き込みのブロックを避けるためにインデックスを同時実行で作成します。通常は時間がかかり、トランザクションブロック内では実行できません。",
+    concurrentExistingIndexTooltip: "新規インデックスのみ利用可能です。既存インデックスの同時再構築（DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY）には未対応です。",
+    concurrentPartitionedTooltip: "パーティション親テーブルでは利用できません。PostgreSQL はパーティション親テーブルへの同時インデックス作成を拒否します。子インデックスを同時作成してアタッチしてください。",
+    invalidIndexBlocksSave: '保存がブロックされました: 同じ名前の INVALID インデックス（キャンセルされた同時ビルドの残骸）がすでに存在します: {indexNames}。先に削除（例: DROP INDEX "schema"."name"）してから再試行してください。',
+    concurrentUnavailableTooltip: "テーブルのパーティション状態を確認できない間は利用できません。並行作成は非パーティションのテーブルでのみ提供されます。",
+    concurrentUnavailableBlocksSave:
+      "インデックスの並行作成は利用できなくなりました（テーブルのパーティション状態を確認できません）。選択した「並行」オプションは解除され、テーブルが再確認されるまでこの変更はブロックされます。再試行するには更新、または他の変更を続けるにはインデックスを削除してください。",
+    invalidIndexRetryHint: "以前にキャンセルされた同時ビルドが残した同名の INVALID インデックスが原因の可能性があります。そのインデックスを削除してから再試行してください。",
     foreignKeyName: "外部キー",
     referencedSchema: "参照スキーマ",
     referencedTable: "参照テーブル",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index 4cf15666d8..81fae18809 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -3440,6 +3440,14 @@ export default withEnglishFallback({
     includedColumns: "포함",
     includedColumnsPlaceholder: "컬럼 선택...",
     filter: "필터",
+    concurrent: "동시 생성",
+    concurrentTooltip: "쓰기 차단을 피하기 위해 인덱스를 동시에 생성합니다. 일반적으로 더 오래 걸리며 트랜잭션 블록 내에서 실행할 수 없습니다.",
+    concurrentExistingIndexTooltip: "새 인덱스에서만 사용할 수 있습니다. 기존 인덱스의 동시 재구축(DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY)은 아직 지원되지 않습니다.",
+    concurrentPartitionedTooltip: "파티션 부모 테이블에서는 사용할 수 없습니다. PostgreSQL은 파티션 부모 테이블에서의 동시 인덱스 생성을 거부합니다. 하위 인덱스를 동시에 생성한 후 연결하세요.",
+    invalidIndexBlocksSave: '저장이 차단되었습니다: 취소된 동시 빌드가 남긴 같은 이름의 INVALID 인덱스가 이미 존재합니다: {indexNames}. 먼저 삭제(예: DROP INDEX "schema"."name")한 후 다시 시도하세요.',
+    concurrentUnavailableTooltip: "테이블의 파티션 상태를 확인할 수 없는 동안에는 사용할 수 없습니다. 동시 생성은 파티션이 아닌 테이블에서만 제공됩니다.",
+    concurrentUnavailableBlocksSave: "인덱스 동시 생성은 더 이상 사용할 수 없습니다(테이블의 파티션 상태를 확인할 수 없습니다). 선택한 동시 옵션이 해제되었으며 테이블이 다시 확인될 때까지 이 변경은 차단됩니다. 다시 시도하려면 새로 고치거나 다른 변경을 계속하려면 인덱스를 제거하세요.",
+    invalidIndexRetryHint: "이전에 취소된 동시 빌드가 남긴 같은 이름의 INVALID 인덱스 때문일 수 있습니다. 해당 인덱스를 먼저 삭제한 후 다시 시도하세요.",
     foreignKeyName: "외래 키",
     referencedSchema: "참조 스키마",
     referencedTable: "참조 테이블",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index ee7aabded1..037f06761a 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -3458,6 +3458,15 @@ export default withEnglishFallback({
     includedColumns: "Incluídas",
     includedColumnsPlaceholder: "Selecione as colunas...",
     filter: "Filtro",
+    concurrent: "Concorrente",
+    concurrentTooltip: "Cria o índice de forma concorrente para evitar bloquear gravações. Geralmente leva mais tempo e não pode ser executado dentro de um bloco de transação.",
+    concurrentExistingIndexTooltip: "Disponível apenas para novos índices. Reconstruir um índice existente de forma concorrente (DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY) ainda não é suportado.",
+    concurrentPartitionedTooltip: "Não disponível em tabelas pai particionadas. O PostgreSQL rejeita a criação concorrente de índices em tabelas pai particionadas; crie os índices filhos de forma concorrente e anexe-os.",
+    invalidIndexBlocksSave: 'Salvamento bloqueado: já existe um índice INVALID com o mesmo nome (resíduo de uma construção concorrente cancelada): {indexNames}. Remova-o primeiro (ex.: DROP INDEX "schema"."name") e tente novamente.',
+    concurrentUnavailableTooltip: "Indisponível enquanto o status de partição da tabela não puder ser verificado. A criação concorrente só é oferecida em tabelas não particionadas.",
+    concurrentUnavailableBlocksSave:
+      "A criação concorrente do índice não está mais disponível (o status de partição da tabela não pôde ser verificado). A opção Concorrente selecionada foi cancelada e esta alteração fica bloqueada até que a tabela seja reverificada. Atualize para tentar novamente ou remova o índice para continuar com outras alterações.",
+    invalidIndexRetryHint: "Isso pode ser causado por um índice INVALID com o mesmo nome deixado por uma construção concorrente cancelada anteriormente. Remova esse índice primeiro e tente novamente.",
     foreignKeyName: "Chave estrangeira",
     referencedSchema: "Schema ref.",
     referencedTable: "Tabela ref.",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 261e1a0847..9d845bbd94 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -3610,6 +3610,14 @@ export default withEnglishFallback({
     includedColumns: "包含列",
     includedColumnsPlaceholder: "选择列...",
     filter: "过滤条件",
+    concurrent: "并发创建",
+    concurrentTooltip: "并发创建索引，避免阻塞写入。构建通常更慢，且不能在事务块内执行。",
+    concurrentExistingIndexTooltip: "仅可用于新建索引。尚不支持并发重建已有索引（DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY）。",
+    concurrentPartitionedTooltip: "分区父表不可用。PostgreSQL 拒绝在分区父表上并发建索引；请改为并发构建子索引后 attach。",
+    invalidIndexBlocksSave: '保存已阻止：存在同名 INVALID 索引（通常由被取消的并发构建残留）：{indexNames}。请先删除该索引（例如 DROP INDEX "schema"."name"）后再重试。',
+    concurrentUnavailableTooltip: "在无法确认表的分区状态前不可用。仅非分区表支持并发创建索引。",
+    concurrentUnavailableBlocksSave: "并发创建索引已不可用（无法确认表的分区状态）。已清除选中的“并发”选项，在重新确认表状态前将阻止保存。点击刷新重试，或移除该索引后继续保存其他改动。",
+    invalidIndexRetryHint: "这可能是之前被取消的并发构建残留的同名 INVALID 索引导致。请先删除该索引，再重试。",
     foreignKeyName: "外键名",
     referencedSchema: "引用库",
     referencedTable: "引用表",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 508a9293ca..b7e6d3287f 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -3214,6 +3214,14 @@ export default withEnglishFallback({
     includedColumns: "包含",
     includedColumnsPlaceholder: "選擇欄位……",
     filter: "過濾條件",
+    concurrent: "並行建立",
+    concurrentTooltip: "並行建立索引以避免封鎖寫入。通常需要更長時間，且無法在交易區塊內執行。",
+    concurrentExistingIndexTooltip: "僅可用於新建索引。尚不支援並行重建既有索引（DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY）。",
+    concurrentPartitionedTooltip: "分割父資料表不可用。PostgreSQL 拒絕在分割父資料表上並行建立索引；請改為並行建立子索引後再 attach。",
+    invalidIndexBlocksSave: '儲存已封鎖：已存在同名的 INVALID 索引（通常由已取消的並行建置殘留）：{indexNames}。請先刪除該索引（例如 DROP INDEX "schema"."name"）後再重試。',
+    concurrentUnavailableTooltip: "在無法確認資料表的分割狀態前不可用。僅非分割資料表支援並行建立索引。",
+    concurrentUnavailableBlocksSave: "並行建立索引已不可用（無法確認資料表的分割狀態）。已清除選取的「並行」選項，在重新確認資料表狀態前將阻止儲存。按一下重新整理重試，或移除該索引後繼續儲存其他變更。",
+    invalidIndexRetryHint: "這可能是先前被取消的並行建置殘留的同名 INVALID 索引所致。請先刪除該索引，再重試。",
     foreignKeyName: "外鍵名稱",
     referencedSchema: "引用資料庫",
     referencedTable: "引用資料表",
diff --git a/apps/desktop/src/lib/__tests__/sql/queryTimeout.spec.ts b/apps/desktop/src/lib/__tests__/sql/queryTimeout.spec.ts
index 0eb33dac14..312fa73e1b 100644
--- a/apps/desktop/src/lib/__tests__/sql/queryTimeout.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sql/queryTimeout.spec.ts
@@ -1,7 +1,24 @@
 import { describe, expect, it } from "vitest";
-import { frontendQueryTimeoutDelayMs, frontendQueryTimeoutSecsForSql, queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
+import { CONCURRENT_INDEX_QUERY_TIMEOUT_SECS, frontendQueryTimeoutDelayMs, frontendQueryTimeoutSecsForSql, queryTimeoutSecsForConcurrentIndex, queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
 
 describe("queryTimeout", () => {
+  it("gives CREATE INDEX CONCURRENTLY a dedicated long budget instead of the 30s default", () => {
+    expect(CONCURRENT_INDEX_QUERY_TIMEOUT_SECS).toBe(1800);
+    expect(CONCURRENT_INDEX_QUERY_TIMEOUT_SECS).toBeGreaterThan(30);
+    expect(frontendQueryTimeoutDelayMs(CONCURRENT_INDEX_QUERY_TIMEOUT_SECS)).toBe(1_800_000);
+  });
+
+  it.each([
+    ["non-concurrent", 30, false, 30],
+    ["non-concurrent", 3600, false, 3600],
+    ["concurrent + 0 (unlimited)", 0, true, 0],
+    ["concurrent + 30 (below floor)", 30, true, 1800],
+    ["concurrent + 600 (below floor)", 600, true, 1800],
+    ["concurrent + 1800 (floor)", 1800, true, 1800],
+    ["concurrent + 3600 (above floor)", 3600, true, 3600],
+  ] as const)("queryTimeoutSecsForConcurrentIndex preserves %s", (_name, configured, concurrent, expected) => {
+    expect(queryTimeoutSecsForConcurrentIndex(configured, concurrent)).toBe(expected);
+  });
   it("lets PostgreSQL row queries use the backend inactivity timeout", () => {
     expect(frontendQueryTimeoutSecsForSql("SELECT * FROM sample_records LIMIT 2000", "postgres", 30)).toBe(0);
     expect(frontendQueryTimeoutSecsForSql("/* page */\nWITH rows AS (SELECT 1) SELECT * FROM rows", "postgres", 30)).toBe(0);
diff --git a/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts b/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts
index 050c3a0415..0756746126 100644
--- a/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts
@@ -38,6 +38,22 @@ describe("tableStructureCapabilities", () => {
     expect(getTableStructureCapabilities("sqlserver", "sqlserver", "10.0").indexInclude).toBe(true);
   });
 
+  it("enables concurrent index creation only for PostgreSQL", () => {
+    // PostgreSQL (including pre-11 versions that disable INCLUDE) advertises it.
+    expect(getTableStructureCapabilities("postgres", "postgres").indexConcurrent).toBe(true);
+    expect(getTableStructureCapabilities("postgres", "postgres", "10.15").indexConcurrent).toBe(true);
+
+    // PostgreSQL-family engines sharing the Postgres dialect stay off until verified.
+    for (const databaseType of ["kingbase", "gaussdb", "opengauss", "highgo", "uxdb", "vastbase", "kwdb", "firebird"] as const) {
+      expect(getTableStructureCapabilities(databaseType, databaseType).indexConcurrent).toBe(false);
+    }
+
+    // Unrelated engines never advertise it.
+    for (const databaseType of ["mysql", "sqlite", "sqlserver", "oracle", "dameng", "duckdb", "questdb"] as const) {
+      expect(getTableStructureCapabilities(databaseType, databaseType).indexConcurrent).toBe(false);
+    }
+  });
+
   it("removes unsupported included columns before SQL generation", () => {
     const index = {
       id: "new:index",
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index e8394cd731..597d180df9 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -171,6 +171,8 @@ export const listForeignKeys = forward("listForeignKeys");
 export const listTriggers = forward("listTriggers");
 export const listConstraints = forward("listConstraints");
 export const listPartitions = forward("listPartitions");
+export const getTablePartitionStatus = forward("getTablePartitionStatus");
+export const listInvalidIndexes = forward("listInvalidIndexes");
 export const listSubpartitions = forward("listSubpartitions");
 export const getTableDdl = forward("getTableDdl");
 export const getTableDisplayDdl = forward("getTableDisplayDdl");
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index 144c912dc4..7a15420699 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -869,6 +869,19 @@ export async function listPartitions(connectionId: string, database: string, sch
   return get(`/api/schema/partitions?${qs({ connection_id: connectionId, database, schema, table, catalog })}`);
 }
 
+export interface TablePartitionStatus {
+  isPartitionedParent: boolean;
+  isPartition: boolean;
+}
+
+export async function getTablePartitionStatus(connectionId: string, database: string, schema: string, table: string): Promise<TablePartitionStatus> {
+  return get(`/api/schema/table-partition-status?${qs({ connection_id: connectionId, database, schema, table })}`);
+}
+
+export async function listInvalidIndexes(connectionId: string, database: string, schema: string, table: string): Promise<string[]> {
+  return get(`/api/schema/invalid-indexes?${qs({ connection_id: connectionId, database, schema, table })}`);
+}
+
 export async function listSubpartitions(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<SubpartitionInfo[]> {
   return get(`/api/schema/subpartitions?${qs({ connection_id: connectionId, database, schema, table, catalog })}`);
 }
@@ -1105,12 +1118,13 @@ export async function closeClientConnectionSession(connectionId: string, databas
   });
 }
 
-export async function executeBatch(connectionId: string, database: string, statements: string[], schema?: string): Promise<QueryResult> {
+export async function executeBatch(connectionId: string, database: string, statements: string[], schema?: string, timeoutSecs?: number): Promise<QueryResult> {
   return post("/api/query/execute-batch", {
     connectionId,
     database,
     statements,
     schema,
+    timeoutSecs,
   });
 }
 
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 719bfd2c51..c1b9605b5b 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -1644,6 +1644,29 @@ export async function listPartitions(connectionId: string, database: string, sch
   });
 }
 
+export interface TablePartitionStatus {
+  isPartitionedParent: boolean;
+  isPartition: boolean;
+}
+
+export async function getTablePartitionStatus(connectionId: string, database: string, schema: string, table: string): Promise<TablePartitionStatus> {
+  return invoke("get_table_partition_status", {
+    connectionId,
+    database,
+    schema,
+    table,
+  });
+}
+
+export async function listInvalidIndexes(connectionId: string, database: string, schema: string, table: string): Promise<string[]> {
+  return invoke("list_invalid_indexes", {
+    connectionId,
+    database,
+    schema,
+    table,
+  });
+}
+
 export async function listSubpartitions(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<SubpartitionInfo[]> {
   return invoke("list_subpartitions", {
     connectionId,
diff --git a/apps/desktop/src/lib/diagram/draft-table.ts b/apps/desktop/src/lib/diagram/draft-table.ts
index 7ccbf275a4..378913da79 100644
--- a/apps/desktop/src/lib/diagram/draft-table.ts
+++ b/apps/desktop/src/lib/diagram/draft-table.ts
@@ -39,6 +39,7 @@ export function createDraftIndex(tableName: string, columns: string[], existingI
     indexType: "",
     includedColumns: [],
     comment: "",
+    concurrently: false,
     markedForDrop: false,
   };
 }
diff --git a/apps/desktop/src/lib/sql/queryTimeout.ts b/apps/desktop/src/lib/sql/queryTimeout.ts
index ccb3adfdef..44165b4d58 100644
--- a/apps/desktop/src/lib/sql/queryTimeout.ts
+++ b/apps/desktop/src/lib/sql/queryTimeout.ts
@@ -3,6 +3,21 @@ import { tokenizeSqlSemantic } from "@/lib/sql/semantic/tokens";
 import type { ConnectionConfig, DatabaseType } from "@/types/database";
 
 export const DEFAULT_QUERY_TIMEOUT_SECS = 30;
+
+/**
+ * Query timeout (seconds) the table structure editor applies when the change
+ * script contains a PostgreSQL `CREATE INDEX CONCURRENTLY`.
+ *
+ * Concurrent builds scan the whole table while only taking `ShareUpdateExclusiveLock`,
+ * so they routinely run far beyond the default 30s query timeout — the default
+ * budget would cancel a legitimate build and leave an INVALID index behind.
+ * PostgreSQL itself does not impose a build deadline
+ * (https://www.postgresql.org/docs/current/sql-createindex.html). This is the
+ * dedicated 30-minute floor used by `queryTimeoutSecsForConcurrentIndex` for
+ * such statements; it never overrides an unlimited setting (0) and never
+ * shortens a larger configured timeout.
+ */
+export const CONCURRENT_INDEX_QUERY_TIMEOUT_SECS = 1800;
 const MAX_BROWSER_TIMER_DELAY_MS = 2_147_483_647;
 
 const POSTGRES_ROW_STATEMENT_KEYWORDS = new Set(["select", "show", "explain", "table", "with"]);
@@ -17,6 +32,19 @@ export function queryTimeoutSecsForConnection(connection?: Pick<ConnectionConfig
   return Number.isFinite(value) && value >= 0 ? value : DEFAULT_QUERY_TIMEOUT_SECS;
 }
 
+/**
+ * Effective query timeout (seconds) for a table-structure change script.
+ *
+ * Concurrent builds use at least the dedicated 30-minute floor while
+ * preserving an unlimited setting (0) and any larger configured timeout.
+ * Non-concurrent scripts keep the configured timeout unchanged.
+ */
+export function queryTimeoutSecsForConcurrentIndex(configuredTimeoutSecs: number, hasConcurrentIndexBuild: boolean): number {
+  if (!hasConcurrentIndexBuild) return configuredTimeoutSecs;
+  if (configuredTimeoutSecs === 0) return 0;
+  return Math.max(configuredTimeoutSecs, CONCURRENT_INDEX_QUERY_TIMEOUT_SECS);
+}
+
 export function frontendQueryTimeoutSecsForSql(sql: string, databaseType: DatabaseType | undefined, queryTimeoutSecs: number): number {
   if (queryTimeoutSecs === 0) return 0;
 
diff --git a/apps/desktop/src/lib/table/concurrentIndexAvailability.ts b/apps/desktop/src/lib/table/concurrentIndexAvailability.ts
new file mode 100644
index 0000000000..d7703b33cf
--- /dev/null
+++ b/apps/desktop/src/lib/table/concurrentIndexAvailability.ts
@@ -0,0 +1,78 @@
+/**
+ * Pure decision helper for the PostgreSQL `CREATE INDEX CONCURRENTLY` checkbox
+ * in the table structure editor (PR #6361).
+ *
+ * Concurrent builds are scoped to *new* indexes on *non-partitioned* tables:
+ * editing an existing index would require a `DROP INDEX CONCURRENTLY` +
+ * `CREATE INDEX CONCURRENTLY` replace flow (not implemented), and PostgreSQL
+ * rejects `CREATE INDEX CONCURRENTLY` on partitioned parent tables. The core
+ * SQL builder enforces the same scope as a hard error, so this only decides
+ * whether the option is actionable in the UI.
+ */
+export type ConcurrentIndexUnavailableReason = "existing" | "partitioned" | "unknown" | "primary" | "markedForDrop" | "unsupported";
+
+export interface ConcurrentIndexAvailability {
+  enabled: boolean;
+  reason?: ConcurrentIndexUnavailableReason;
+}
+
+export interface ConcurrentIndexAvailabilityInput {
+  /** The draft edits an index that already exists on the table. */
+  hasOriginal: boolean;
+  isPrimary: boolean;
+  markedForDrop: boolean;
+  /** `relkind = 'p'` partitioned parent table. */
+  isPartitionedParent: boolean;
+  /**
+   * The partition status could not be verified (probe failed). Fail closed:
+   * do not offer Concurrent when we cannot rule out a partitioned parent.
+   */
+  partitionStatusKnown: boolean;
+  supportsIndexConcurrent: boolean;
+  supportsCreateIndex: boolean;
+}
+
+export function getConcurrentIndexAvailability(input: ConcurrentIndexAvailabilityInput): ConcurrentIndexAvailability {
+  if (input.markedForDrop) return { enabled: false, reason: "markedForDrop" };
+  if (input.isPrimary) return { enabled: false, reason: "primary" };
+  if (input.hasOriginal) return { enabled: false, reason: "existing" };
+  if (input.isPartitionedParent) return { enabled: false, reason: "partitioned" };
+  if (!input.partitionStatusKnown) return { enabled: false, reason: "unknown" };
+  if (!input.supportsIndexConcurrent || !input.supportsCreateIndex) return { enabled: false, reason: "unsupported" };
+  return { enabled: true };
+}
+
+/**
+ * Unquoted index names referenced by `CREATE [UNIQUE] INDEX CONCURRENTLY`
+ * statements, used to detect same-name INVALID leftovers before applying a
+ * concurrent build. The PG builder emits the index name as a single
+ * double-quoted identifier (optionally schema-qualified).
+ */
+export function concurrentIndexNamesInStatements(statements: string[]): string[] {
+  const names: string[] = [];
+  for (const sql of statements) {
+    const match = sql.match(/CREATE\s+(?:UNIQUE\s+)?INDEX\s+CONCURRENTLY\s+(?:(?:"[^"]+")\s*\.\s*)?"([^"]+)"/i);
+    if (match?.[1]) names.push(match[1]);
+  }
+  return names;
+}
+
+/**
+ * Report index drafts whose Concurrent availability is no longer `enabled`.
+ * Definitive states (partitioned parent, existing index, capability loss, ...)
+ * clear the stale flag. A transiently unknown partition status preserves the
+ * user's intent so a later successful probe can restore the concurrent SQL.
+ * Callers must gate save/SQL generation on every reported invalidation.
+ */
+export function normalizeUnsupportedConcurrentIndexes<IIndex extends { id: string; concurrently?: boolean }>(indexes: readonly IIndex[], availabilityResolver: (index: IIndex) => ConcurrentIndexAvailability): { indexes: IIndex[]; invalidatedIds: string[] } {
+  const invalidatedIds: string[] = [];
+  const normalized = indexes.map((index) => {
+    if (!index.concurrently) return index;
+    const availability = availabilityResolver(index);
+    if (availability.enabled) return index;
+    invalidatedIds.push(index.id);
+    if (availability.reason === "unknown") return index;
+    return { ...index, concurrently: false };
+  });
+  return { indexes: normalized, invalidatedIds };
+}
diff --git a/apps/desktop/src/lib/table/tableStructureCapabilities.ts b/apps/desktop/src/lib/table/tableStructureCapabilities.ts
index e9dcd99229..250f6d9605 100644
--- a/apps/desktop/src/lib/table/tableStructureCapabilities.ts
+++ b/apps/desktop/src/lib/table/tableStructureCapabilities.ts
@@ -25,6 +25,7 @@ export interface TableStructureCapabilities {
   indexInclude: boolean;
   indexFilter: boolean;
   indexComment: boolean;
+  indexConcurrent: boolean;
   foreignKey: boolean;
 }
 
@@ -49,6 +50,7 @@ const unsupportedCapabilities: TableStructureCapabilities = {
   indexInclude: false,
   indexFilter: false,
   indexComment: false,
+  indexConcurrent: false,
   foreignKey: false,
 };
 
@@ -115,6 +117,7 @@ const postgresCapabilities = capabilities({
 const postgresBefore11Capabilities = capabilities({
   ...postgresCapabilities,
   indexInclude: false,
+  indexConcurrent: true,
 });
 
 const redshiftCapabilities = capabilities({
@@ -318,7 +321,7 @@ const capabilityByType: Partial<Record<DatabaseType, TableStructureCapabilities>
   oscar: damengCapabilities,
   databend: mysqlCapabilities,
   gbase: gbaseCapabilities,
-  postgres: postgresCapabilities,
+  postgres: capabilities({ ...postgresCapabilities, indexConcurrent: true }),
   gaussdb: postgresCapabilities,
   kwdb: postgresCapabilities,
   opengauss: postgresCapabilities,
diff --git a/apps/desktop/src/lib/table/tableStructureEditorSql.ts b/apps/desktop/src/lib/table/tableStructureEditorSql.ts
index 177e04090d..c00a89c402 100644
--- a/apps/desktop/src/lib/table/tableStructureEditorSql.ts
+++ b/apps/desktop/src/lib/table/tableStructureEditorSql.ts
@@ -44,6 +44,8 @@ export interface EditableStructureIndex {
   indexType: string;
   includedColumns: string[];
   comment: string;
+  /** Build the index with PostgreSQL `CREATE INDEX CONCURRENTLY` (PostgreSQL only, default off). */
+  concurrently?: boolean;
   original?: IndexInfo;
   markedForDrop: boolean;
 }
@@ -81,6 +83,10 @@ export interface BuildTableStructureChangeSqlOptions {
   triggers?: EditableStructureTrigger[];
   tableComment?: string;
   originalTableComment?: string;
+  /** The target table is a PostgreSQL partitioned parent (`relkind = 'p'`);
+   * the backend rejects `CREATE INDEX CONCURRENTLY` on such tables (fail
+   * closed) instead of downgrading to a blocking `CREATE INDEX`. */
+  partitioned?: boolean;
 }
 
 export interface TableStructureChangeSql {
diff --git a/crates/dbx-core/src/db/postgres.rs b/crates/dbx-core/src/db/postgres.rs
index a726f23e0f..89cc0e5f0e 100644
--- a/crates/dbx-core/src/db/postgres.rs
+++ b/crates/dbx-core/src/db/postgres.rs
@@ -5473,6 +5473,30 @@ pub async fn list_indexes(pool: &Pool, schema: &str, table: &str) -> Result<Vec<
     }
 }
 
+/// Names of same-table indexes whose `pg_index.indisvalid` is `false`.
+///
+/// A cancelled `CREATE INDEX CONCURRENTLY` leaves an INVALID index behind with
+/// the requested name; until it is dropped, any retry of the same build fails
+/// with `relation already exists`. The structure editor consults this before
+/// applying a concurrent build so it can surface the leftover explicitly
+/// instead of failing silently.
+const POSTGRES_INVALID_INDEXES_SQL: &str = "SELECT idx.relname \
+     FROM pg_catalog.pg_index ix \
+     JOIN pg_catalog.pg_class idx ON idx.oid = ix.indexrelid \
+     JOIN pg_catalog.pg_class t ON t.oid = ix.indrelid \
+     JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace \
+     WHERE n.nspname = $1 AND t.relname = $2 AND ix.indisvalid = false \
+     ORDER BY idx.relname";
+
+pub async fn list_invalid_indexes(pool: &Pool, schema: &str, table: &str) -> Result<Vec<String>, String> {
+    let schema = if schema.is_empty() { "public" } else { schema };
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(&client, POSTGRES_INVALID_INDEXES_SQL, &[&schema, &table])
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(rows.iter().map(|row| pg_row_try_string(row, 0)).collect())
+}
+
 fn postgres_foreign_keys_sql() -> &'static str {
     "SELECT fk.constraint_name, fk.column_name, \
      pk.table_schema AS ref_schema, pk.table_name AS ref_table, pk.column_name AS ref_column, \
diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rs
index 39f868d44a..06485bae78 100644
--- a/crates/dbx-core/src/schema.rs
+++ b/crates/dbx-core/src/schema.rs
@@ -6273,6 +6273,63 @@ pub async fn list_partitions_core(
     .await
 }
 
+/// PostgreSQL partition classification of a single table, used by the table
+/// structure editor to decide whether `CREATE INDEX CONCURRENTLY` applies.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TablePartitionStatus {
+    /// The table is a partitioned parent (`pg_class.relkind = 'p'`); PostgreSQL
+    /// rejects `CREATE INDEX CONCURRENTLY` directly on it — the supported
+    /// approach is building child indexes concurrently and attaching them.
+    pub is_partitioned_parent: bool,
+    /// The table is itself a partition of a parent (`pg_class.relispartition`).
+    pub is_partition: bool,
+}
+
+pub async fn table_partition_status_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<TablePartitionStatus, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_metadata_pool_for_session(connection_id, Some(database), None).await?;
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key) {
+            Some(PoolKind::Postgres(pool)) => {
+                let info = db::postgres::get_table_partition_info(pool, schema, table).await?;
+                Ok(TablePartitionStatus {
+                    is_partitioned_parent: info.key.is_some() && !info.is_partition,
+                    is_partition: info.is_partition,
+                })
+            }
+            _ => Ok(TablePartitionStatus::default()),
+        }
+    })
+    .await
+}
+
+/// Same-table index names whose `pg_index.indisvalid` is `false` (left behind
+/// by a cancelled `CREATE INDEX CONCURRENTLY`). Empty for non-PostgreSQL pools.
+pub async fn list_invalid_indexes_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<String>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_metadata_pool_for_session(connection_id, Some(database), None).await?;
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key) {
+            Some(PoolKind::Postgres(pool)) => db::postgres::list_invalid_indexes(pool, schema, table).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
 pub async fn list_subpartitions_core(
     state: &AppState,
     connection_id: &str,
diff --git a/crates/dbx-core/src/table_structure_sql.rs b/crates/dbx-core/src/table_structure_sql.rs
index 63f78005d9..3cf1833300 100644
--- a/crates/dbx-core/src/table_structure_sql.rs
+++ b/crates/dbx-core/src/table_structure_sql.rs
@@ -25,9 +25,16 @@ use comments::build_table_comment_sql;
 use foreign_keys::build_foreign_key_sql;
 use indexes::build_index_sql;
 use triggers::build_trigger_sql;
-use validation::validate_draft;
+use validation::{validate_concurrent_index_scope, validate_draft};
 
 pub fn build_table_structure_change_sql(options: TableStructureSqlOptions) -> TableStructureSqlResult {
+    // Fail closed: an unsupported concurrent-index request (existing index, or
+    // partitioned parent table) must never degrade into blocking index DDL
+    // behind the caller's back, so the whole plan is refused up front.
+    let concurrent_errors = validate_concurrent_index_scope(&options);
+    if !concurrent_errors.is_empty() {
+        return TableStructureSqlResult { statements: Vec::new(), warnings: concurrent_errors };
+    }
     let mut warnings = validate_draft(&options);
     let mut statements = build_column_sql(&options, &mut warnings);
     statements.extend(build_index_sql(&options, &mut warnings));
diff --git a/crates/dbx-core/src/table_structure_sql/create_table.rs b/crates/dbx-core/src/table_structure_sql/create_table.rs
index 9b1775afe3..e23b679cac 100644
--- a/crates/dbx-core/src/table_structure_sql/create_table.rs
+++ b/crates/dbx-core/src/table_structure_sql/create_table.rs
@@ -9,12 +9,16 @@ use super::indexes::build_create_index_statements;
 use super::triggers::build_trigger_sql;
 use super::types::{TableStructureSqlOptions, TableStructureSqlResult};
 use super::util::{clean, format_default_for_sql, normalize_default, qualified_table, quote_ident, quote_string};
-use super::validation::{validate_columns, validate_dameng_identity};
+use super::validation::{validate_columns, validate_concurrent_index_scope, validate_dameng_identity};
 use crate::models::connection::DatabaseType;
 
 pub fn build_create_table_sql(mut options: TableStructureSqlOptions) -> TableStructureSqlResult {
     options.table_name = clean(&options.table_name);
     let mut warnings = Vec::new();
+    // Fail closed: a concurrent-index request on a partitioned parent (or on an
+    // existing index in a hand-built draft) is refused up front instead of
+    // degrading into blocking index DDL.
+    warnings.extend(validate_concurrent_index_scope(&options));
     if options.table_name.is_empty() {
         warnings.push("Table name is required.".to_string());
     }
@@ -183,6 +187,7 @@ pub fn build_create_table_sql(mut options: TableStructureSqlOptions) -> TableStr
             options.schema.as_deref(),
             &options.table_name,
             false,
+            capabilities.index_concurrent,
         ));
     }
 
diff --git a/crates/dbx-core/src/table_structure_sql/dialect.rs b/crates/dbx-core/src/table_structure_sql/dialect.rs
index 34477ca8c9..134190f62c 100644
--- a/crates/dbx-core/src/table_structure_sql/dialect.rs
+++ b/crates/dbx-core/src/table_structure_sql/dialect.rs
@@ -38,6 +38,7 @@ pub(super) struct TableStructureCapabilities {
     pub(super) index_include: bool,
     pub(super) index_filter: bool,
     pub(super) index_comment: bool,
+    pub(super) index_concurrent: bool,
     pub(super) alter_primary_key: bool,
     pub(super) foreign_key: bool,
 }
@@ -59,6 +60,7 @@ impl Default for TableStructureCapabilities {
             index_include: false,
             index_filter: false,
             index_comment: false,
+            index_concurrent: false,
             alter_primary_key: false,
             foreign_key: false,
         }
@@ -118,24 +120,35 @@ pub(super) fn capabilities_for(database_type: Option<DatabaseType>) -> TableStru
             | DatabaseType::Vastbase
             | DatabaseType::Kingbase
             | DatabaseType::Firebird,
-        ) => TableStructureCapabilities {
-            dialect: StructureDialect::Postgres,
-            add_column: true,
-            drop_column: true,
-            rename_column: true,
-            alter_existing_column: true,
-            comment: true,
-            create_index: true,
-            drop_index: true,
-            rebuild_index: true,
-            index_type: true,
-            index_include: true,
-            index_filter: true,
-            index_comment: true,
-            alter_primary_key: true,
-            foreign_key: true,
-            ..base
-        },
+        ) => {
+            let mut caps = TableStructureCapabilities {
+                dialect: StructureDialect::Postgres,
+                add_column: true,
+                drop_column: true,
+                rename_column: true,
+                alter_existing_column: true,
+                comment: true,
+                create_index: true,
+                drop_index: true,
+                rebuild_index: true,
+                index_type: true,
+                index_include: true,
+                index_filter: true,
+                index_comment: true,
+                alter_primary_key: true,
+                foreign_key: true,
+                ..base
+            };
+            // CREATE INDEX CONCURRENTLY is PostgreSQL-specific. Other PostgreSQL-family
+            // engines (Kingbase, GaussDB, OpenGauss, HighGo, UXDB, Vastbase, KWDB,
+            // Firebird) share the Postgres dialect but have not been verified against a
+            // real environment, so they keep this capability off until individually
+            // validated.
+            if database_type == Some(DatabaseType::Postgres) {
+                caps.index_concurrent = true;
+            }
+            caps
+        }
         Some(DatabaseType::Questdb) => TableStructureCapabilities {
             dialect: StructureDialect::Questdb,
             add_column: true,
@@ -151,6 +164,7 @@ pub(super) fn capabilities_for(database_type: Option<DatabaseType>) -> TableStru
             index_include: false,
             index_filter: false,
             index_comment: false,
+            index_concurrent: false,
             alter_primary_key: false,
             foreign_key: false,
         },
diff --git a/crates/dbx-core/src/table_structure_sql/indexes.rs b/crates/dbx-core/src/table_structure_sql/indexes.rs
index d8bea9e586..c04163c266 100644
--- a/crates/dbx-core/src/table_structure_sql/indexes.rs
+++ b/crates/dbx-core/src/table_structure_sql/indexes.rs
@@ -66,6 +66,7 @@ pub(super) fn build_index_sql(options: &TableStructureSqlOptions, warnings: &mut
                 options.schema.as_deref(),
                 &options.table_name,
                 or_replace,
+                capabilities.index_concurrent,
             ));
             continue;
         }
@@ -82,6 +83,7 @@ pub(super) fn build_index_sql(options: &TableStructureSqlOptions, warnings: &mut
             options.schema.as_deref(),
             &options.table_name,
             false,
+            capabilities.index_concurrent,
         ));
     }
 
@@ -217,6 +219,7 @@ pub(super) fn build_create_index_statements(
     schema: Option<&str>,
     table_name: &str,
     or_replace: bool,
+    concurrently_supported: bool,
 ) -> Vec<String> {
     let capabilities = capabilities_for(database_type_for_dialect(dialect));
     let name = clean(&index.name);
@@ -226,6 +229,14 @@ pub(super) fn build_create_index_statements(
         return Vec::new();
     }
 
+    // `CREATE INDEX CONCURRENTLY` is PostgreSQL-only: the flag is honored only when
+    // the caller's real database type advertises the capability, so a stale or
+    // forged `concurrently: true` from another engine is ignored and the original
+    // SQL is generated unchanged. Unsupported concurrent requests (existing index,
+    // partitioned parent) are rejected up front by `validate_concurrent_index_scope`
+    // before any statement is built — this function never downgrades them.
+    let concurrently = index.concurrently && concurrently_supported && dialect == StructureDialect::Postgres;
+
     let unique = if index.is_unique { "UNIQUE " } else { "" };
     let replace = if or_replace { "OR REPLACE " } else { "" };
     let key_is_expression = key_expression_flags(index, &columns);
@@ -296,8 +307,9 @@ pub(super) fn build_create_index_statements(
     let create_table =
         if dialect == StructureDialect::Sqlite { quote_ident(dialect, table_name) } else { table.to_string() };
     let create_sql = if dialect == StructureDialect::Postgres {
+        let concurrent_clause = if concurrently { "CONCURRENTLY " } else { "" };
         format!(
-            "CREATE {replace}{unique}{type_prefix}INDEX {index_name} ON {create_table}{using_clause} ({cols}){include_clause}{where_clause};"
+            "CREATE {replace}{unique}INDEX {concurrent_clause}{index_name} ON {create_table}{using_clause} ({cols}){include_clause}{where_clause};"
         )
     } else {
         format!(
diff --git a/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs b/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs
index 0062176e57..c5980c9599 100644
--- a/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs
+++ b/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs
@@ -1516,6 +1516,7 @@ mod tests {
             triggers: Vec::new(),
             table_comment: None,
             original_table_comment: None,
+            partitioned: false,
         }
     }
 
@@ -1691,6 +1692,7 @@ mod tests {
             index_type: String::new(),
             included_columns: Vec::new(),
             comment: String::new(),
+            concurrently: false,
             original: None,
             marked_for_drop: false,
         });
@@ -2009,6 +2011,7 @@ mod tests {
             index_type: String::new(),
             included_columns: Vec::new(),
             comment: String::new(),
+            concurrently: false,
             original: Some(IndexInfo {
                 name: "uq_items_value".to_string(),
                 columns: vec!["value".to_string()],
diff --git a/crates/dbx-core/src/table_structure_sql/tests.rs b/crates/dbx-core/src/table_structure_sql/tests.rs
index 8d4e0238f1..0c0ca9b152 100644
--- a/crates/dbx-core/src/table_structure_sql/tests.rs
+++ b/crates/dbx-core/src/table_structure_sql/tests.rs
@@ -59,6 +59,7 @@ fn structure_change_options(
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     }
 }
 
@@ -73,6 +74,7 @@ fn index(name: &str, columns: &[&str]) -> EditableStructureIndex {
         index_type: String::new(),
         included_columns: Vec::new(),
         comment: String::new(),
+        concurrently: false,
         original: None,
         marked_for_drop: false,
     }
@@ -110,6 +112,7 @@ fn index_change_options(
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     }
 }
 
@@ -185,6 +188,7 @@ fn builds_mysql_column_and_index_changes() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -398,6 +402,7 @@ fn builds_xugu_type_change_with_native_syntax() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -563,6 +568,7 @@ fn builds_mysql_unsigned_integer_column_with_length_before_attribute() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -595,6 +601,7 @@ fn doris_table_editor_renames_column_without_mysql_change_syntax() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -651,6 +658,7 @@ fn dameng_integer_column_omits_mysql_display_width() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -690,6 +698,7 @@ fn builds_highgo_foreign_key_changes_with_postgres_syntax() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -758,6 +767,7 @@ fn builds_informix_column_and_index_changes() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -811,6 +821,7 @@ fn oracle_does_not_generate_drop_sql_for_all_columns() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -869,6 +880,7 @@ fn oracle_create_table_preserves_character_length_units() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert!(result.statements[0].contains("\"BYTE_COL\" VARCHAR2(12 BYTE)"));
@@ -955,6 +967,7 @@ fn iris_drop_index_includes_table_name() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -993,6 +1006,7 @@ fn iris_ignores_comment_changes_but_keeps_supported_column_alters() {
         triggers: Vec::new(),
         table_comment: Some("new table description".to_string()),
         original_table_comment: Some("old table description".to_string()),
+        partitioned: false,
     });
 
     assert_eq!(
@@ -1071,6 +1085,7 @@ fn oracle_compatible_databases_keep_comment_on_sql() {
             triggers: Vec::new(),
             table_comment: Some("new table description".to_string()),
             original_table_comment: Some("old table description".to_string()),
+            partitioned: false,
         });
 
         assert_eq!(result.warnings, Vec::<String>::new(), "{database_type:?}");
@@ -1102,6 +1117,7 @@ fn mysql_create_index_with_comment() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1132,6 +1148,7 @@ fn manticoresearch_builds_create_table_sql_only() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1172,6 +1189,7 @@ fn manticoresearch_builds_add_and_drop_column_sql() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1235,6 +1253,7 @@ fn gbase8a_uses_limited_mysql_ddl() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(
@@ -1302,6 +1321,7 @@ fn gbase8a_allows_mysql_style_column_reorder() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1334,6 +1354,7 @@ fn manticoresearch_does_not_drop_id_column() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -1399,6 +1420,7 @@ fn manticoresearch_warns_when_existing_column_properties_change() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -1431,6 +1453,7 @@ fn manticoresearch_ignores_mysql_column_options() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1466,6 +1489,7 @@ fn manticoresearch_builds_text_column_properties() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1493,6 +1517,7 @@ fn manticoresearch_builds_json_secondary_index_property() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1516,6 +1541,7 @@ fn mysql_create_unique_index_with_comment_and_btree() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1541,6 +1567,7 @@ fn mysql_create_functional_index_preserves_key_part_syntax() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1566,6 +1593,7 @@ fn mysql_add_timestamp_column_drops_invalid_precision() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1591,6 +1619,7 @@ fn mysql_add_timestamp_column_preserves_valid_precision() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1623,6 +1652,7 @@ fn builds_postgres_create_table_with_comments_and_index() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1652,6 +1682,7 @@ fn quotes_expression_like_new_index_columns_without_provenance() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1721,6 +1752,7 @@ fn create_table_trims_table_name_whitespace_for_all_statements() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1755,6 +1787,7 @@ fn warns_for_sqlite_unsafe_column_changes() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -1793,6 +1826,7 @@ fn qualifies_attached_sqlite_table_and_index_changes() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1859,6 +1893,7 @@ fn builds_rqlite_changes_with_sqlite_dialect() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1886,6 +1921,7 @@ fn builds_kingbase_add_column_without_column_keyword() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -1948,6 +1984,7 @@ fn builds_mysql_column_reorder_statements() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2001,6 +2038,7 @@ fn mysql_add_column_before_existing_column_does_not_reorder_shifted_column() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2061,6 +2099,7 @@ fn mysql_existing_column_reorder_does_not_reorder_columns_shifted_by_prior_move(
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2133,6 +2172,7 @@ fn mysql_moving_first_column_to_end_uses_single_reorder_statement() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2155,6 +2195,7 @@ fn builds_sql_server_quoted_column_and_index_statements() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2183,6 +2224,7 @@ fn sqlserver_strips_mysql_display_width_from_fixed_integer_types() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2205,6 +2247,7 @@ fn sqlserver_strips_scale_from_float() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2227,6 +2270,7 @@ fn sqlserver_preserves_float_mantissa_bits() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2274,6 +2318,7 @@ fn sqlserver_default_changes_drop_old_constraints_with_isolated_batches() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2454,6 +2499,7 @@ fn sqlserver_unchanged_foreign_key_does_not_warn_when_saving_other_changes() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2481,6 +2527,7 @@ fn sqlserver_add_column_with_identity() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2508,6 +2555,7 @@ fn dameng_add_column_with_identity() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2534,6 +2582,7 @@ fn dameng_rejects_identity_on_incompatible_type() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -2564,6 +2613,7 @@ fn sqlserver_rejects_identity_on_incompatible_type() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -2597,6 +2647,7 @@ fn sqlserver_changed_foreign_key_still_warns_as_unsupported() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -2635,6 +2686,7 @@ fn sqlserver_unchanged_identity_extra_does_not_mark_existing_column_changed() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2673,6 +2725,7 @@ fn dameng_unchanged_identity_extra_does_not_mark_existing_column_changed() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2718,6 +2771,7 @@ fn dameng_rejects_adding_second_identity_column() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, vec!["Dameng tables can have only one identity column."]);
@@ -2767,6 +2821,7 @@ fn sqlserver_existing_column_identity_change_warns_without_unchanged_foreign_key
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.statements, Vec::<String>::new());
@@ -2796,6 +2851,7 @@ fn builds_duckdb_create_table_statements() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2839,6 +2895,7 @@ fn builds_clickhouse_nullable_comment_and_reorder_statements() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -2883,6 +2940,7 @@ fn builds_h2_schema_qualified_existing_column_statements() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3295,6 +3353,7 @@ fn mysql_create_table_with_auto_increment() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3320,6 +3379,7 @@ fn mysql_create_table_keeps_column_charset_collation_and_comment() {
         triggers: Vec::new(),
         table_comment: Some("User accounts".to_string()),
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3349,6 +3409,7 @@ fn mysql_compatible_databases_do_not_emit_mysql_column_charset_clauses() {
             triggers: Vec::new(),
             table_comment: None,
             original_table_comment: None,
+            partitioned: false,
         });
 
         assert_eq!(result.warnings, Vec::<String>::new());
@@ -3375,6 +3436,7 @@ fn mysql_create_table_with_on_update_current_timestamp() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3401,6 +3463,7 @@ fn postgres_create_table_with_identity() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3429,6 +3492,7 @@ fn dameng_create_table_with_identity() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3453,6 +3517,7 @@ fn dameng_create_table_preserves_character_length_units() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3485,6 +3550,7 @@ fn dameng_alter_column_preserves_character_length_unit() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3518,6 +3584,7 @@ fn dameng_rejects_multiple_identity_columns() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert!(result.statements.is_empty());
@@ -3544,6 +3611,7 @@ fn dameng_rejects_zero_identity_increment() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert!(result.statements.is_empty());
@@ -3571,6 +3639,7 @@ fn sqlserver_create_table_with_identity() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3593,6 +3662,7 @@ fn mysql_quotes_datetime_literal_default() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3615,6 +3685,7 @@ fn mysql_does_not_quote_current_timestamp() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3638,6 +3709,7 @@ fn mysql_does_not_quote_temporal_function_with_parens() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3660,6 +3732,7 @@ fn mysql_date_literal_default_is_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3682,6 +3755,7 @@ fn mysql_time_literal_default_is_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3704,6 +3778,7 @@ fn non_temporal_types_are_not_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3799,6 +3874,7 @@ fn builds_mysql_foreign_key_changes() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3826,6 +3902,7 @@ fn builds_mysql_composite_foreign_key() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3856,6 +3933,7 @@ fn builds_oracle_foreign_key_with_supported_actions() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3890,6 +3968,7 @@ fn builds_oracle_foreign_key_replacement() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3922,6 +4001,7 @@ fn builds_mysql_trigger_changes() {
         triggers: vec![existing],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3965,6 +4045,7 @@ fn unchanged_postgres_trigger_does_not_block_column_rename() {
         triggers: vec![existing],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -3991,6 +4072,7 @@ fn changed_postgres_trigger_remains_unsupported() {
         triggers: vec![existing],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert!(result.statements.is_empty());
@@ -4022,6 +4104,7 @@ fn rejects_editing_existing_oracle_trigger_without_complete_source() {
         triggers: vec![existing],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert!(result.statements.is_empty());
@@ -4043,6 +4126,7 @@ fn builds_oracle_statement_trigger_without_row_clause() {
         triggers: vec![trigger("ORDERS_AUDIT", "BEFORE STATEMENT", "UPDATE OF STATUS", "BEGIN\n  NULL;\nEND;\n/")],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4075,6 +4159,7 @@ fn drops_existing_oracle_trigger_without_reconstructing_it() {
         triggers: vec![existing],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4093,6 +4178,7 @@ fn rejects_unsupported_oracle_compound_trigger_shape() {
         triggers: vec![trigger("ORDERS_CT", "COMPOUND", "UPDATE", "BEGIN\n  NULL;\nEND;")],
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert!(result.statements.is_empty());
@@ -4115,6 +4201,7 @@ fn mysql_varchar_default_is_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4138,6 +4225,7 @@ fn mysql_char_default_is_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4160,6 +4248,7 @@ fn mysql_text_default_is_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4182,6 +4271,7 @@ fn mysql_enum_default_is_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4204,6 +4294,7 @@ fn mysql_int_default_is_not_quoted() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4332,6 +4423,7 @@ fn mysql_character_column_add_with_charset_collation() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4362,6 +4454,7 @@ fn mysql_numeric_column_omits_charset_collation_in_column_definition() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4402,6 +4495,7 @@ fn mysql_numeric_column_ignores_charset_collation_in_change_detection() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     // No ALTER should be emitted — charset/collation changes on
@@ -4437,6 +4531,7 @@ fn mysql_character_column_detects_charset_collation_change() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4477,6 +4572,7 @@ fn mysql_character_column_preserves_charset_collation_on_other_change() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4512,6 +4608,7 @@ fn oscar_create_table_with_primary_key_and_comments() {
         triggers: Vec::new(),
         table_comment: Some("user table".to_string()),
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4702,6 +4799,7 @@ fn oscar_drop_index_with_schema_qualifier() {
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
@@ -4720,8 +4818,377 @@ fn oscar_table_comment_uses_comment_on_table() {
         triggers: Vec::new(),
         table_comment: Some("new comment".to_string()),
         original_table_comment: Some("old comment".to_string()),
+        partitioned: false,
     });
 
     assert_eq!(result.warnings, Vec::<String>::new());
     assert_eq!(result.statements, vec!["COMMENT ON TABLE \"SYSDBA\".\"users\" IS 'new comment';"]);
 }
+
+#[test]
+fn postgres_existing_index_concurrent_request_rejected() {
+    let mut idx = existing_index("idx_users_email", &["email"], false);
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    // Fail closed: a concurrent request on an existing index is refused up
+    // front. No DROP INDEX and no plain (blocking) CREATE INDEX may be
+    // generated behind the caller's back.
+    assert_eq!(
+        result.warnings,
+        vec![
+            "CREATE INDEX CONCURRENTLY is only supported for newly created indexes. Editing an existing index \"idx_users_email\" with Concurrent enabled is not supported."
+        ]
+    );
+    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
+}
+
+#[test]
+fn postgres_existing_index_concurrent_flag_with_real_change_still_rejected() {
+    // The concurrent flag combined with a real edit (renamed index) must still
+    // be rejected rather than rebuilt the regular way.
+    let mut idx = existing_index("idx_users_email", &["email"], false);
+    idx.name = "idx_users_email_new".to_string();
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings.len(), 1);
+    assert!(result.warnings[0].contains("only supported for newly created indexes"));
+    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
+}
+
+#[test]
+fn postgres_default_index_keeps_plain_create_index() {
+    let idx = index("idx_users_email", &["email"]);
+    assert!(!idx.concurrently);
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]);
+}
+
+#[test]
+fn postgres_concurrent_index_emits_concurrently() {
+    let mut idx = index("idx_users_email", &["email"]);
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["CREATE INDEX CONCURRENTLY \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]
+    );
+}
+
+#[test]
+fn postgres_partitioned_parent_concurrent_request_rejected() {
+    let mut idx = index("idx_users_email", &["email"]);
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "USERS".to_string(),
+        columns: Vec::new(),
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+        partitioned: true,
+    });
+
+    // Fail closed: PostgreSQL rejects CREATE INDEX CONCURRENTLY on a
+    // partitioned parent, so the request is refused up front instead of
+    // downgrading to a blocking CREATE INDEX.
+    assert_eq!(
+        result.warnings,
+        vec![
+            "CREATE INDEX CONCURRENTLY is not supported on PostgreSQL partitioned parent tables. Create indexes concurrently on individual partitions and attach them separately."
+        ]
+    );
+    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
+}
+
+#[test]
+fn postgres_partitioned_parent_plain_index_unchanged() {
+    let idx = index("idx_users_email", &["email"]);
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "USERS".to_string(),
+        columns: Vec::new(),
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+        partitioned: true,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]);
+}
+
+#[test]
+fn postgres_partitioned_option_defaults_to_false() {
+    let json = serde_json::json!({
+        "databaseType": "postgres",
+        "schema": "public",
+        "tableName": "users",
+        "columns": [],
+        "indexes": [],
+        "foreignKeys": [],
+        "triggers": [],
+        "tableComment": null,
+        "originalTableComment": null,
+    });
+    let options: TableStructureSqlOptions = serde_json::from_value(json).unwrap();
+    assert!(!options.partitioned);
+}
+
+#[test]
+fn postgres_create_table_partitioned_concurrent_request_rejected() {
+    // The new-table path (`build_create_table_sql`) is a separate entry point
+    // and must refuse partitioned-parent concurrent requests the same way.
+    let mut idx = index("idx_events_id", &["id"]);
+    idx.concurrently = true;
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "events".to_string(),
+        columns: vec![column("id")],
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+        partitioned: true,
+    });
+
+    assert_eq!(
+        result.warnings,
+        vec![
+            "CREATE INDEX CONCURRENTLY is not supported on PostgreSQL partitioned parent tables. Create indexes concurrently on individual partitions and attach them separately."
+        ]
+    );
+    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
+}
+
+#[test]
+fn mysql_stale_concurrently_flag_is_ignored() {
+    // Non-PostgreSQL engines cannot request a concurrent build at all; a stale
+    // or forged `concurrently` flag must not error and must not alter the SQL.
+    let mut idx = index("idx_users_email", &["email"]);
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE INDEX `idx_users_email` ON `USERS` (`email`);"]);
+}
+
+#[test]
+fn mysql_existing_index_with_stale_concurrently_flag_ignored() {
+    // An existing-index edit on a non-PostgreSQL engine is driven by the actual
+    // field changes; a stale concurrently flag alone must not force a rebuild.
+    let idx = existing_index("idx_users_email", &["email"], false);
+    let mut changed = idx;
+    changed.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, Some("public"), changed));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements.is_empty(), "no rebuild for a flag-only change, got: {:?}", result.statements);
+}
+
+#[test]
+fn postgres_concurrent_unique_index() {
+    let mut idx = index("uniq_users_email", &["email"]);
+    idx.is_unique = true;
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["CREATE UNIQUE INDEX CONCURRENTLY \"uniq_users_email\" ON \"public\".\"USERS\" (\"email\");"]
+    );
+}
+
+#[test]
+fn postgres_concurrent_partial_index_keeps_where_clause() {
+    let mut idx = index("idx_users_active", &["status"]);
+    idx.filter = "status = 'active'".to_string();
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE INDEX CONCURRENTLY \"idx_users_active\" ON \"public\".\"USERS\" (\"status\") WHERE status = 'active';"
+        ]
+    );
+}
+
+#[test]
+fn postgres_concurrent_include_index() {
+    let mut idx = index("idx_users_email", &["email"]);
+    idx.included_columns = vec!["name".to_string(), "created_at".to_string()];
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE INDEX CONCURRENTLY \"idx_users_email\" ON \"public\".\"USERS\" (\"email\") INCLUDE (\"name\", \"created_at\");"
+        ]
+    );
+}
+
+#[test]
+fn postgres_concurrent_index_with_using_and_comment() {
+    let mut idx = index("idx_users_name", &["name"]);
+    idx.index_type = "gin".to_string();
+    idx.comment = "search".to_string();
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE INDEX CONCURRENTLY \"idx_users_name\" ON \"public\".\"USERS\" USING GIN (\"name\");",
+            "COMMENT ON INDEX \"idx_users_name\" IS 'search';",
+        ]
+    );
+}
+
+#[test]
+fn postgres_create_table_concurrent_index() {
+    let mut id = column("id");
+    id.data_type = "integer".to_string();
+    id.is_nullable = false;
+    let mut idx = index("idx_users_name", &["name"]);
+    idx.concurrently = true;
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![id],
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+        partitioned: false,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE TABLE \"public\".\"users\" (\n  \"id\" integer NOT NULL\n);",
+            "CREATE INDEX CONCURRENTLY \"idx_users_name\" ON \"public\".\"users\" (\"name\");",
+        ]
+    );
+}
+
+#[test]
+fn postgres_serde_missing_concurrently_field_defaults_to_false() {
+    let json = serde_json::json!({
+        "id": "idx_users_email",
+        "name": "idx_users_email",
+        "columns": ["email"],
+        "isUnique": false,
+        "isPrimary": false,
+        "filter": "",
+        "indexType": "",
+        "includedColumns": [],
+        "comment": "",
+        "markedForDrop": false,
+    });
+    let index: EditableStructureIndex = serde_json::from_value(json).unwrap();
+    assert!(!index.concurrently);
+}
+
+#[test]
+fn postgres_serde_concurrently_field_roundtrip() {
+    let json = serde_json::json!({
+        "id": "idx_users_email",
+        "name": "idx_users_email",
+        "columns": ["email"],
+        "isUnique": false,
+        "isPrimary": false,
+        "filter": "",
+        "indexType": "",
+        "includedColumns": [],
+        "comment": "",
+        "concurrently": true,
+        "markedForDrop": false,
+    });
+    let index: EditableStructureIndex = serde_json::from_value(json).unwrap();
+    assert!(index.concurrently);
+}
+
+#[test]
+fn kingbase_concurrent_flag_is_ignored() {
+    let mut idx = index("idx_users_email", &["email"]);
+    idx.concurrently = true;
+
+    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Kingbase, Some("public"), idx));
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]);
+}
+
+#[test]
+fn pg_family_concurrent_flag_is_ignored() {
+    for database_type in [
+        DatabaseType::Gaussdb,
+        DatabaseType::OpenGauss,
+        DatabaseType::Highgo,
+        DatabaseType::Uxdb,
+        DatabaseType::Vastbase,
+        DatabaseType::Kwdb,
+        DatabaseType::Firebird,
+    ] {
+        let mut idx = index("idx_users_email", &["email"]);
+        idx.concurrently = true;
+        let result = build_table_structure_change_sql(index_change_options(database_type, Some("public"), idx));
+        assert_eq!(result.warnings, Vec::<String>::new());
+        assert_eq!(
+            result.statements,
+            vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"],
+            "{database_type:?} must not emit CONCURRENTLY"
+        );
+    }
+}
+
+#[test]
+fn non_postgres_concurrent_flag_is_ignored() {
+    for database_type in [DatabaseType::Mysql, DatabaseType::Sqlite, DatabaseType::SqlServer] {
+        let mut idx = index("idx_users_email", &["email"]);
+        idx.concurrently = true;
+        let result = build_table_structure_change_sql(index_change_options(database_type, None, idx));
+        assert_eq!(result.warnings, Vec::<String>::new());
+        let statements = result.statements.join("\n");
+        assert!(
+            !statements.contains("CONCURRENTLY"),
+            "{database_type:?} must not emit CONCURRENTLY, got: {statements}"
+        );
+    }
+}
diff --git a/crates/dbx-core/src/table_structure_sql/types.rs b/crates/dbx-core/src/table_structure_sql/types.rs
index fcc108394d..812eaa8d3d 100644
--- a/crates/dbx-core/src/table_structure_sql/types.rs
+++ b/crates/dbx-core/src/table_structure_sql/types.rs
@@ -96,6 +96,8 @@ pub struct EditableStructureIndex {
     pub included_columns: Vec<String>,
     #[serde(default)]
     pub comment: String,
+    #[serde(default)]
+    pub concurrently: bool,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub original: Option<IndexInfo>,
     #[serde(default)]
@@ -208,6 +210,13 @@ pub struct TableStructureSqlOptions {
     pub table_comment: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub original_table_comment: Option<String>,
+    /// Whether the target table is a partitioned parent table (PostgreSQL
+    /// `relkind = 'p'`). PostgreSQL rejects `CREATE INDEX CONCURRENTLY` on
+    /// partitioned parents, so the builder refuses such a request up front
+    /// (`validate_concurrent_index_scope`) instead of emitting SQL the server
+    /// will reject or downgrading to a blocking `CREATE INDEX`.
+    #[serde(default)]
+    pub partitioned: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
diff --git a/crates/dbx-core/src/table_structure_sql/validation.rs b/crates/dbx-core/src/table_structure_sql/validation.rs
index 9a6290be0d..c743854062 100644
--- a/crates/dbx-core/src/table_structure_sql/validation.rs
+++ b/crates/dbx-core/src/table_structure_sql/validation.rs
@@ -4,6 +4,40 @@ use super::indexes::has_existing_index_change;
 use super::types::{EditableStructureColumn, TableStructureSqlOptions};
 use super::util::clean;
 
+/// Hard errors for `CREATE INDEX CONCURRENTLY` requests the editor cannot
+/// honor safely. Unlike the advisory warnings in [`validate_draft`], these
+/// reject the whole save plan: the caller asked for a non-blocking build and
+/// the only way to honor that is the requested concurrent DDL, so falling back
+/// to blocking index DDL must never happen silently.
+///
+/// Only real PostgreSQL advertises `index_concurrent`, so stale/forged
+/// `concurrently` flags on other engines are ignored here (they cannot express
+/// a concurrent request in the first place).
+pub(super) fn validate_concurrent_index_scope(options: &TableStructureSqlOptions) -> Vec<String> {
+    let mut errors = Vec::new();
+    let capabilities = capabilities_for(options.database_type);
+    if !capabilities.index_concurrent || capabilities.dialect != StructureDialect::Postgres {
+        return errors;
+    }
+    for index in options.indexes.iter().filter(|index| !index.marked_for_drop) {
+        if !index.concurrently {
+            continue;
+        }
+        if index.original.is_some() {
+            errors.push(format!(
+                "CREATE INDEX CONCURRENTLY is only supported for newly created indexes. Editing an existing index \"{}\" with Concurrent enabled is not supported.",
+                index.name
+            ));
+        } else if options.partitioned {
+            errors.push(
+                "CREATE INDEX CONCURRENTLY is not supported on PostgreSQL partitioned parent tables. Create indexes concurrently on individual partitions and attach them separately."
+                    .to_string(),
+            );
+        }
+    }
+    errors
+}
+
 pub(super) fn validate_draft(options: &TableStructureSqlOptions) -> Vec<String> {
     let mut warnings = Vec::new();
     let active_columns: Vec<_> = options.columns.iter().filter(|column| !column.marked_for_drop).collect();
diff --git a/crates/dbx-core/tests/live_postgres_concurrent_index.rs b/crates/dbx-core/tests/live_postgres_concurrent_index.rs
new file mode 100644
index 0000000000..2a4b10ebd1
--- /dev/null
+++ b/crates/dbx-core/tests/live_postgres_concurrent_index.rs
@@ -0,0 +1,217 @@
+use std::time::Duration;
+
+use dbx_core::db::postgres;
+use dbx_core::models::connection::DatabaseType;
+use dbx_core::table_structure_sql::{
+    build_table_structure_change_sql, EditableStructureIndex, TableStructureSqlOptions,
+};
+
+fn live_postgres_url() -> String {
+    let host = std::env::var("DBX_LIVE_POSTGRES_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_POSTGRES_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(5432);
+    let user = std::env::var("DBX_LIVE_POSTGRES_USER").unwrap_or_else(|_| "postgres".to_string());
+    let password = std::env::var("DBX_LIVE_POSTGRES_PASSWORD").unwrap_or_default();
+    let database = std::env::var("DBX_LIVE_POSTGRES_DATABASE").unwrap_or_else(|_| "postgres".to_string());
+    format!("postgresql://{user}:{password}@{host}:{port}/{database}")
+}
+
+fn concurrent_index(columns: Vec<&str>) -> EditableStructureIndex {
+    EditableStructureIndex {
+        id: "idx_users_email".to_string(),
+        name: "idx_users_email".to_string(),
+        columns: columns.into_iter().map(str::to_string).collect(),
+        is_unique: false,
+        is_primary: false,
+        filter: String::new(),
+        index_type: String::new(),
+        included_columns: Vec::new(),
+        comment: String::new(),
+        concurrently: true,
+        original: None,
+        marked_for_drop: false,
+    }
+}
+
+/// `CREATE INDEX CONCURRENTLY` generated by the table structure editor must
+/// succeed on a real PostgreSQL server and leave a valid index
+/// (`pg_index.indisvalid = true`).
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_POSTGRES_HOST/PORT/USER/PASSWORD/DATABASE pointing at a writable PostgreSQL database"]
+async fn live_postgres_concurrent_index_builds_valid_index() {
+    let pool = postgres::connect(&live_postgres_url(), Duration::from_secs(10)).await.expect("connect PostgreSQL");
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_cic_{}", &suffix[..8]);
+    let cleanup = vec![format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE")];
+    let _ = postgres::execute_batch(&pool, &cleanup).await;
+    let setup = vec![
+        format!("CREATE SCHEMA \"{schema}\""),
+        format!("CREATE TABLE \"{schema}\".users (id integer PRIMARY KEY, email text, name text, status text)"),
+    ];
+    postgres::execute_batch(&pool, &setup).await.expect("create live test schema");
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some(schema.clone()),
+        table_name: "users".to_string(),
+        columns: Vec::new(),
+        indexes: vec![concurrent_index(vec!["email"])],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+        partitioned: false,
+    });
+    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
+    assert_eq!(
+        result.statements,
+        vec![format!("CREATE INDEX CONCURRENTLY \"idx_users_email\" ON \"{schema}\".\"users\" (\"email\");")]
+    );
+
+    postgres::execute_batch(&pool, &result.statements).await.expect("execute concurrent index build");
+    let client = pool.get().await.expect("checkout connection");
+    let row = client
+        .query_one(
+            "SELECT indisvalid FROM pg_index WHERE indexrelid = to_regclass($1)",
+            &[&format!("{schema}.idx_users_email")],
+        )
+        .await
+        .expect("read pg_index");
+    let valid: bool = row.get(0);
+    assert!(valid, "concurrently-built index must be valid");
+
+    postgres::execute_batch(&pool, &cleanup).await.expect("cleanup live test schema");
+}
+
+/// PostgreSQL forbids `CREATE INDEX CONCURRENTLY` inside an explicit
+/// transaction block; the editor relies on per-statement autocommit, so the
+/// generated statement must only ever run outside `BEGIN`.
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_POSTGRES_HOST/PORT/USER/PASSWORD/DATABASE pointing at a writable PostgreSQL database"]
+async fn live_postgres_concurrent_index_rejects_transaction_block() {
+    let pool = postgres::connect(&live_postgres_url(), Duration::from_secs(10)).await.expect("connect PostgreSQL");
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_cic_{}", &suffix[..8]);
+    let cleanup = vec![format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE")];
+    let _ = postgres::execute_batch(&pool, &cleanup).await;
+    let setup = vec![
+        format!("CREATE SCHEMA \"{schema}\""),
+        format!("CREATE TABLE \"{schema}\".users (id integer PRIMARY KEY, email text)"),
+    ];
+    postgres::execute_batch(&pool, &setup).await.expect("create live test schema");
+
+    let client = pool.get().await.expect("checkout connection");
+    client.batch_execute("BEGIN").await.expect("begin transaction");
+    let err = client
+        .batch_execute(&format!("CREATE INDEX CONCURRENTLY \"idx_users_email\" ON \"{schema}\".\"users\" (\"email\")"))
+        .await
+        .expect_err("CREATE INDEX CONCURRENTLY must fail inside a transaction block");
+    let _ = client.batch_execute("ROLLBACK").await;
+    let message = err.as_db_error().map(|db_error| db_error.message().to_string()).unwrap_or_else(|| err.to_string());
+    assert!(
+        message.contains("cannot run inside a transaction block"),
+        "expected transaction-block error, got: {message}"
+    );
+
+    postgres::execute_batch(&pool, &cleanup).await.expect("cleanup live test schema");
+}
+
+/// A cancelled `CREATE INDEX CONCURRENTLY` leaves a same-name INVALID index
+/// behind (`pg_index.indisvalid = false`); `list_invalid_indexes` must report
+/// it so the editor can block a doomed retry and point the user at the fix.
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_POSTGRES_HOST/PORT/USER/PASSWORD/DATABASE pointing at a writable PostgreSQL database"]
+async fn live_postgres_invalid_index_leftover_is_detected() {
+    let pool = postgres::connect(&live_postgres_url(), Duration::from_secs(10)).await.expect("connect PostgreSQL");
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_cic_{}", &suffix[..8]);
+    let cleanup = vec![format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE")];
+    let _ = postgres::execute_batch(&pool, &cleanup).await;
+    let setup = vec![
+        format!("CREATE SCHEMA \"{schema}\""),
+        format!("CREATE TABLE \"{schema}\".users (id integer PRIMARY KEY, email text)"),
+        // Simulate the leftover of a cancelled concurrent build. PostgreSQL
+        // does not accept a schema-qualified index name in CREATE INDEX; the
+        // index inherits the table's schema, so only the table is qualified.
+        format!("CREATE INDEX \"idx_users_email\" ON \"{schema}\".\"users\" (\"email\")"),
+    ];
+    postgres::execute_batch(&pool, &setup).await.expect("create live test schema");
+
+    let invalid = postgres::list_invalid_indexes(&pool, &schema, "users").await.expect("list invalid indexes");
+    assert!(invalid.is_empty(), "fresh index must be valid, got: {invalid:?}");
+
+    // Flip indisvalid to false the same way an interrupted concurrent build does.
+    let client = pool.get().await.expect("checkout connection");
+    client
+        .batch_execute(&format!(
+            "UPDATE pg_index SET indisvalid = false WHERE indexrelid = to_regclass('{schema}.idx_users_email')"
+        ))
+        .await
+        .expect("mark index invalid");
+
+    let invalid = postgres::list_invalid_indexes(&pool, &schema, "users").await.expect("list invalid indexes");
+    assert_eq!(invalid, vec!["idx_users_email".to_string()], "invalid leftover must be reported");
+
+    postgres::execute_batch(&pool, &cleanup).await.expect("cleanup live test schema");
+}
+
+/// The structure editor must never emit `CREATE INDEX CONCURRENTLY` for a
+/// partitioned parent table — the builder rejects the request up front
+/// (fail closed) and no SQL reaches the server at all, instead of downgrading
+/// to a blocking `CREATE INDEX`.
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_POSTGRES_HOST/PORT/USER/PASSWORD/DATABASE pointing at a writable PostgreSQL database"]
+async fn live_postgres_partitioned_parent_concurrent_request_rejected() {
+    let pool = postgres::connect(&live_postgres_url(), Duration::from_secs(10)).await.expect("connect PostgreSQL");
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_cic_{}", &suffix[..8]);
+    let cleanup = vec![format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE")];
+    let _ = postgres::execute_batch(&pool, &cleanup).await;
+    let setup = vec![
+        format!("CREATE SCHEMA \"{schema}\""),
+        format!(
+            "CREATE TABLE \"{schema}\".events (id integer, created_at date) PARTITION BY RANGE (created_at)"
+        ),
+        format!("CREATE TABLE \"{schema}\".events_2026 PARTITION OF \"{schema}\".events FOR VALUES FROM ('2026-01-01') TO ('2027-01-01')"),
+    ];
+    postgres::execute_batch(&pool, &setup).await.expect("create live test schema");
+
+    let mut idx = concurrent_index(vec!["id"]);
+    idx.name = "idx_events_id".to_string();
+    idx.id = "idx_events_id".to_string();
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some(schema.clone()),
+        table_name: "events".to_string(),
+        columns: Vec::new(),
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+        partitioned: true,
+    });
+    assert_eq!(
+        result.warnings,
+        vec![
+            "CREATE INDEX CONCURRENTLY is not supported on PostgreSQL partitioned parent tables. Create indexes concurrently on individual partitions and attach them separately."
+        ]
+    );
+    assert!(
+        result.statements.is_empty(),
+        "no SQL may be generated for an unsupported concurrent request, got: {:?}",
+        result.statements
+    );
+    // Nothing was executed: the partitioned parent still has no such index.
+    let client = pool.get().await.expect("checkout connection");
+    let row = client
+        .query_one(
+            "SELECT count(*) FROM pg_catalog.pg_class WHERE relname = $1 AND relnamespace = to_regnamespace($2)",
+            &[&"idx_events_id", &schema],
+        )
+        .await
+        .expect("count index relations");
+    let count: i64 = row.get(0);
+    assert_eq!(count, 0, "rejected request must not create any index on the server");
+
+    postgres::execute_batch(&pool, &cleanup).await.expect("cleanup live test schema");
+}
diff --git a/crates/dbx-core/tests/live_sqlserver_completion.rs b/crates/dbx-core/tests/live_sqlserver_completion.rs
index 77e6890136..8a755fac9d 100644
--- a/crates/dbx-core/tests/live_sqlserver_completion.rs
+++ b/crates/dbx-core/tests/live_sqlserver_completion.rs
@@ -1005,6 +1005,7 @@ async fn live_sqlserver_table_structure_default_changes_drop_existing_constraint
         triggers: Vec::new(),
         table_comment: None,
         original_table_comment: None,
+        partitioned: false,
     });
     assert_eq!(result.warnings, Vec::<String>::new());
     assert_eq!(result.statements.len(), 4);
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index c2e2582597..fe3c55e7d5 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -420,6 +420,8 @@ async fn main() {
         .route("/schema/triggers", get(routes::schema::list_triggers))
         .route("/schema/constraints", get(routes::schema::list_constraints))
         .route("/schema/partitions", get(routes::schema::list_partitions))
+        .route("/schema/table-partition-status", get(routes::schema::get_table_partition_status))
+        .route("/schema/invalid-indexes", get(routes::schema::list_invalid_indexes))
         .route("/schema/subpartitions", get(routes::schema::list_subpartitions))
         .route("/schema/functions", get(routes::schema::list_functions))
         .route("/schema/sequences", get(routes::schema::list_sequences))
diff --git a/crates/dbx-web/src/routes/schema.rs b/crates/dbx-web/src/routes/schema.rs
index 1b8be53fe5..1c358c9947 100644
--- a/crates/dbx-web/src/routes/schema.rs
+++ b/crates/dbx-web/src/routes/schema.rs
@@ -623,6 +623,32 @@ pub async fn list_partitions(
     Ok(Json(serde_json::to_value(result).map_err(|e| AppError::from(e.to_string()))?))
 }
 
+pub async fn get_table_partition_status(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<dbx_core::schema::TablePartitionStatus>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    dbx_core::schema::table_partition_status_core(&state.app, &q.connection_id, database, schema, table)
+        .await
+        .map(Json)
+        .map_err(AppError::from)
+}
+
+pub async fn list_invalid_indexes(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<Vec<String>>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    dbx_core::schema::list_invalid_indexes_core(&state.app, &q.connection_id, database, schema, table)
+        .await
+        .map(Json)
+        .map_err(AppError::from)
+}
+
 pub async fn list_subpartitions(
     State(state): State<Arc<WebState>>,
     Query(q): Query<SchemaQuery>,
diff --git a/src-tauri/src/commands/schema.rs b/src-tauri/src/commands/schema.rs
index ad3712ad12..a15def4876 100644
--- a/src-tauri/src/commands/schema.rs
+++ b/src-tauri/src/commands/schema.rs
@@ -453,6 +453,28 @@ pub async fn list_partitions(
     dbx_core::schema::list_partitions_core(&state, &connection_id, &database, &schema, &table).await
 }
 
+#[tauri::command]
+pub async fn get_table_partition_status(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+) -> Result<dbx_core::schema::TablePartitionStatus, String> {
+    dbx_core::schema::table_partition_status_core(&state, &connection_id, &database, &schema, &table).await
+}
+
+#[tauri::command]
+pub async fn list_invalid_indexes(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+) -> Result<Vec<String>, String> {
+    dbx_core::schema::list_invalid_indexes_core(&state, &connection_id, &database, &schema, &table).await
+}
+
 #[tauri::command]
 pub async fn list_subpartitions(
     state: State<'_, Arc<AppState>>,
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index ebc01ef291..c548f14226 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1662,6 +1662,8 @@ pub fn run() {
             commands::schema::list_triggers,
             commands::schema::list_constraints,
             commands::schema::list_partitions,
+            commands::schema::get_table_partition_status,
+            commands::schema::list_invalid_indexes,
             commands::schema::list_subpartitions,
             commands::schema::get_table_ddl,
             commands::schema::list_functions,