From 120566b1fd79c49ce1ee60789033700ec27e357a Mon Sep 17 00:00:00 2001
From: t8y2 <1156263951@qq.com>
Date: Thu, 4 Jun 2026 19:40:52 +0800
Subject: [PATCH] fix: improve JDBC dialect handling

---
 .../src/components/layout/ContentArea.vue     | 16 +--
 .../src/components/objects/ObjectBrowser.vue  | 64 ++++++------
 .../src/components/sidebar/ConnectionTree.vue |  3 +-
 .../src/components/sidebar/TreeItem.vue       | 81 ++++++++++------
 .../structure/TableStructureEditor.vue        | 32 ++++--
 .../src/composables/useDataGridActions.ts     | 14 +--
 .../src/composables/useNavigationTargets.ts   | 45 +++++----
 .../desktop/src/lib/databaseCapabilitySets.ts |  3 +
 .../desktop/src/lib/databaseFeatureSupport.ts | 25 +++++
 apps/desktop/src/lib/jdbcDialect.ts           | 70 +++++++++++++
 apps/desktop/src/lib/tableSelectSql.ts        |  4 +-
 apps/desktop/src/stores/connectionStore.ts    | 31 ++++--
 apps/desktop/src/stores/queryStore.ts         | 54 +++++++++--
 crates/dbx-core/src/query.rs                  |  2 +-
 crates/dbx-core/src/sql_dialect.rs            | 24 +++--
 .../app-tests/databaseCapabilities.test.ts    | 19 ++++
 packages/app-tests/jdbcDialect.test.ts        | 60 ++++++++++++
 packages/app-tests/queryStore.test.ts         | 15 +++
 packages/app-tests/tableSelectSql.test.ts     |  2 +-
 .../main/java/app/dbx/jdbc/DbxJdbcPlugin.java | 97 +++++++++++++++++--
 .../java/app/dbx/jdbc/DbxJdbcPluginTest.java  | 13 +++
 21 files changed, 541 insertions(+), 133 deletions(-)
 create mode 100644 apps/desktop/src/lib/jdbcDialect.ts
 create mode 100644 packages/app-tests/jdbcDialect.test.ts

diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index 5c9e16974f..3c4c271325 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -54,6 +54,7 @@ import { canCancelQueryExecution, queryExecutionLabelKey } from "@/lib/queryExec
 import { databaseDisplayNameForTab } from "@/lib/tabPresentation";
 import { isTableDataEditable } from "@/lib/tableEditing";
 import { tableMetaForDataTab } from "@/lib/tableDataTabMeta";
+import { effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect";
 import type { QueryTab, ConnectionConfig } from "@/types/database";
 import type { SqlFormatDialect } from "@/lib/sqlFormatter";
 
@@ -148,9 +149,10 @@ const redisKeyBrowserRef = ref<SearchableBrowserHandle>();
 const objectBrowserRef = ref<SearchableBrowserHandle>();
 const activeTableMeta = computed(() => props.activeTab.tableMeta);
 const activeDataTabTableMeta = computed(() => tableMetaForDataTab(props.activeTab));
+const activeEffectiveDatabaseType = computed(() => effectiveDatabaseTypeForConnection(props.activeConnection));
 
 const activeSqlFormatDialect = computed<SqlFormatDialect>(() => {
-  switch (props.activeConnection?.db_type) {
+  switch (activeEffectiveDatabaseType.value) {
     case "mysql":
       return "mysql";
     case "postgres":
@@ -165,8 +167,8 @@ const activeSqlFormatDialect = computed<SqlFormatDialect>(() => {
 });
 
 const editorDialect = computed<"mysql" | "postgres" | "sqlserver">(() => {
-  if (props.activeConnection?.db_type === "postgres") return "postgres";
-  if (props.activeConnection?.db_type === "sqlserver") return "sqlserver";
+  if (activeEffectiveDatabaseType.value === "postgres") return "postgres";
+  if (activeEffectiveDatabaseType.value === "sqlserver") return "sqlserver";
   return "mysql";
 });
 
@@ -367,7 +369,7 @@ defineExpose({ focusSearch, refreshData, handleModRTarget });
               :connection-id="activeTab.connectionId"
               :database="activeTab.database"
               :schema="activeTab.schema"
-              :database-type="activeConnection?.db_type"
+              :database-type="activeEffectiveDatabaseType"
               :dialect="editorDialect"
               :format-dialect="activeSqlFormatDialect"
               :format-request-id="formatSqlRequestId"
@@ -552,7 +554,7 @@ defineExpose({ focusSearch, refreshData, handleModRTarget });
                 :editable="!!activeTab.queryAnalysis"
                 :source-columns="activeTab.querySourceColumns"
                 context="results"
-                :database-type="activeConnection?.db_type"
+                :database-type="activeEffectiveDatabaseType"
                 :connection-id="activeTab.connectionId"
                 :database="activeTab.database"
                 :schema="activeTab.schema"
@@ -799,10 +801,10 @@ defineExpose({ focusSearch, refreshData, handleModRTarget });
           :initial-order-by-input="activeTab.orderByInput"
           :sql="activeTab.sql"
           :loading="activeTab.isExecuting"
-          :editable="isTableDataEditable(activeConnection?.db_type, activeTableMeta?.primaryKeys ?? [])"
+          :editable="isTableDataEditable(activeEffectiveDatabaseType, activeTableMeta?.primaryKeys ?? [])"
           context="table-data"
           :initial-where-input="activeTab.whereInput"
-          :database-type="activeConnection?.db_type"
+          :database-type="activeEffectiveDatabaseType"
           :connection-id="activeTab.connectionId"
           :database="activeTab.database"
           :table-meta="activeDataTabTableMeta"
diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vue
index 8827db0512..c5b6165d6c 100644
--- a/apps/desktop/src/components/objects/ObjectBrowser.vue
+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue
@@ -51,6 +51,7 @@ import {
   supportsTableStructureEditing,
   supportsTableTruncate,
 } from "@/lib/databaseFeatureSupport";
+import { connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect";
 import { buildTableSelectSql } from "@/lib/tableSelectSql";
 import {
   buildDropObjectSql,
@@ -128,6 +129,9 @@ const sourceContent = ref("");
 const sourceError = ref("");
 const sourceRow = ref<ObjectBrowserRow | null>(null);
 const sourceEditing = ref(false);
+const effectiveDatabaseType = computed(
+  () => effectiveDatabaseTypeForConnection(props.connection) ?? props.connection.db_type,
+);
 const sourceDraft = ref("");
 const sourceSaving = ref(false);
 const sourceSaveError = ref("");
@@ -159,7 +163,9 @@ let loadId = 0;
 // Export via background tracker
 const { addTask: addExportTask } = useExportTracker();
 
-const needsSchema = computed(() => isSchemaAware(props.connection.db_type));
+const needsSchema = computed(
+  () => isSchemaAware(props.connection.db_type) && !connectionUsesDatabaseObjectTreeMode(props.connection),
+);
 const tableCount = computed(() => rows.value.filter((row) => row.type === "TABLE").length);
 const viewCount = computed(() => rows.value.filter((row) => row.type === "VIEW").length);
 const procedureCount = computed(() => rows.value.filter((row) => row.type === "PROCEDURE").length);
@@ -167,27 +173,27 @@ const functionCount = computed(() => rows.value.filter((row) => row.type === "FU
 const packageCount = computed(
   () => rows.value.filter((row) => row.type === "PACKAGE" || row.type === "PACKAGE_BODY").length,
 );
-const canOpenStructureEditor = computed(() => supportsTableStructureEditing(props.connection.db_type));
-const canOpenDiagram = computed(() => !!props.database && supportsSchemaDiagram(props.connection.db_type));
-const canOpenTableImport = computed(() => !!props.database && supportsTableImport(props.connection.db_type));
-const supportsTruncateTable = computed(() => supportsTableTruncate(props.connection.db_type));
+const canOpenStructureEditor = computed(() => supportsTableStructureEditing(effectiveDatabaseType.value));
+const canOpenDiagram = computed(() => !!props.database && supportsSchemaDiagram(effectiveDatabaseType.value));
+const canOpenTableImport = computed(() => !!props.database && supportsTableImport(effectiveDatabaseType.value));
+const supportsTruncateTable = computed(() => supportsTableTruncate(effectiveDatabaseType.value));
 const sourceDialect = computed<"mysql" | "postgres" | "sqlserver">(() => {
   if (
-    props.connection.db_type === "postgres" ||
-    props.connection.db_type === "gaussdb" ||
-    props.connection.db_type === "opengauss"
+    effectiveDatabaseType.value === "postgres" ||
+    effectiveDatabaseType.value === "gaussdb" ||
+    effectiveDatabaseType.value === "opengauss"
   )
     return "postgres";
-  if (props.connection.db_type === "sqlserver") return "sqlserver";
+  if (effectiveDatabaseType.value === "sqlserver") return "sqlserver";
   return "mysql";
 });
 const sourceFormatDialect = computed<SqlFormatDialect>(() => {
-  switch (props.connection.db_type) {
+  switch (effectiveDatabaseType.value) {
     case "mysql":
     case "postgres":
     case "sqlite":
     case "sqlserver":
-      return props.connection.db_type;
+      return effectiveDatabaseType.value;
     case "gaussdb":
     case "opengauss":
       return "postgres";
@@ -348,8 +354,8 @@ function canOpenSource(row: ObjectBrowserRow) {
 
 function canRename(row: ObjectBrowserRow) {
   return (
-    supportsObjectRename(props.connection.db_type, row.type) ||
-    supportsSourceBackedRoutineRename(props.connection.db_type, row.type as ObjectSourceKind)
+    supportsObjectRename(effectiveDatabaseType.value, row.type) ||
+    supportsSourceBackedRoutineRename(effectiveDatabaseType.value, row.type as ObjectSourceKind)
   );
 }
 
@@ -414,7 +420,7 @@ async function openViewDdl(row: ObjectBrowserRow) {
       "VIEW",
     );
     const ddl = await buildViewDdl({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       schema: row.schema || selectedSchema.value || props.database,
       name: row.name,
       source: result.source,
@@ -431,7 +437,7 @@ async function openNewQuery(row: ObjectBrowserRow) {
   queryStore.updateSql(
     tabId,
     await buildTableSelectSql({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       schema: row.schema || selectedSchema.value,
       tableName: row.name,
       limit: 100,
@@ -485,13 +491,13 @@ async function refreshRenamePreviewSql() {
     renamePreviewSqlText.value = "";
     return;
   }
-  if (supportsSourceBackedRoutineRename(props.connection.db_type, row.type as ObjectSourceKind)) {
+  if (supportsSourceBackedRoutineRename(effectiveDatabaseType.value, row.type as ObjectSourceKind)) {
     renamePreviewSqlText.value = `-- Recreate ${row.type} from source, then drop the original object.`;
     return;
   }
   try {
     const sql = await buildRenameObjectSql({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       objectType: row.type,
       schema: row.schema || selectedSchema.value,
       oldName: row.name,
@@ -514,7 +520,7 @@ async function confirmRename() {
   renameError.value = "";
   try {
     const schema = row.schema || selectedSchema.value || props.database;
-    if (supportsSourceBackedRoutineRename(props.connection.db_type, row.type as ObjectSourceKind)) {
+    if (supportsSourceBackedRoutineRename(effectiveDatabaseType.value, row.type as ObjectSourceKind)) {
       const source = await api.getObjectSource(
         props.connection.id,
         props.database,
@@ -523,7 +529,7 @@ async function confirmRename() {
         row.type as ObjectSourceKind,
       );
       const statements = await buildRoutineRenameObjectSourceStatements({
-        databaseType: props.connection.db_type,
+        databaseType: effectiveDatabaseType.value,
         objectType: row.type as ObjectSourceKind,
         schema,
         name: row.name,
@@ -535,7 +541,7 @@ async function confirmRename() {
       }
     } else {
       const sql = await buildRenameObjectSql({
-        databaseType: props.connection.db_type,
+        databaseType: effectiveDatabaseType.value,
         objectType: row.type,
         schema,
         oldName: row.name,
@@ -562,7 +568,7 @@ async function confirmDrop() {
   const row = dropTarget.value;
   try {
     const sql = await buildDropObjectSql({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       objectType: row.type,
       schema: row.schema || selectedSchema.value,
       name: row.name,
@@ -727,7 +733,7 @@ async function refreshBatchDropPreviewSql() {
   const statements: string[] = [];
   for (const row of selectedTableRows.value) {
     const sql = await buildDropObjectSql({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       objectType: "TABLE",
       schema: row.schema || selectedSchema.value,
       name: row.name,
@@ -750,7 +756,7 @@ async function confirmBatchDropTables() {
   try {
     for (const row of targets) {
       const sql = await buildDropObjectSql({
-        databaseType: props.connection.db_type,
+        databaseType: effectiveDatabaseType.value,
         objectType: "TABLE",
         schema: row.schema || selectedSchema.value,
         name: row.name,
@@ -786,7 +792,7 @@ async function exportDataLegacy(row: ObjectBrowserRow, format: "json" | "sql") {
           )
         : undefined;
     const result = await fetchTableDataForExport({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       schema,
       tableName: row.name,
       columns: queryColumns,
@@ -810,7 +816,7 @@ async function exportDataLegacy(row: ObjectBrowserRow, format: "json" | "sql") {
     }
 
     const content = await formatSqlInsert({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       schema,
       tableName: row.name,
       columns: result.columns,
@@ -916,7 +922,7 @@ async function confirmDuplicateStructure() {
   try {
     const schema = row.schema || selectedSchema.value;
     const sql = await buildDuplicateTableStructureSql({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       schema,
       sourceName: row.name,
       targetName: newName,
@@ -932,7 +938,7 @@ async function confirmDuplicateStructure() {
 
 function tableAdminSqlOptions(row: ObjectBrowserRow): TableAdminSqlOptions {
   return {
-    databaseType: props.connection.db_type,
+    databaseType: effectiveDatabaseType.value,
     schema: row.schema || selectedSchema.value,
     tableName: row.name,
   };
@@ -1026,14 +1032,14 @@ async function saveSource() {
   sourceSaveError.value = "";
   try {
     const statements = await buildExecutableObjectSourceStatements({
-      databaseType: props.connection.db_type,
+      databaseType: effectiveDatabaseType.value,
       objectType: row.type as ObjectSourceKind,
       schema,
       name: row.name,
       source: sourceDraft.value,
     });
     for (const sql of statements) {
-      if (objectSourceSaveExecutionMode(props.connection.db_type) === "single") {
+      if (objectSourceSaveExecutionMode(effectiveDatabaseType.value) === "single") {
         await api.executeQuery(props.connection.id, props.database, sql, schema);
       } else {
         await api.executeScript(props.connection.id, props.database, sql, schema);
diff --git a/apps/desktop/src/components/sidebar/ConnectionTree.vue b/apps/desktop/src/components/sidebar/ConnectionTree.vue
index d5f7ecc74f..abd3b5922b 100644
--- a/apps/desktop/src/components/sidebar/ConnectionTree.vue
+++ b/apps/desktop/src/components/sidebar/ConnectionTree.vue
@@ -9,6 +9,7 @@ import type { QueryTab, TreeNode, TreeNodeType } from "@/types/database";
 import { filterSidebarSearchRootsByConnectionState, filterSidebarTree } from "@/lib/sidebarSearchTree";
 import { isCancelSearchShortcut } from "@/lib/keyboardShortcuts";
 import { usesTreeSchemaMode } from "@/lib/databaseFeatureSupport";
+import { connectionUsesDatabaseObjectTreeMode } from "@/lib/jdbcDialect";
 import {
   findSidebarNodeForActiveTab,
   findNodePathForActiveTab,
@@ -277,7 +278,7 @@ async function ensureTreeLoadedForTab(tab: QueryTab) {
   try {
     if (config.db_type === "sqlserver") {
       await store.loadSqlServerDatabaseObjects(connId, tab.database);
-    } else if (usesTreeSchemaMode(config.db_type)) {
+    } else if (usesTreeSchemaMode(config.db_type) && !connectionUsesDatabaseObjectTreeMode(config)) {
       await store.loadSchemas(connId, tab.database);
       // If we have a schema, also load tables under that schema
       if (tab.schema) {
diff --git a/apps/desktop/src/components/sidebar/TreeItem.vue b/apps/desktop/src/components/sidebar/TreeItem.vue
index 05d7725ca9..a4ef7568e1 100644
--- a/apps/desktop/src/components/sidebar/TreeItem.vue
+++ b/apps/desktop/src/components/sidebar/TreeItem.vue
@@ -116,6 +116,11 @@ import { buildRenameObjectSql, supportsObjectRename, type RenameableObjectType }
 import { buildRoutineRenameObjectSourceStatements, supportsSourceBackedRoutineRename } from "@/lib/objectSourceEditor";
 import { buildViewDdl } from "@/lib/viewDdl";
 import { getTableStructureCapabilities } from "@/lib/tableStructureCapabilities";
+import {
+  connectionObjectTreeQuerySchema,
+  connectionUsesDatabaseObjectTreeMode,
+  effectiveDatabaseTypeForConnection,
+} from "@/lib/jdbcDialect";
 import { hexToRgba } from "@/lib/color";
 import { focusSidebarRenameInput } from "@/lib/sidebarRenameFocus";
 import { hasTreeNodeDatabaseContext } from "@/lib/treeNodeContext";
@@ -187,9 +192,21 @@ const labelWidthClass = computed(() =>
 );
 
 function currentDatabaseType(): DatabaseType | undefined {
+  return props.node.connectionId
+    ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(props.node.connectionId))
+    : undefined;
+}
+
+function rawDatabaseType(): DatabaseType | undefined {
   return props.node.connectionId ? connectionStore.getConfig(props.node.connectionId)?.db_type : undefined;
 }
 
+function databaseTypeForNode(node: TreeNode): DatabaseType | undefined {
+  return node.connectionId
+    ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(node.connectionId))
+    : undefined;
+}
+
 function hasNodeDatabaseContext(node: TreeNode): node is TreeNode & { connectionId: string; database: string } {
   return !!node.connectionId && hasTreeNodeDatabaseContext(node);
 }
@@ -370,7 +387,7 @@ async function toggle() {
       const config = connectionStore.getConfig(node.connectionId);
       if (config?.db_type === "sqlserver") {
         await connectionStore.loadSqlServerDatabaseObjects(node.connectionId, node.database);
-      } else if (usesTreeSchemaMode(config?.db_type)) {
+      } else if (usesTreeSchemaMode(config?.db_type) && !connectionUsesDatabaseObjectTreeMode(config)) {
         await connectionStore.loadSchemas(node.connectionId, node.database);
       } else {
         await connectionStore.loadTables(node.connectionId, node.database);
@@ -723,6 +740,7 @@ async function openData() {
     table: node.label,
     dbType: config?.db_type,
   });
+  const tableSchema = connectionUsesDatabaseObjectTreeMode(config) ? undefined : node.schema;
   const tabId = (() => {
     if (settingsStore.editorSettings.reuseDataTab) {
       const existing = queryStore.tabs.find(
@@ -730,12 +748,12 @@ async function openData() {
       );
       if (existing) {
         existing.title = node.label;
-        existing.schema = node.schema;
+        existing.schema = tableSchema;
         queryStore.activeTabId = existing.id;
         return existing.id;
       }
     }
-    return queryStore.createTab(node.connectionId, node.database, node.label, "data", node.schema);
+    return queryStore.createTab(node.connectionId, node.database, node.label, "data", tableSchema);
   })();
   console.info("[DBX][openData:tab-created]", { traceId, tabId, elapsed: elapsed() });
   queryStore.setExecuting(tabId, true);
@@ -746,11 +764,12 @@ async function openData() {
     console.info("[DBX][openData:ensure-connected:done]", { traceId, elapsed: elapsed() });
     if (!config) throw new Error("Connection config not found");
 
-    const querySchema = node.schema || node.database;
+    const querySchema = connectionObjectTreeQuerySchema(config, node.database, tableSchema);
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
     const limit = settingsStore.editorSettings.pageSize;
     const sql = await buildTableSelectSql({
-      databaseType: config.db_type,
-      schema: node.schema,
+      databaseType: effectiveDbType,
+      schema: tableSchema,
       tableName: node.label,
       columns: [],
       primaryKeys: [],
@@ -782,9 +801,9 @@ async function openData() {
           primaryKeys: columns.filter((column) => column.is_primary_key).map((column) => column.name),
           elapsed: elapsed(),
         });
-        const pks = editablePrimaryKeys(config.db_type, columns);
+        const pks = editablePrimaryKeys(effectiveDbType, columns);
         queryStore.setTableMeta(tabId, {
-          schema: node.schema,
+          schema: tableSchema,
           tableName: node.label,
           columns,
           primaryKeys: pks,
@@ -986,7 +1005,7 @@ function dropObjectSqlOptions(): DropObjectSqlOptions | null {
 function dropObjectSqlOptionsForNode(node: TreeNode): DropObjectSqlOptions | null {
   if (node.type !== "view" && node.type !== "procedure" && node.type !== "function") return null;
   return {
-    databaseType: node.connectionId ? connectionStore.getConfig(node.connectionId)?.db_type : undefined,
+    databaseType: databaseTypeForNode(node),
     objectType: node.type === "view" ? "VIEW" : node.type === "procedure" ? "PROCEDURE" : "FUNCTION",
     schema: node.schema,
     name: node.label,
@@ -1022,7 +1041,7 @@ function dropTableChildObjectSqlOptionsForNode(node: TreeNode): DropTableChildOb
   const name = tableChildDropObjectName(node).trim();
   if (!name) return null;
   return {
-    databaseType: node.connectionId ? connectionStore.getConfig(node.connectionId)?.db_type : undefined,
+    databaseType: databaseTypeForNode(node),
     objectType,
     schema: node.schema,
     tableName: node.tableName,
@@ -1138,7 +1157,7 @@ function viewObjectDdl() {
     .then(async (result) => {
       const connection = connectionStore.getConfig(node.connectionId!);
       const ddl = await buildViewDdl({
-        databaseType: connection?.db_type,
+        databaseType: effectiveDatabaseTypeForConnection(connection),
         schema,
         name: node.label,
         source: result.source,
@@ -1221,7 +1240,7 @@ function batchDropConfirmMessage(): string {
 async function dropSqlForTreeNode(node: TreeNode): Promise<string | null> {
   if (node.type === "table" && node.connectionId && node.database) {
     return buildDropTableSql({
-      databaseType: node.connectionId ? connectionStore.getConfig(node.connectionId)?.db_type : undefined,
+      databaseType: databaseTypeForNode(node),
       schema: node.schema,
       tableName: node.label,
     });
@@ -1454,7 +1473,7 @@ const canCreateTable = computed(() => {
   return (
     (props.node.type === "database" || props.node.type === "schema" || props.node.type === "group-tables") &&
     !!props.node.database &&
-    supportsTableStructureEditing(config?.db_type)
+    supportsTableStructureEditing(effectiveDatabaseTypeForConnection(config))
   );
 });
 
@@ -1482,12 +1501,18 @@ const canDropDatabase = computed(() => {
 
 const canCreateSchema = computed(() => {
   const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
-  return props.node.type === "database" && usesTreeSchemaMode(config?.db_type);
+  return (
+    props.node.type === "database" &&
+    usesTreeSchemaMode(config?.db_type) &&
+    !connectionUsesDatabaseObjectTreeMode(config)
+  );
 });
 
 const canDropSchema = computed(() => {
   const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
-  return props.node.type === "schema" && usesTreeSchemaMode(config?.db_type);
+  return (
+    props.node.type === "schema" && usesTreeSchemaMode(config?.db_type) && !connectionUsesDatabaseObjectTreeMode(config)
+  );
 });
 
 function tableAdminSqlOptions(): TableAdminSqlOptions {
@@ -1793,7 +1818,7 @@ async function confirmDuplicateStructure() {
   showDuplicateDialog.value = false;
   try {
     await connectionStore.ensureConnected(node.connectionId);
-    const databaseType = connectionStore.getConfig(node.connectionId)?.db_type;
+    const databaseType = databaseTypeForNode(node);
     const sql = await buildDuplicateTableStructureSql({
       databaseType,
       schema: node.schema,
@@ -2065,8 +2090,9 @@ async function exportDataLegacy(format: "csv" | "json" | "sql") {
             (column) => column.name,
           )
         : undefined;
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
     const result = await fetchTableDataForExport({
-      databaseType: config.db_type,
+      databaseType: effectiveDbType,
       schema: node.schema,
       tableName: node.label,
       columns: queryColumns,
@@ -2106,7 +2132,7 @@ async function exportDataLegacy(format: "csv" | "json" | "sql") {
     }
 
     const content = await formatSqlInsert({
-      databaseType: config.db_type,
+      databaseType: effectiveDbType,
       schema: node.schema,
       tableName: node.label,
       columns: result.columns,
@@ -2335,36 +2361,31 @@ const canExpand = computed(() =>
     childCount: props.node.children?.length ?? 0,
   }),
 );
-const nodeConfig = computed(() =>
-  props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined,
-);
 const canPin = computed(() => pinnableTypes.has(props.node.type));
 const canOpenSqlFileExecution = computed(() => {
-  return supportsSqlFileExecution(nodeConfig.value?.db_type);
+  return supportsSqlFileExecution(rawDatabaseType());
 });
 const canOpenDiagram = computed(() => {
-  return !!props.node.database && supportsSchemaDiagram(nodeConfig.value?.db_type);
+  return !!props.node.database && supportsSchemaDiagram(currentDatabaseType());
 });
 const canOpenDatabaseSearch = computed(() => {
-  return !!props.node.database && supportsDatabaseSearch(nodeConfig.value?.db_type);
+  return !!props.node.database && supportsDatabaseSearch(currentDatabaseType());
 });
 const canOpenObjectBrowser = computed(() => {
-  return supportsObjectBrowserTreeNode(nodeConfig.value?.db_type, props.node.type);
+  return supportsObjectBrowserTreeNode(rawDatabaseType(), props.node.type);
 });
 const canOpenTableImport = computed(() => {
-  return props.node.type === "table" && !!props.node.database && supportsTableImport(nodeConfig.value?.db_type);
+  return props.node.type === "table" && !!props.node.database && supportsTableImport(currentDatabaseType());
 });
 const canOpenStructureEditor = computed(() => {
-  return (
-    props.node.type === "table" && !!props.node.database && supportsTableStructureEditing(nodeConfig.value?.db_type)
-  );
+  return props.node.type === "table" && !!props.node.database && supportsTableStructureEditing(currentDatabaseType());
 });
 const canOpenFieldLineage = computed(() => {
   return (
     props.node.type === "column" &&
     !!props.node.database &&
     !!props.node.tableName &&
-    supportsFieldLineage(nodeConfig.value?.db_type)
+    supportsFieldLineage(currentDatabaseType())
   );
 });
 const isPinned = computed(() => props.node.pinned || connectionStore.isTreeNodePinned(props.node.id));
diff --git a/apps/desktop/src/components/structure/TableStructureEditor.vue b/apps/desktop/src/components/structure/TableStructureEditor.vue
index 415588eb28..d75dd5343c 100644
--- a/apps/desktop/src/components/structure/TableStructureEditor.vue
+++ b/apps/desktop/src/components/structure/TableStructureEditor.vue
@@ -35,6 +35,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip
 import { SearchableSelect } from "@/components/ui/searchable-select";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
 import { useHistoryStore } from "@/stores/historyStore";
 import { useSettingsStore, type StructureEditorDensity } from "@/stores/settingsStore";
 import { useTheme } from "@/composables/useTheme";
@@ -44,6 +45,7 @@ import { copyToClipboard } from "@/lib/clipboard";
 import { queryTimeoutSecsForConnection } from "@/lib/queryTimeout";
 import { type EditableStructureColumn, type EditableStructureIndex } from "@/lib/tableStructureEditorSql";
 import { getTableStructureCapabilities } from "@/lib/tableStructureCapabilities";
+import { connectionObjectTreeQuerySchema, effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect";
 import {
   buildStructureTargetLabel,
   combineDataTypeForDatabase,
@@ -60,6 +62,7 @@ import * as api from "@/lib/api";
 const { t } = useI18n();
 const { isDark } = useTheme();
 const store = useConnectionStore();
+const queryStore = useQueryStore();
 const historyStore = useHistoryStore();
 const settingsStore = useSettingsStore();
 const { toast } = useToast();
@@ -283,7 +286,7 @@ function onIndexColResize(e: MouseEvent, col: number) {
 }
 
 const connection = computed(() => (props.connectionId ? store.getConfig(props.connectionId) : undefined));
-const databaseType = computed(() => connection.value?.db_type);
+const databaseType = computed(() => effectiveDatabaseTypeForConnection(connection.value));
 const structureCapabilities = computed(() => getTableStructureCapabilities(databaseType.value));
 const structureDialect = computed(() => structureCapabilities.value.dialect);
 const isTableCommentDisabled = computed(() => !structureCapabilities.value.comment);
@@ -355,7 +358,12 @@ const indexColLabels = computed(() => [
   t("structureEditor.comment"),
   t("structureEditor.actions"),
 ]);
-const targetSchema = computed(() => props.schema || props.database || "");
+const metadataSchema = computed(() => connectionObjectTreeQuerySchema(connection.value, props.database, props.schema));
+const refreshVersion = computed(() =>
+  props.connectionId && props.tableName
+    ? queryStore.tableStructureRefreshVersion(props.connectionId, props.database, props.schema, props.tableName)
+    : 0,
+);
 const isCreateMode = computed(() => !props.tableName);
 const newTableName = ref("");
 const tableComment = ref("");
@@ -434,18 +442,18 @@ async function loadStructure(silent = false) {
   errorMessage.value = "";
   try {
     await store.ensureConnected(props.connectionId);
-    const nextColumns = await api.getColumns(props.connectionId, props.database, targetSchema.value, props.tableName);
+    const nextColumns = await api.getColumns(props.connectionId, props.database, metadataSchema.value, props.tableName);
     const [nextIndexes, nextForeignKeys, nextTriggers] = await Promise.all([
-      api.listIndexes(props.connectionId, props.database, targetSchema.value, props.tableName).catch(() => []),
-      api.listForeignKeys(props.connectionId, props.database, targetSchema.value, props.tableName).catch(() => []),
-      api.listTriggers(props.connectionId, props.database, targetSchema.value, props.tableName).catch(() => []),
+      api.listIndexes(props.connectionId, props.database, metadataSchema.value, props.tableName).catch(() => []),
+      api.listForeignKeys(props.connectionId, props.database, metadataSchema.value, props.tableName).catch(() => []),
+      api.listTriggers(props.connectionId, props.database, metadataSchema.value, props.tableName).catch(() => []),
     ]);
     columns.value = createColumnDrafts(nextColumns, databaseType.value);
     indexes.value = createIndexDrafts(nextIndexes);
     foreignKeys.value = nextForeignKeys;
     triggers.value = nextTriggers;
     try {
-      const tables = await api.listTables(props.connectionId, props.database, targetSchema.value);
+      const tables = await api.listTables(props.connectionId, props.database, metadataSchema.value);
       const table = tables.find(
         (t) => t.name.toLowerCase() === props.tableName!.toLowerCase() && t.table_type !== "VIEW",
       );
@@ -746,7 +754,10 @@ onMounted(() => {
   void loadStructure();
 });
 
-onActivated(registerStructureEditorShortcuts);
+onActivated(() => {
+  registerStructureEditorShortcuts();
+  if (!isCreateMode.value) void loadStructure(true);
+});
 onDeactivated(unregisterStructureEditorShortcuts);
 onBeforeUnmount(() => {
   unregisterStructureEditorShortcuts();
@@ -759,6 +770,11 @@ watch(
   },
   { deep: true, immediate: true },
 );
+
+watch(refreshVersion, (version, previous) => {
+  if (version === previous || !version || isCreateMode.value) return;
+  void loadStructure(true);
+});
 </script>
 
 <template>
diff --git a/apps/desktop/src/composables/useDataGridActions.ts b/apps/desktop/src/composables/useDataGridActions.ts
index b292f3b038..dd834ad473 100644
--- a/apps/desktop/src/composables/useDataGridActions.ts
+++ b/apps/desktop/src/composables/useDataGridActions.ts
@@ -9,6 +9,7 @@ import { tableMetaForDataTab } from "@/lib/tableDataTabMeta";
 import * as api from "@/lib/api";
 import type { QueryTab } from "@/types/database";
 import { useToast } from "@/composables/useToast";
+import { effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect";
 
 export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>) {
   const { t } = useI18n();
@@ -19,7 +20,7 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
 
   function quoteIdent(tab: QueryTab, name: string): string {
     const config = connectionStore.getConfig(tab.connectionId);
-    return quoteTableIdentifier(config?.db_type, name);
+    return quoteTableIdentifier(effectiveDatabaseTypeForConnection(config), name);
   }
 
   function buildTableSql(
@@ -27,20 +28,21 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
     options: { orderBy?: string; limit?: number; offset?: number; whereInput?: string } = {},
   ): Promise<string> {
     const config = connectionStore.getConfig(tab.connectionId);
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
     const tableMeta = tableMetaForDataTab(tab);
     const primaryKeys = tab.tableMeta
-      ? editablePrimaryKeys(config?.db_type, tab.tableMeta.columns)
+      ? editablePrimaryKeys(effectiveDbType, tab.tableMeta.columns)
       : (tableMeta?.primaryKeys ?? []);
     if (tab.tableMeta && primaryKeys.join("\0") !== tab.tableMeta.primaryKeys.join("\0")) {
       tab.tableMeta.primaryKeys = primaryKeys;
     }
     const fallbackOrderColumns =
-      config?.db_type === "sqlserver" && !primaryKeys.length
+      effectiveDbType === "sqlserver" && !primaryKeys.length
         ? tableMeta?.columns.slice(0, 1).map((column) => column.name)
         : undefined;
-    const useRowId = usesSyntheticRowIdKey(config?.db_type, primaryKeys);
+    const useRowId = usesSyntheticRowIdKey(effectiveDbType, primaryKeys);
     return buildTableSelectSql({
-      databaseType: config?.db_type,
+      databaseType: effectiveDbType,
       schema: tableMeta?.schema,
       tableName: tableMeta?.tableName ?? "",
       columns: tableMeta?.columns.map((column) => column.name),
@@ -166,7 +168,7 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
     const config = connectionStore.getConfig(tab.connectionId);
     const built = await api.buildSortedQuerySql({
       originalSql: baseSql,
-      databaseType: config?.db_type,
+      databaseType: effectiveDatabaseTypeForConnection(config),
       resultColumns: tab.result?.columns ?? [],
       columnIndex,
       column,
diff --git a/apps/desktop/src/composables/useNavigationTargets.ts b/apps/desktop/src/composables/useNavigationTargets.ts
index 234db61ae2..abacd96dd3 100644
--- a/apps/desktop/src/composables/useNavigationTargets.ts
+++ b/apps/desktop/src/composables/useNavigationTargets.ts
@@ -1,4 +1,5 @@
 import * as api from "@/lib/api";
+import { connectionObjectTreeQuerySchema, effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect";
 import { buildTableSelectSql } from "@/lib/tableSelectSql";
 import { editablePrimaryKeys, usesSyntheticRowIdKey } from "@/lib/tableEditing";
 import { useConnectionStore } from "@/stores/connectionStore";
@@ -42,12 +43,13 @@ async function openTableTarget(target: NavigationTarget) {
   try {
     await connectionStore.ensureConnected(target.connectionId);
     if (!config) throw new Error("Connection config not found");
-    const querySchema = target.schema || target.database;
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+    const querySchema = connectionObjectTreeQuerySchema(config, target.database, target.schema);
     if (config.db_type === "neo4j") {
       const columns = await api.getColumns(target.connectionId, target.database, querySchema, target.tableName);
-      const primaryKeys = editablePrimaryKeys(config.db_type, columns);
+      const primaryKeys = editablePrimaryKeys(effectiveDbType, columns);
       const sql = await buildTableSelectSql({
-        databaseType: config.db_type,
+        databaseType: effectiveDbType,
         schema: target.schema,
         tableName: target.tableName,
         columns: columns.map((column) => column.name),
@@ -66,7 +68,7 @@ async function openTableTarget(target: NavigationTarget) {
       return;
     }
     const sql = await buildTableSelectSql({
-      databaseType: config.db_type,
+      databaseType: effectiveDbType,
       schema: target.schema,
       tableName: target.tableName,
       whereInput: target.whereInput,
@@ -84,8 +86,8 @@ async function openTableTarget(target: NavigationTarget) {
     const [columnsResult, dataResult] = await Promise.allSettled([columnsPromise, dataPromise]);
     if (columnsResult.status === "fulfilled") {
       const columns = columnsResult.value;
-      const primaryKeys = editablePrimaryKeys(config.db_type, columns);
-      const useRowId = usesSyntheticRowIdKey(config.db_type, primaryKeys);
+      const primaryKeys = editablePrimaryKeys(effectiveDbType, columns);
+      const useRowId = usesSyntheticRowIdKey(effectiveDbType, primaryKeys);
       queryStore.setTableMeta(tabId, {
         schema: target.schema,
         tableName: target.tableName,
@@ -94,7 +96,7 @@ async function openTableTarget(target: NavigationTarget) {
       });
       if (useRowId || config.db_type === "tdengine") {
         const newSql = await buildTableSelectSql({
-          databaseType: config.db_type,
+          databaseType: effectiveDbType,
           schema: target.schema,
           tableName: target.tableName,
           whereInput: target.whereInput,
@@ -157,21 +159,26 @@ export function useNavigationTargets(dialogs: {
         );
       } catch {}
     }
-    const activeTab = queryStore.tabs.find((t) => t.id === queryStore.activeTabId);
-    if (activeTab?.mode === "data" && activeTab.tableMeta?.tableName === context.tableName) {
+    queryStore.invalidateTableStructure(context.connectionId, context.database, context.schema, context.tableName);
+    const matchingDataTabs = queryStore.tabs.filter(
+      (tab) =>
+        tab.mode === "data" &&
+        tab.connectionId === context.connectionId &&
+        tab.database === context.database &&
+        tab.tableMeta?.tableName === context.tableName &&
+        (tab.tableMeta.schema || "") === (context.schema || ""),
+    );
+    for (const tab of matchingDataTabs) {
       try {
-        const columns = await api.getColumns(
-          activeTab.connectionId,
-          activeTab.database,
-          activeTab.tableMeta.schema || activeTab.database,
-          activeTab.tableMeta.tableName,
-        );
-        queryStore.setTableMeta(activeTab.id, {
-          ...activeTab.tableMeta,
+        const connection = connectionStore.getConfig(tab.connectionId);
+        const metadataSchema = connectionObjectTreeQuerySchema(connection, tab.database, tab.tableMeta?.schema);
+        const columns = await api.getColumns(tab.connectionId, tab.database, metadataSchema, tab.tableMeta!.tableName);
+        queryStore.setTableMeta(tab.id, {
+          ...tab.tableMeta!,
           columns,
-          primaryKeys: editablePrimaryKeys(connectionStore.getConfig(activeTab.connectionId)?.db_type, columns),
+          primaryKeys: editablePrimaryKeys(effectiveDatabaseTypeForConnection(connection), columns),
         });
-        await reloadData();
+        if (tab.id === queryStore.activeTabId) await reloadData();
       } catch (e: any) {
         toast(e?.message || String(e), 5000);
       }
diff --git a/apps/desktop/src/lib/databaseCapabilitySets.ts b/apps/desktop/src/lib/databaseCapabilitySets.ts
index cebefe8bd7..d043c8221b 100644
--- a/apps/desktop/src/lib/databaseCapabilitySets.ts
+++ b/apps/desktop/src/lib/databaseCapabilitySets.ts
@@ -23,6 +23,7 @@ export const SCHEMA_AWARE_TYPES = new Set<DatabaseType>([
   "h2",
   "snowflake",
   "trino",
+  "hive",
   "db2",
   "tdengine",
   "xugu",
@@ -213,6 +214,8 @@ export const TREE_SCHEMA_TYPES = new Set<DatabaseType>([
   "duckdb",
 ]);
 
+export const DATABASE_OBJECT_TREE_TYPES = new Set<DatabaseType>(["jdbc"]);
+
 export const PG_LIKE_STRUCTURE_TYPES = new Set<DatabaseType>(["postgres", "redshift", "gaussdb", "opengauss"]);
 
 export const AGENT_DRIVER_TYPES = new Set<DatabaseType>([
diff --git a/apps/desktop/src/lib/databaseFeatureSupport.ts b/apps/desktop/src/lib/databaseFeatureSupport.ts
index 4be10e89b0..53ca922327 100644
--- a/apps/desktop/src/lib/databaseFeatureSupport.ts
+++ b/apps/desktop/src/lib/databaseFeatureSupport.ts
@@ -4,6 +4,7 @@ import {
   AGENT_DRIVER_TYPES,
   CREATE_DATABASE_SUPPORTED_TYPES,
   DATABASE_SEARCH_SUPPORTED_TYPES,
+  DATABASE_OBJECT_TREE_TYPES,
   DIAGRAM_SUPPORTED_TYPES,
   FETCH_FIRST_TYPES,
   FIELD_LINEAGE_SUPPORTED_TYPES,
@@ -24,6 +25,29 @@ export function usesTreeSchemaMode(dbType?: DatabaseType): boolean {
   return !!dbType && TREE_SCHEMA_TYPES.has(dbType);
 }
 
+export function usesDatabaseObjectTreeMode(dbType?: DatabaseType): boolean {
+  return !!dbType && DATABASE_OBJECT_TREE_TYPES.has(dbType);
+}
+
+export function databaseObjectTreeQuerySchema(
+  dbType: DatabaseType | undefined,
+  database: string,
+  schema?: string,
+): string {
+  if (usesDatabaseObjectTreeMode(dbType)) return "";
+  return schema || database;
+}
+
+export function databaseObjectTreeNodeSchema(
+  dbType: DatabaseType | undefined,
+  database: string,
+  schema?: string,
+): string | undefined {
+  if (usesDatabaseObjectTreeMode(dbType)) return undefined;
+  if (schema) return schema;
+  return isSchemaAware(dbType) ? database : undefined;
+}
+
 export function isSingleDatabase(dbType?: DatabaseType): boolean {
   return !!dbType && SINGLE_DATABASE_TYPES.has(dbType);
 }
@@ -74,6 +98,7 @@ export function supportsObjectBrowser(dbType?: DatabaseType): boolean {
 
 export function supportsObjectBrowserTreeNode(dbType: DatabaseType | undefined, nodeType: TreeNodeType): boolean {
   if (!supportsObjectBrowser(dbType)) return false;
+  if (nodeType === "database" && usesDatabaseObjectTreeMode(dbType)) return true;
   if (nodeType === "database" && isSchemaAware(dbType) && dbType !== "sqlserver") return false;
   return nodeType === "database" || nodeType === "schema" || nodeType === "object-browser";
 }
diff --git a/apps/desktop/src/lib/jdbcDialect.ts b/apps/desktop/src/lib/jdbcDialect.ts
new file mode 100644
index 0000000000..05469848c4
--- /dev/null
+++ b/apps/desktop/src/lib/jdbcDialect.ts
@@ -0,0 +1,70 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { isSchemaAware, usesDatabaseObjectTreeMode } from "@/lib/databaseFeatureSupport";
+
+const JDBC_DIALECT_MATCHERS: Array<{ type: DatabaseType; patterns: RegExp[] }> = [
+  { type: "starrocks", patterns: [/starrocks/i] },
+  { type: "doris", patterns: [/doris/i] },
+  { type: "hive", patterns: [/org\.apache\.hive\.jdbc\.HiveDriver/i, /hive-jdbc/i] },
+  { type: "mysql", patterns: [/jdbc:mysql:/i, /mysql/i, /mariadb/i, /kyuubi/i, /hive2/i] },
+  { type: "postgres", patterns: [/jdbc:postgresql:/i, /postgres/i] },
+  { type: "sqlserver", patterns: [/jdbc:sqlserver:/i, /sqlserver/i, /mssql/i] },
+  { type: "oracle", patterns: [/jdbc:oracle:/i, /oracle/i] },
+  { type: "clickhouse", patterns: [/jdbc:clickhouse:/i, /clickhouse/i] },
+  { type: "h2", patterns: [/jdbc:h2:/i, /\bh2\b/i] },
+  { type: "sqlite", patterns: [/jdbc:sqlite:/i, /sqlite/i] },
+  { type: "db2", patterns: [/jdbc:db2:/i, /\bdb2\b/i] },
+  { type: "informix", patterns: [/jdbc:informix/i, /informix/i] },
+];
+
+export function inferJdbcDialect(
+  connection?: Pick<ConnectionConfig, "db_type" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">,
+): DatabaseType | undefined {
+  if (!connection || connection.db_type !== "jdbc") return undefined;
+  const haystack = [connection.connection_string, connection.jdbc_driver_class, ...(connection.jdbc_driver_paths ?? [])]
+    .filter(Boolean)
+    .join("\n");
+  if (!haystack) return undefined;
+  return JDBC_DIALECT_MATCHERS.find((matcher) => matcher.patterns.some((pattern) => pattern.test(haystack)))?.type;
+}
+
+export function effectiveDatabaseTypeForConnection(
+  connection?: Pick<ConnectionConfig, "db_type" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">,
+): DatabaseType | undefined {
+  if (!connection) return undefined;
+  if (connection.db_type !== "jdbc") return connection.db_type;
+  return inferJdbcDialect(connection) ?? "jdbc";
+}
+
+export function connectionUsesDatabaseObjectTreeMode(
+  connection?: Pick<ConnectionConfig, "db_type" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">,
+): boolean {
+  if (!connection) return false;
+  if (connection.db_type !== "jdbc") return usesDatabaseObjectTreeMode(connection.db_type);
+  const dialect = inferJdbcDialect(connection);
+  if (dialect === "hive" || dialect === "trino") return false;
+  return true;
+}
+
+export function connectionObjectTreeQuerySchema(
+  connection:
+    | Pick<ConnectionConfig, "db_type" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">
+    | undefined,
+  database: string,
+  schema?: string,
+): string {
+  if (connectionUsesDatabaseObjectTreeMode(connection)) return "";
+  return schema || database;
+}
+
+export function connectionObjectTreeNodeSchema(
+  connection:
+    | Pick<ConnectionConfig, "db_type" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">
+    | undefined,
+  database: string,
+  schema?: string,
+): string | undefined {
+  if (connectionUsesDatabaseObjectTreeMode(connection)) return undefined;
+  if (schema) return schema;
+  const type = connection?.db_type === "jdbc" ? effectiveDatabaseTypeForConnection(connection) : connection?.db_type;
+  return isSchemaAware(type) ? database : undefined;
+}
diff --git a/apps/desktop/src/lib/tableSelectSql.ts b/apps/desktop/src/lib/tableSelectSql.ts
index 84eb095895..7a2b699b77 100644
--- a/apps/desktop/src/lib/tableSelectSql.ts
+++ b/apps/desktop/src/lib/tableSelectSql.ts
@@ -1,5 +1,5 @@
 import type { DatabaseType } from "../types/database.ts";
-import { isSchemaAware } from "./databaseCapabilities.ts";
+import { isSchemaAware, usesDatabaseObjectTreeMode } from "./databaseCapabilities.ts";
 import * as api from "./api.ts";
 
 export interface BuildTableSelectSqlOptions {
@@ -39,7 +39,7 @@ export function qualifiedTableName(
   options: Pick<BuildTableSelectSqlOptions, "databaseType" | "schema" | "tableName">,
 ): string {
   const { databaseType, schema, tableName } = options;
-  if (isSchemaAware(databaseType) && schema) {
+  if (isSchemaAware(databaseType) && !usesDatabaseObjectTreeMode(databaseType) && schema) {
     return `${quoteTableIdentifier(databaseType, schema)}.${quoteTableIdentifier(databaseType, tableName)}`;
   }
   return quoteTableIdentifier(databaseType, tableName);
diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.ts
index 08e9e839d3..d1814d86e6 100644
--- a/apps/desktop/src/stores/connectionStore.ts
+++ b/apps/desktop/src/stores/connectionStore.ts
@@ -21,6 +21,11 @@ import type { SqlCompletionColumn, SqlCompletionObject, SqlCompletionTable } fro
 import * as api from "@/lib/api";
 import { isTauriRuntime } from "@/lib/tauriRuntime";
 import { isSchemaAware, usesTreeSchemaMode } from "@/lib/databaseCapabilities";
+import {
+  connectionObjectTreeNodeSchema,
+  connectionObjectTreeQuerySchema,
+  connectionUsesDatabaseObjectTreeMode,
+} from "@/lib/jdbcDialect";
 import {
   buildDatabaseTreeNodes,
   buildDuckDbConnectionTreeNodes,
@@ -1085,9 +1090,9 @@ export const useConnectionStore = defineStore("connection", () => {
         }
       }
 
-      const querySchema = schema || database;
       const config = getConfig(connectionId);
-      const effectiveSchema = schema || (config?.db_type && isSchemaAware(config.db_type) ? database : undefined);
+      const querySchema = connectionObjectTreeQuerySchema(config, database, schema);
+      const effectiveSchema = connectionObjectTreeNodeSchema(config, database, schema);
       const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
       let children: TreeNode[];
       if (simpleObjectDisplay) {
@@ -1202,7 +1207,7 @@ export const useConnectionStore = defineStore("connection", () => {
 
     node.isLoading = true;
     try {
-      const querySchema = schema || database;
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
       const columns = await api.getColumns(connectionId, database, querySchema, table);
       setChildren(
         node,
@@ -1237,7 +1242,7 @@ export const useConnectionStore = defineStore("connection", () => {
 
     node.isLoading = true;
     try {
-      const querySchema = schema || database;
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
       const indexes = await api.listIndexes(connectionId, database, querySchema, table);
       setChildren(
         node,
@@ -1278,7 +1283,7 @@ export const useConnectionStore = defineStore("connection", () => {
 
     node.isLoading = true;
     try {
-      const querySchema = schema || database;
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
       const fkeys = await api.listForeignKeys(connectionId, database, querySchema, table);
       setChildren(
         node,
@@ -1313,7 +1318,7 @@ export const useConnectionStore = defineStore("connection", () => {
 
     node.isLoading = true;
     try {
-      const querySchema = schema || database;
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
       const triggers = await api.listTriggers(connectionId, database, querySchema, table);
       setChildren(
         node,
@@ -1361,7 +1366,7 @@ export const useConnectionStore = defineStore("connection", () => {
       const config = getConfig(node.connectionId);
       if (config?.db_type === "sqlserver") {
         await loadSqlServerDatabaseObjects(node.connectionId, node.database, options);
-      } else if (usesTreeSchemaMode(config?.db_type)) {
+      } else if (usesTreeSchemaMode(config?.db_type) && !connectionUsesDatabaseObjectTreeMode(config)) {
         await loadSchemas(node.connectionId, node.database, options);
       } else {
         await loadTables(node.connectionId, node.database, undefined, options);
@@ -1462,6 +1467,10 @@ export const useConnectionStore = defineStore("connection", () => {
     return isSchemaAware(getConfig(connectionId)?.db_type);
   }
 
+  function metadataQuerySchema(connectionId: string, database: string, schema?: string): string {
+    return connectionObjectTreeQuerySchema(getConfig(connectionId), database, schema);
+  }
+
   const COMPLETION_CACHE_MAX = 50;
 
   function evictOldestCacheEntries(cache: Record<string, unknown>, max: number) {
@@ -1730,13 +1739,17 @@ export const useConnectionStore = defineStore("connection", () => {
     table: string,
     schema?: string,
   ): Promise<SqlCompletionColumn[]> {
-    if (isSchemaAwareDatabase(connectionId) && !schema) {
+    if (
+      isSchemaAwareDatabase(connectionId) &&
+      !connectionUsesDatabaseObjectTreeMode(getConfig(connectionId)) &&
+      !schema
+    ) {
       return [];
     }
     const cacheKey = `${connectionId}:${database}:${schema || ""}:${table}`;
     if (!completionColumnsCache.value[cacheKey]) {
       await ensureConnected(connectionId);
-      const querySchema = schema || database;
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
       completionColumnsCache.value[cacheKey] = await api.getColumns(connectionId, database, querySchema, table);
       evictOldestCacheEntries(completionColumnsCache.value, COMPLETION_CACHE_MAX);
     }
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
index d676dd6f83..d7ee4f10f8 100644
--- a/apps/desktop/src/stores/queryStore.ts
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -30,6 +30,7 @@ import { editablePrimaryKeys } from "@/lib/tableEditing";
 import { TABLE_DATA_EXPORT_PAGE_SIZE } from "@/lib/tableDataExport";
 import { tableMetaForDataTab } from "@/lib/tableDataTabMeta";
 import { quoteTableIdentifier } from "@/lib/tableSelectSql";
+import { connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect";
 import { queryTimeoutSecsForConnection } from "@/lib/queryTimeout";
 import * as api from "@/lib/api";
 import { useConnectionStore } from "@/stores/connectionStore";
@@ -117,6 +118,39 @@ export const useQueryStore = defineStore("query", () => {
   const restored = loadSavedTabs();
   const tabs = ref<QueryTab[]>(restored.tabs);
   const activeTabId = ref<string | null>(restored.activeTabId);
+  const tableStructureRefreshVersions = ref<Record<string, number>>({});
+
+  function tableStructureKey(
+    connectionId: string,
+    database: string,
+    schema: string | undefined,
+    tableName: string,
+  ): string {
+    return [connectionId, database, schema || "", tableName].map((part) => part.toLowerCase()).join("\u0000");
+  }
+
+  function invalidateTableStructure(
+    connectionId: string,
+    database: string,
+    schema: string | undefined,
+    tableName: string,
+  ) {
+    if (!tableName) return;
+    const key = tableStructureKey(connectionId, database, schema, tableName);
+    tableStructureRefreshVersions.value = {
+      ...tableStructureRefreshVersions.value,
+      [key]: (tableStructureRefreshVersions.value[key] ?? 0) + 1,
+    };
+  }
+
+  function tableStructureRefreshVersion(
+    connectionId: string,
+    database: string,
+    schema: string | undefined,
+    tableName: string,
+  ): number {
+    return tableStructureRefreshVersions.value[tableStructureKey(connectionId, database, schema, tableName)] ?? 0;
+  }
   const MAX_CACHED_RESULTS = 5;
 
   async function closeResultSession(tab: QueryTab | undefined, preserveSessionId?: string) {
@@ -810,6 +844,7 @@ export const useQueryStore = defineStore("query", () => {
       const connStore = useConnectionStore();
       await connStore.ensureConnected(tab.connectionId);
       const conn = connStore.getConfig(tab.connectionId);
+      const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
       const useAgentCursor = !!conn?.db_type && AGENT_DRIVER_TYPES.has(conn.db_type);
       const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
       const settingsStore = useSettingsStore();
@@ -819,7 +854,7 @@ export const useQueryStore = defineStore("query", () => {
         const plan = await api.prepareQueryPaginationExecutionPlan({
           sql,
           queryBaseSql,
-          databaseType: conn?.db_type,
+          databaseType: effectiveDbType,
           pagination,
           useAgentCursor,
         });
@@ -1015,7 +1050,8 @@ export const useQueryStore = defineStore("query", () => {
         ...(clientSessionId ? { clientSessionId } : {}),
         timeoutSecs: queryTimeoutSecs,
       };
-      const executionSchema = tab.mode === "data" ? undefined : tab.schema;
+      const executionSchema =
+        tab.mode === "data" || connectionUsesDatabaseObjectTreeMode(conn) ? undefined : tab.schema;
       const executionPromise = api.executeMulti(
         tab.connectionId,
         tab.database,
@@ -1304,16 +1340,17 @@ export const useQueryStore = defineStore("query", () => {
       if (!tableMeta?.tableName) return tab.result;
 
       const pageLimit = TABLE_DATA_EXPORT_PAGE_SIZE;
+      const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
       const primaryKeys = tab.tableMeta
-        ? editablePrimaryKeys(conn?.db_type, tab.tableMeta.columns)
+        ? editablePrimaryKeys(effectiveDbType, tab.tableMeta.columns)
         : tableMeta.primaryKeys;
       const fallbackOrderColumns =
-        conn?.db_type === "sqlserver" && !primaryKeys.length
+        effectiveDbType === "sqlserver" && !primaryKeys.length
           ? tableMeta.columns.slice(0, 1).map((column) => column.name)
           : undefined;
       const sortOrder =
         tab.resultSortColumn && tab.resultSortDirection
-          ? `${quoteTableIdentifier(conn?.db_type, tab.resultSortColumn)} ${tab.resultSortDirection.toUpperCase()}`
+          ? `${quoteTableIdentifier(effectiveDbType, tab.resultSortColumn)} ${tab.resultSortDirection.toUpperCase()}`
           : undefined;
       const orderBy = tab.orderByInput?.trim() || sortOrder;
       const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
@@ -1324,7 +1361,7 @@ export const useQueryStore = defineStore("query", () => {
 
       while (true) {
         const sql = await api.buildTableSelectSql({
-          databaseType: conn?.db_type,
+          databaseType: effectiveDbType,
           schema: tableMeta.schema,
           tableName: tableMeta.tableName,
           columns: tableMeta.columns.map((column) => column.name),
@@ -1367,6 +1404,7 @@ export const useQueryStore = defineStore("query", () => {
     const connStore = useConnectionStore();
     await connStore.ensureConnected(tab.connectionId);
     const conn = connStore.getConfig(tab.connectionId);
+    const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
     const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
     const useAgentCursor = !!conn?.db_type && AGENT_DRIVER_TYPES.has(conn.db_type);
     const queryBaseSql = tab.resultBaseSql ?? sql;
@@ -1383,7 +1421,7 @@ export const useQueryStore = defineStore("query", () => {
         const plan = await api.prepareQueryPaginationExecutionPlan({
           sql,
           queryBaseSql,
-          databaseType: conn?.db_type,
+          databaseType: effectiveDbType,
           pagination: { limit: pageLimit, offset, sessionId },
           useAgentCursor,
         });
@@ -1455,6 +1493,8 @@ export const useQueryStore = defineStore("query", () => {
     updateSchema,
     updateConnection,
     setTableMeta,
+    invalidateTableStructure,
+    tableStructureRefreshVersion,
     setObjectSource,
     setExecuting,
     setErrorResult,
diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rs
index 563facd254..1c97da0f41 100644
--- a/crates/dbx-core/src/query.rs
+++ b/crates/dbx-core/src/query.rs
@@ -660,7 +660,7 @@ pub async fn do_execute(
             let session = session.clone();
             let sql = sql.to_string();
             let schema = schema.map(str::to_string);
-            let database = config.effective_database().unwrap_or("").to_string();
+            let database = database.unwrap_or_else(|| config.effective_database().unwrap_or("")).to_string();
             let max_rows = options.max_rows;
             let plugin_timeout = query_timeout;
             drop(connections);
diff --git a/crates/dbx-core/src/sql_dialect.rs b/crates/dbx-core/src/sql_dialect.rs
index c50427b63e..bf9fe11acd 100644
--- a/crates/dbx-core/src/sql_dialect.rs
+++ b/crates/dbx-core/src/sql_dialect.rs
@@ -170,7 +170,10 @@ pub fn build_table_select_sql(options: TableSelectSqlOptions<'_>) -> String {
 }
 
 pub fn qualified_table_name(database_type: Option<DatabaseType>, schema: Option<&str>, table_name: &str) -> String {
-    if database_type.is_some_and(is_schema_aware) && schema.is_some_and(|schema| !schema.trim().is_empty()) {
+    if database_type.is_some_and(is_schema_aware)
+        && database_type != Some(DatabaseType::Jdbc)
+        && schema.is_some_and(|schema| !schema.trim().is_empty())
+    {
         return format!(
             "{}.{}",
             quote_table_identifier(database_type, schema.unwrap()),
@@ -358,6 +361,7 @@ pub fn is_schema_aware(database_type: DatabaseType) -> bool {
             | DatabaseType::H2
             | DatabaseType::Snowflake
             | DatabaseType::Trino
+            | DatabaseType::Hive
             | DatabaseType::Db2
             | DatabaseType::Tdengine
             | DatabaseType::DuckDb
@@ -405,10 +409,7 @@ mod tests {
     fn qualifies_schema_only_for_schema_aware_databases() {
         assert_eq!(qualified_table_name(Some(DatabaseType::Postgres), Some("public"), "users"), "\"public\".\"users\"");
         assert_eq!(qualified_table_name(Some(DatabaseType::Mysql), Some("public"), "users"), "`users`");
-        assert_eq!(
-            qualified_table_name(Some(DatabaseType::Jdbc), Some("cbsdw_dwd"), "dwd_test_df"),
-            "cbsdw_dwd.dwd_test_df"
-        );
+        assert_eq!(qualified_table_name(Some(DatabaseType::Jdbc), Some("cbsdw_dwd"), "dwd_test_df"), "dwd_test_df");
     }
 
     #[test]
@@ -447,7 +448,18 @@ mod tests {
                 order_columns: &[],
                 limit: 100,
             }),
-            "SELECT * FROM cbsdw_dwd.dwd_test_df LIMIT 100;"
+            "SELECT * FROM dwd_test_df LIMIT 100;"
+        );
+        assert_eq!(
+            build_table_select_sql(TableSelectSqlOptions {
+                database_type: Some(DatabaseType::Hive),
+                schema: Some("test"),
+                table_name: "dws_event_analyse",
+                columns: &[],
+                order_columns: &[],
+                limit: 100,
+            }),
+            "SELECT * FROM `test`.`dws_event_analyse` LIMIT 100;"
         );
         assert_eq!(
             build_table_select_sql(TableSelectSqlOptions {
diff --git a/packages/app-tests/databaseCapabilities.test.ts b/packages/app-tests/databaseCapabilities.test.ts
index dac6f8b743..e766d1406b 100644
--- a/packages/app-tests/databaseCapabilities.test.ts
+++ b/packages/app-tests/databaseCapabilities.test.ts
@@ -3,6 +3,8 @@ import test from "node:test";
 import {
   SCHEMA_AWARE_TYPES,
   TREE_SCHEMA_TYPES,
+  databaseObjectTreeNodeSchema,
+  databaseObjectTreeQuerySchema,
   getDatabaseCapability,
   supportsDatabaseCreation,
   supportsDatabaseSearch,
@@ -16,6 +18,7 @@ import {
   supportsTableTruncate,
   supportsTableStructureEditing,
   supportsTransfer,
+  usesDatabaseObjectTreeMode,
   usesPostgresLikeStructureCopy,
   usesTreeSchemaMode,
 } from "../../apps/desktop/src/lib/databaseCapabilities.ts";
@@ -78,6 +81,21 @@ test("describes schema tree mode through the capability helper", () => {
   assert.equal(usesTreeSchemaMode(undefined), false);
 });
 
+test("generic JDBC database nodes list objects directly under catalogs", () => {
+  assert.equal(TREE_SCHEMA_TYPES.has("jdbc"), true);
+  assert.equal(usesDatabaseObjectTreeMode("jdbc"), true);
+  assert.equal(databaseObjectTreeQuerySchema("jdbc", "test"), "");
+  assert.equal(databaseObjectTreeNodeSchema("jdbc", "test"), undefined);
+  assert.equal(databaseObjectTreeQuerySchema("jdbc", "test", "dataeye_starpony"), "");
+  assert.equal(databaseObjectTreeNodeSchema("jdbc", "test", "dataeye_starpony"), undefined);
+});
+
+test("schema tree databases still use database nodes as default schema context", () => {
+  assert.equal(usesDatabaseObjectTreeMode("postgres"), false);
+  assert.equal(databaseObjectTreeQuerySchema("postgres", "app"), "app");
+  assert.equal(databaseObjectTreeNodeSchema("postgres", "app"), "app");
+});
+
 test("treats Trino tables as schema-qualified SQL targets", () => {
   assert.equal(SCHEMA_AWARE_TYPES.has("trino"), true);
 });
@@ -210,5 +228,6 @@ test("object browser entry follows database tree shape", () => {
   assert.equal(supportsObjectBrowserTreeNode("sqlserver", "database"), true);
   assert.equal(supportsObjectBrowserTreeNode("sqlserver", "schema"), true);
   assert.equal(supportsObjectBrowserTreeNode("mysql", "database"), true);
+  assert.equal(supportsObjectBrowserTreeNode("jdbc", "database"), true);
   assert.equal(supportsObjectBrowserTreeNode("mongodb", "database"), false);
 });
diff --git a/packages/app-tests/jdbcDialect.test.ts b/packages/app-tests/jdbcDialect.test.ts
new file mode 100644
index 0000000000..30ac25ba8f
--- /dev/null
+++ b/packages/app-tests/jdbcDialect.test.ts
@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  connectionObjectTreeQuerySchema,
+  connectionUsesDatabaseObjectTreeMode,
+  effectiveDatabaseTypeForConnection,
+  inferJdbcDialect,
+} from "../../apps/desktop/src/lib/jdbcDialect.ts";
+import { supportsTableStructureEditing } from "../../apps/desktop/src/lib/databaseFeatureSupport.ts";
+import { qualifiedTableName } from "../../apps/desktop/src/lib/tableSelectSql.ts";
+
+test("infers JDBC dialect from URL, driver class, and driver jar path", () => {
+  assert.equal(
+    inferJdbcDialect({ db_type: "jdbc", connection_string: "jdbc:mysql://db.example.com:9030/demo" }),
+    "mysql",
+  );
+  assert.equal(
+    inferJdbcDialect({ db_type: "jdbc", jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver" }),
+    "mysql",
+  );
+  assert.equal(inferJdbcDialect({ db_type: "jdbc", jdbc_driver_class: "org.apache.hive.jdbc.HiveDriver" }), "hive");
+  assert.equal(
+    inferJdbcDialect({ db_type: "jdbc", jdbc_driver_paths: ["/drivers/starrocks-jdbc.jar"] }),
+    "starrocks",
+  );
+});
+
+test("effective database type keeps non-JDBC types and enables compatible JDBC structure editing", () => {
+  assert.equal(effectiveDatabaseTypeForConnection({ db_type: "postgres" }), "postgres");
+  assert.equal(effectiveDatabaseTypeForConnection({ db_type: "jdbc" }), "jdbc");
+  assert.equal(
+    effectiveDatabaseTypeForConnection({ db_type: "jdbc", jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver" }),
+    "mysql",
+  );
+  assert.equal(
+    supportsTableStructureEditing(
+      effectiveDatabaseTypeForConnection({ db_type: "jdbc", jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver" }),
+    ),
+    true,
+  );
+  assert.equal(supportsTableStructureEditing(effectiveDatabaseTypeForConnection({ db_type: "jdbc" })), false);
+});
+
+test("JDBC tree shape follows the inferred driver dialect", () => {
+  const kyuubi = { db_type: "jdbc" as const, jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver" };
+  const hive = { db_type: "jdbc" as const, jdbc_driver_class: "org.apache.hive.jdbc.HiveDriver" };
+
+  assert.equal(connectionUsesDatabaseObjectTreeMode(kyuubi), true);
+  assert.equal(connectionObjectTreeQuerySchema(kyuubi, "test", undefined), "");
+  assert.equal(connectionUsesDatabaseObjectTreeMode(hive), false);
+  assert.equal(connectionObjectTreeQuerySchema(hive, "spark_catalog", "test"), "test");
+  assert.equal(
+    qualifiedTableName({
+      databaseType: effectiveDatabaseTypeForConnection(hive),
+      schema: connectionObjectTreeQuerySchema(hive, "spark_catalog", "test"),
+      tableName: "dws_event_analyse",
+    }),
+    "`test`.`dws_event_analyse`",
+  );
+});
diff --git a/packages/app-tests/queryStore.test.ts b/packages/app-tests/queryStore.test.ts
index 4ab2955562..300eb7d273 100644
--- a/packages/app-tests/queryStore.test.ts
+++ b/packages/app-tests/queryStore.test.ts
@@ -1258,6 +1258,21 @@ test("new table structure tabs can open multiple drafts while existing tables st
   }
 });
 
+test("table structure refresh versions are scoped by table target", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", "public", "users"), 0);
+
+  store.invalidateTableStructure("conn-1", "db", "public", "users");
+  store.invalidateTableStructure("conn-1", "db", "public", "users");
+  store.invalidateTableStructure("conn-1", "db", undefined, "users");
+
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", "public", "users"), 2);
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", undefined, "users"), 1);
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", "public", "orders"), 0);
+});
+
 test("reorderTab keeps pinned tabs before unpinned tabs after reorder", () => {
   setActivePinia(createPinia());
   const store = useQueryStore();
diff --git a/packages/app-tests/tableSelectSql.test.ts b/packages/app-tests/tableSelectSql.test.ts
index a8d9f49fcc..c098f2ae75 100644
--- a/packages/app-tests/tableSelectSql.test.ts
+++ b/packages/app-tests/tableSelectSql.test.ts
@@ -7,7 +7,7 @@ test("JDBC table identifiers avoid double quotes for Kyuubi-compatible names", (
   assert.equal(quoteTableIdentifier("jdbc", "dwd_test_df"), "dwd_test_df");
   assert.equal(
     qualifiedTableName({ databaseType: "jdbc", schema: "cbsdw_dwd", tableName: "dwd_test_df" }),
-    "cbsdw_dwd.dwd_test_df",
+    "dwd_test_df",
   );
 });
 
diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
index 13f12ceeef..22b02dc5c9 100644
--- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
@@ -44,11 +44,17 @@ import java.util.logging.Logger;
 public final class DbxJdbcPlugin {
     private static final ObjectMapper MAPPER = new ObjectMapper();
     private static final int MAX_ROWS = 10_000;
-    private static final JdbcDriverQuirks DEFAULT_QUIRKS = new JdbcDriverQuirks(false, false, false);
-    private static final JdbcDriverQuirks YASHAN_QUIRKS = new JdbcDriverQuirks(true, true, false);
-    private static final JdbcDriverQuirks IRIS_QUIRKS = new JdbcDriverQuirks(true, false, true);
-    private static final JdbcDriverQuirks ORACLE_QUIRKS = new JdbcDriverQuirks(false, true, false);
+    private static final JdbcDriverQuirks DEFAULT_QUIRKS = new JdbcDriverQuirks(false, false, false, false);
+    private static final JdbcDriverQuirks USE_CATALOG_QUIRKS = new JdbcDriverQuirks(false, false, false, true);
+    private static final JdbcDriverQuirks YASHAN_QUIRKS = new JdbcDriverQuirks(true, true, false, false);
+    private static final JdbcDriverQuirks IRIS_QUIRKS = new JdbcDriverQuirks(true, false, true, false);
+    private static final JdbcDriverQuirks ORACLE_QUIRKS = new JdbcDriverQuirks(false, true, false, false);
     private static final List<JdbcDriverQuirkRule> DRIVER_QUIRK_RULES = List.of(
+        new JdbcDriverQuirkRule("jdbc:mysql:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:mariadb:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:starrocks:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:doris:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:hive2:", USE_CATALOG_QUIRKS),
         new JdbcDriverQuirkRule("jdbc:yasdb:", YASHAN_QUIRKS),
         new JdbcDriverQuirkRule("jdbc:iris:", IRIS_QUIRKS),
         new JdbcDriverQuirkRule("jdbc:oracle:", ORACLE_QUIRKS),
@@ -61,7 +67,8 @@ public final class DbxJdbcPlugin {
     record JdbcDriverQuirks(
         boolean skipExecutionContext,
         boolean useOracleMetadata,
-        boolean caseInsensitiveSchemaMetadata
+        boolean caseInsensitiveSchemaMetadata,
+        boolean useCatalogFallbackSql
     ) {
     }
 
@@ -327,11 +334,15 @@ public final class DbxJdbcPlugin {
         if (driverQuirks(connection).skipExecutionContext()) {
             return;
         }
-        if (database != null) {
+        String catalog = emptyToNull(database);
+        if (catalog != null) {
             try {
-                conn.setCatalog(database);
+                conn.setCatalog(catalog);
             } catch (SQLFeatureNotSupportedException | AbstractMethodError ignored) {
             }
+            if (driverQuirks(connection).useCatalogFallbackSql()) {
+                applyUseCatalogFallback(conn, catalog);
+            }
         }
         if (schema != null) {
             try {
@@ -341,6 +352,20 @@ public final class DbxJdbcPlugin {
         }
     }
 
+    private static void applyUseCatalogFallback(Connection conn, String catalog) {
+        try (Statement statement = conn.createStatement()) {
+            statement.execute("USE " + quoteJdbcIdentifier(catalog));
+        } catch (SQLException | AbstractMethodError ignored) {
+        }
+    }
+
+    private static String quoteJdbcIdentifier(String identifier) {
+        if (identifier != null && identifier.matches("[A-Za-z_][A-Za-z0-9_]*")) {
+            return identifier;
+        }
+        return "`" + identifier.replace("`", "``") + "`";
+    }
+
     static JdbcDriverQuirks driverQuirks(JsonNode connection) {
         String url = optionalText(connection, "connection_string");
         for (JdbcDriverQuirkRule rule : DRIVER_QUIRK_RULES) {
@@ -348,9 +373,29 @@ public final class DbxJdbcPlugin {
                 return rule.quirks();
             }
         }
+        if (isKyuubiDriver(connection)) {
+            return USE_CATALOG_QUIRKS;
+        }
         return DEFAULT_QUIRKS;
     }
 
+    private static boolean isKyuubiDriver(JsonNode connection) {
+        String driverClass = optionalText(connection, "jdbc_driver_class");
+        if (driverClass != null && driverClass.toLowerCase(Locale.ROOT).contains("kyuubi")) {
+            return true;
+        }
+        JsonNode paths = connection.path("jdbc_driver_paths");
+        if (!paths.isArray()) {
+            return false;
+        }
+        for (JsonNode path : paths) {
+            if (path.asText("").toLowerCase(Locale.ROOT).contains("kyuubi")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private static boolean urlMatchesPrefix(String url, String prefix) {
         return url != null && url.regionMatches(true, 0, prefix, 0, prefix.length());
     }
@@ -523,6 +568,9 @@ public final class DbxJdbcPlugin {
             primaryKeys = safePrimaryKeys(meta, null, schemaPattern, table);
             appendColumns(result, meta, null, schemaPattern, table, primaryKeys);
         }
+        if (quirks.useCatalogFallbackSql()) {
+            mergeShowFullColumnComments(conn, result, schemaPattern, table);
+        }
         return result;
     }
 
@@ -668,6 +716,41 @@ public final class DbxJdbcPlugin {
         }
     }
 
+    private static void mergeShowFullColumnComments(Connection conn, ArrayNode result, String schema, String table) {
+        String target = qualifiedJdbcTableName(schema, table);
+        try (Statement statement = conn.createStatement(); ResultSet rs = statement.executeQuery("SHOW FULL COLUMNS FROM " + target)) {
+            int fieldIndex = resultSetColumnIndex(rs, "Field");
+            int commentIndex = resultSetColumnIndex(rs, "Comment");
+            if (fieldIndex <= 0 || commentIndex <= 0) {
+                return;
+            }
+            while (rs.next()) {
+                String name = rs.getString(fieldIndex);
+                String comment = rs.getString(commentIndex);
+                if (name != null) {
+                    putNullablePreferValue(columnNode(result, name), "comment", comment);
+                }
+            }
+        } catch (SQLException | AbstractMethodError ignored) {
+        }
+    }
+
+    private static String qualifiedJdbcTableName(String schema, String table) {
+        String tableName = quoteJdbcIdentifier(table);
+        String schemaName = emptyToNull(schema);
+        return schemaName == null ? tableName : quoteJdbcIdentifier(schemaName) + "." + tableName;
+    }
+
+    private static int resultSetColumnIndex(ResultSet rs, String label) throws SQLException {
+        ResultSetMetaData meta = rs.getMetaData();
+        for (int i = 1; i <= meta.getColumnCount(); i++) {
+            if (label.equalsIgnoreCase(meta.getColumnLabel(i)) || label.equalsIgnoreCase(meta.getColumnName(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
     private static void closeSharedConnection() {
         if (sharedConnection != null) {
             try {
diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
index fe169c9958..3865042ae0 100644
--- a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
@@ -225,6 +225,16 @@ final class DbxJdbcPluginTest {
               "connection_string": "jdbc:h2:mem:dbx_quirks"
             }
             """);
+        JsonNode mysql = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:mysql://127.0.0.1:9030/demo"
+            }
+            """);
+        JsonNode kyuubi = MAPPER.readTree("""
+            {
+              "jdbc_driver_class": "org.apache.kyuubi.jdbc.KyuubiHiveDriver"
+            }
+            """);
 
         assertEquals(true, DbxJdbcPlugin.driverQuirks(yashan).skipExecutionContext());
         assertEquals(true, DbxJdbcPlugin.driverQuirks(yashan).useOracleMetadata());
@@ -234,6 +244,9 @@ final class DbxJdbcPluginTest {
         assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).skipExecutionContext());
         assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).useOracleMetadata());
         assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).caseInsensitiveSchemaMetadata());
+        assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).useCatalogFallbackSql());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(mysql).useCatalogFallbackSql());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(kyuubi).useCatalogFallbackSql());
     }
 
     @Test