diff --git a/ui/chen/api/index.ts b/ui/chen/api/index.ts
index 5ccec92cc..12692dc53 100644
--- a/ui/chen/api/index.ts
+++ b/ui/chen/api/index.ts
@@ -1,4 +1,11 @@
 import type { ChenActionItem, ChenAuthResponse, ChenProfile, ChenTreeNode } from "~/chen/types";
+import type {
+  ChenSchemaOverview,
+  ChenSchemaOverviewCapabilities,
+  ChenSchemaOverviewIndex,
+  ChenSchemaOverviewTable,
+  ChenSchemaOverviewView
+} from "~/chen/types/schemaOverview";
 import type {
   ChenQualifiedRelation,
   ChenRelationColumnsMetadata,
@@ -157,6 +164,25 @@ export async function fetchChenSqlColumns(
   });
 }
 
+export async function fetchChenSchemaOverview(
+  chenToken: string,
+  nodeKey: string,
+  fetchImpl: typeof fetch = fetch,
+  endpointUrl?: string
+): Promise<ChenSchemaOverview> {
+  const response = await fetchImpl(chenPath("/api/resources/metadata/schema-overview", endpointUrl), {
+    method: "POST",
+    credentials: "include",
+    headers: {
+      ...buildHeaders(chenToken, getWebApiMutationHeaders()),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ nodeKey })
+  });
+
+  return parseSchemaOverview(await readJson<unknown>(response));
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -167,7 +193,7 @@ function parseQualifiedRelation(value: unknown): ChenQualifiedRelation {
     !(typeof value.catalog === "string" || value.catalog === null) ||
     typeof value.schema !== "string" ||
     typeof value.name !== "string" ||
-    !(value.kind === "table" || value.kind === "view")
+    !(value.kind === "table" || value.kind === "view" || value.kind === "materialized_view")
   ) {
     throw new Error("Chen returned malformed SQL relation metadata");
   }
@@ -179,6 +205,114 @@ function parseQualifiedRelation(value: unknown): ChenQualifiedRelation {
   };
 }
 
+function parseSchemaOverview(value: unknown): ChenSchemaOverview {
+  if (
+    !isRecord(value) ||
+    !(typeof value.catalog === "string" || value.catalog === null) ||
+    typeof value.schema !== "string" ||
+    !isRecord(value.capabilities) ||
+    !Array.isArray(value.tables) ||
+    !Array.isArray(value.views) ||
+    !Array.isArray(value.indexes) ||
+    !(typeof value.ddl === "string" || value.ddl === null)
+  ) {
+    throw new Error("Chen returned malformed schema overview metadata");
+  }
+
+  return {
+    catalog: value.catalog,
+    schema: value.schema,
+    capabilities: parseSchemaOverviewCapabilities(value.capabilities),
+    tables: value.tables.map(parseSchemaOverviewTable),
+    views: value.views.map(parseSchemaOverviewView),
+    indexes: value.indexes.map(parseSchemaOverviewIndex),
+    ddl: value.ddl
+  };
+}
+
+function parseSchemaOverviewCapabilities(value: Record<string, unknown>): ChenSchemaOverviewCapabilities {
+  const keys = [
+    "tableRows",
+    "tableSize",
+    "tableEngine",
+    "tableCharacterSet",
+    "tableCollation",
+    "tableComment",
+    "viewComment",
+    "indexes",
+    "ddl"
+  ] as const;
+  if (keys.some((key) => typeof value[key] !== "boolean")) {
+    throw new Error("Chen returned malformed schema overview metadata");
+  }
+  return {
+    tableRows: value.tableRows as boolean,
+    tableSize: value.tableSize as boolean,
+    tableEngine: value.tableEngine as boolean,
+    tableCharacterSet: value.tableCharacterSet as boolean,
+    tableCollation: value.tableCollation as boolean,
+    tableComment: value.tableComment as boolean,
+    viewComment: value.viewComment as boolean,
+    indexes: value.indexes as boolean,
+    ddl: value.ddl as boolean
+  };
+}
+
+function parseSchemaOverviewTable(value: unknown): ChenSchemaOverviewTable {
+  if (
+    !isRecord(value) ||
+    typeof value.name !== "string" ||
+    typeof value.schema !== "string" ||
+    !isNullableNumber(value.estimatedRows) ||
+    !isNullableNumber(value.totalSizeBytes) ||
+    !isNullableString(value.engine) ||
+    !isNullableString(value.characterSet) ||
+    !isNullableString(value.collation) ||
+    !isNullableString(value.comment)
+  ) {
+    throw new Error("Chen returned malformed schema overview metadata");
+  }
+  return value as unknown as ChenSchemaOverviewTable;
+}
+
+function parseSchemaOverviewView(value: unknown): ChenSchemaOverviewView {
+  if (
+    !isRecord(value) ||
+    typeof value.name !== "string" ||
+    typeof value.schema !== "string" ||
+    typeof value.type !== "string" ||
+    !isNullableString(value.comment)
+  ) {
+    throw new Error("Chen returned malformed schema overview metadata");
+  }
+  return value as unknown as ChenSchemaOverviewView;
+}
+
+function parseSchemaOverviewIndex(value: unknown): ChenSchemaOverviewIndex {
+  if (
+    !isRecord(value) ||
+    typeof value.name !== "string" ||
+    typeof value.schema !== "string" ||
+    typeof value.table !== "string" ||
+    !Array.isArray(value.columns) ||
+    value.columns.some((column) => typeof column !== "string") ||
+    !(typeof value.unique === "boolean" || value.unique === null) ||
+    !isNullableString(value.method) ||
+    !isNullableString(value.definition)
+  ) {
+    throw new Error("Chen returned malformed schema overview metadata");
+  }
+  return value as unknown as ChenSchemaOverviewIndex;
+}
+
+function isNullableString(value: unknown): value is string | null {
+  return typeof value === "string" || value === null;
+}
+
+function isNullableNumber(value: unknown): value is number | null {
+  return (typeof value === "number" && Number.isFinite(value)) || value === null;
+}
+
 export function sanitizeChenExportFileName(value: string, fallback = "chen-export") {
   const withoutControls = Array.from(value)
     .filter((character) => {
diff --git a/ui/chen/components/DatabaseOverviewPanel.vue b/ui/chen/components/DatabaseOverviewPanel.vue
index 35cb6aa40..fe895b096 100644
--- a/ui/chen/components/DatabaseOverviewPanel.vue
+++ b/ui/chen/components/DatabaseOverviewPanel.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { ChenDatabaseSection, ChenDatabaseWorkspaceTab, ChenTreeNode } from "~/chen/types";
+import type { ChenSchemaOverview } from "~/chen/types/schemaOverview";
 
 const props = defineProps<{
   tab: ChenDatabaseWorkspaceTab;
@@ -9,7 +10,7 @@ const props = defineProps<{
 const emit = defineEmits<{
   selectSection: [section: ChenDatabaseSection];
   loadCatalog: [];
-  openTable: [node: ChenTreeNode];
+  openTable: [tableName: string];
 }>();
 
 const databaseSections: Array<{ id: ChenDatabaseSection; label: string }> = [
@@ -27,10 +28,10 @@ const schemaSections: Array<{ id: ChenDatabaseSection; label: string }> = [
 
 interface CatalogItem {
   key: string;
-  node: ChenTreeNode;
   name: string;
   schema: string;
   type: string;
+  displayType: string;
   table: string;
   columns: string;
   unique: string;
@@ -43,6 +44,62 @@ interface CatalogItem {
   comment: string;
 }
 
+function collectSchemaOverview(overview: ChenSchemaOverview): CatalogItem[] {
+  return [
+    ...overview.tables.map((table) => ({
+      key: `table:${table.schema}:${table.name}`,
+      name: table.name,
+      schema: table.schema,
+      type: "table",
+      displayType: "TABLE",
+      table: table.name,
+      columns: "",
+      unique: "",
+      method: "",
+      rowCount: formatCount(table.estimatedRows),
+      size: formatBytes(table.totalSizeBytes),
+      engine: table.engine || "",
+      characterSet: table.characterSet || "",
+      collation: table.collation || "",
+      comment: table.comment || ""
+    })),
+    ...overview.views.map((view) => ({
+      key: `view:${view.schema}:${view.name}`,
+      name: view.name,
+      schema: view.schema,
+      type: "view",
+      displayType: view.type,
+      table: "",
+      columns: "",
+      unique: "",
+      method: "",
+      rowCount: "",
+      size: "",
+      engine: "",
+      characterSet: "",
+      collation: "",
+      comment: view.comment || ""
+    })),
+    ...overview.indexes.map((index) => ({
+      key: `index:${index.schema}:${index.table}:${index.name}`,
+      name: index.name,
+      schema: index.schema,
+      type: "index",
+      displayType: "INDEX",
+      table: index.table,
+      columns: index.columns.join(", "),
+      unique: index.unique == null ? "" : index.unique ? "Yes" : "No",
+      method: index.method || "",
+      rowCount: "",
+      size: "",
+      engine: "",
+      characterSet: "",
+      collation: "",
+      comment: ""
+    }))
+  ];
+}
+
 function nodeName(node: ChenTreeNode) {
   return String(node.label || node.name || node.key);
 }
@@ -82,10 +139,10 @@ function collectCatalog(nodes: ChenTreeNode[], schema = "", result: CatalogItem[
     if (node.type === "schema" || node.type === "table" || node.type === "view" || node.type === "index") {
       result.push({
         key: node.key,
-        node,
         name: nodeName(node),
         schema: nextSchema,
         type: node.type,
+        displayType: node.type.toUpperCase(),
         table: String(node.table || node.tableName || ""),
         columns: Array.isArray(node.columns) ? node.columns.join(", ") : String(node.columns || ""),
         unique: node.unique == null ? "" : node.unique ? "Yes" : "No",
@@ -109,8 +166,14 @@ function collectCatalog(nodes: ChenTreeNode[], schema = "", result: CatalogItem[
   return result;
 }
 
-const catalog = computed(() => collectCatalog(props.tab.node.children || []));
 const isDatabase = computed(() => props.tab.node.type === "database");
+const catalog = computed(() =>
+  isDatabase.value
+    ? collectCatalog(props.tab.node.children || [])
+    : props.tab.schemaOverview
+      ? collectSchemaOverview(props.tab.schemaOverview)
+      : []
+);
 const sections = computed(() => (isDatabase.value ? databaseSections : schemaSections));
 const visibleCatalog = computed(() => {
   const type =
@@ -125,9 +188,16 @@ const visibleCatalog = computed(() => {
 });
 const databaseName = computed(() => nodeName(props.tab.node));
 const ddl = computed(() => {
+  if (!isDatabase.value && props.tab.schemaOverview) return props.tab.schemaOverview.ddl || "";
   const node = props.tab.node;
   return String(node.ddl || node.createSql || node.createSQL || node.definition || "").trim();
 });
+function catalogSummary(count: number) {
+  if (props.tab.catalogLoading) return "Loading...";
+  if (props.tab.catalogError) return "Load failed";
+  return props.tab.catalogLoaded ? String(count) : "Not loaded";
+}
+
 const basicInfo = computed(() => {
   const common = [
     { label: "Name", value: databaseName.value },
@@ -139,9 +209,7 @@ const basicInfo = computed(() => {
       ...common,
       {
         label: "Schemas",
-        value: props.tab.catalogLoaded
-          ? String(catalog.value.filter((item) => item.type === "schema").length)
-          : "Not loaded"
+        value: catalogSummary(catalog.value.filter((item) => item.type === "schema").length)
       }
     ];
   }
@@ -149,28 +217,30 @@ const basicInfo = computed(() => {
     ...common,
     {
       label: "Tables",
-      value: props.tab.catalogLoaded
-        ? String(catalog.value.filter((item) => item.type === "table").length)
-        : "Not loaded"
+      value: catalogSummary(catalog.value.filter((item) => item.type === "table").length)
     },
     {
       label: "Views",
-      value: props.tab.catalogLoaded
-        ? String(catalog.value.filter((item) => item.type === "view").length)
-        : "Not loaded"
+      value: catalogSummary(catalog.value.filter((item) => item.type === "view").length)
     },
     {
       label: "Indexes",
-      value: catalog.value.some((item) => item.type === "index")
+      value: props.tab.schemaOverview?.capabilities.indexes
         ? String(catalog.value.filter((item) => item.type === "index").length)
-        : "Requires backend metadata"
+        : "Not supported"
     }
   ];
 });
 
 function selectSection(section: ChenDatabaseSection) {
   emit("selectSection", section);
-  if (section === "schemas" || section === "tables" || section === "views" || section === "indexes") {
+  if (
+    section === "schemas" ||
+    section === "tables" ||
+    section === "views" ||
+    section === "indexes" ||
+    section === "ddl"
+  ) {
     emit("loadCatalog");
   }
 }
@@ -192,6 +262,20 @@ function selectSection(section: ChenDatabaseSection) {
     </div>
 
     <div v-if="tab.activeSection === 'basic'" class="grid min-h-0 flex-1 gap-3 overflow-auto p-4 md:grid-cols-2">
+      <div
+        v-if="tab.catalogLoading"
+        class="flex items-center gap-2 rounded-lg border border-default bg-[var(--workspace-surface-sub-panel)] px-3 py-2 text-sm text-muted md:col-span-2"
+      >
+        <UIcon name="i-lucide-loader-circle" class="size-4 animate-spin" />
+        Loading schema metadata...
+      </div>
+      <div
+        v-else-if="tab.catalogError"
+        class="flex items-center justify-between gap-3 rounded-lg border border-error/40 bg-error/5 px-3 py-2 text-sm text-error md:col-span-2"
+      >
+        <span>{{ tab.catalogError }}</span>
+        <UButton size="xs" color="neutral" variant="soft" @click="emit('loadCatalog')">Retry</UButton>
+      </div>
       <div
         v-for="item in basicInfo"
         :key="item.label"
@@ -277,7 +361,7 @@ function selectSection(section: ChenDatabaseSection) {
                   <button
                     type="button"
                     class="text-left text-primary hover:underline focus-visible:rounded-sm focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary"
-                    @click="emit('openTable', item.node)"
+                    @click="emit('openTable', item.name)"
                   >
                     {{ item.name }}
                   </button>
@@ -295,7 +379,7 @@ function selectSection(section: ChenDatabaseSection) {
               <tr v-for="item in visibleCatalog" :key="item.key" class="border-t border-default">
                 <td class="px-3 py-2">{{ item.name }}</td>
                 <td class="px-3 py-2 text-muted">{{ item.schema || "-" }}</td>
-                <td class="px-3 py-2 text-muted">{{ item.type }}</td>
+                <td class="px-3 py-2 text-muted">{{ item.displayType }}</td>
               </tr>
             </template>
           </tbody>
@@ -306,19 +390,18 @@ function selectSection(section: ChenDatabaseSection) {
         metadata from the server; unavailable fields are shown as “-”.
       </p>
       <div
-        v-else-if="tab.activeSection === 'indexes'"
+        v-else-if="
+          !visibleCatalog.length && tab.activeSection === 'indexes' && !tab.schemaOverview?.capabilities.indexes
+        "
         class="grid h-full place-items-center p-6 text-center text-sm text-muted"
       >
         <div class="max-w-lg">
           <UIcon name="i-lucide-list-tree" class="mx-auto mb-3 size-8" />
-          <div class="font-medium text-[var(--app-fg)]">Index metadata is not available yet</div>
-          <p class="mt-2 text-xs leading-5">
-            The page is ready and will display database-level indexes when the server provides index name, schema,
-            table, columns, uniqueness, and method metadata.
-          </p>
+          <div class="font-medium text-[var(--app-fg)]">Index metadata is not supported</div>
+          <p class="mt-2 text-xs leading-5">This database metadata provider does not expose schema-level indexes.</p>
         </div>
       </div>
-      <div v-else class="grid h-full place-items-center text-sm text-muted">
+      <div v-else-if="!visibleCatalog.length" class="grid h-full place-items-center text-sm text-muted">
         No {{ tab.activeSection }} found in the loaded catalog.
       </div>
     </div>
@@ -335,7 +418,11 @@ function selectSection(section: ChenDatabaseSection) {
             {{ isDatabase ? "Database" : "Schema" }} DDL is not available yet
           </div>
           <p class="mt-2 text-xs leading-5">
-            This page will render the DDL when it is included in the server metadata response.
+            {{
+              tab.schemaOverview?.capabilities.ddl === false
+                ? "This database metadata provider does not expose schema DDL."
+                : "The server returned no schema DDL."
+            }}
           </p>
         </div>
       </div>
diff --git a/ui/chen/composables/useChenWorkspaceTabs.ts b/ui/chen/composables/useChenWorkspaceTabs.ts
index 1be330959..a1d5b73c6 100644
--- a/ui/chen/composables/useChenWorkspaceTabs.ts
+++ b/ui/chen/composables/useChenWorkspaceTabs.ts
@@ -39,7 +39,7 @@ export function useChenWorkspaceTabs() {
     return normalized || tab.title;
   }
 
-  function registerTab(tab: ChenWorkspaceTab) {
+  function registerTab<T extends ChenWorkspaceTab>(tab: T): T {
     workspaceTabs.value.push(tab);
     workspaceTabState[tab.id] = tab;
     activeWorkspaceTabId.value = tab.id;
@@ -130,7 +130,15 @@ export function useChenWorkspaceTabs() {
     const existingTab = workspaceTabs.value.find((item) => item.kind === "database" && item.nodeKey === node.key);
     if (existingTab) {
       activeWorkspaceTabId.value = existingTab.id;
-      return workspaceTabState[existingTab.id] as ChenDatabaseWorkspaceTab;
+      const tab = workspaceTabState[existingTab.id] as ChenDatabaseWorkspaceTab;
+      if (toRaw(tab.node) !== toRaw(node)) {
+        tab.node = node;
+        tab.schemaOverview = null;
+        tab.catalogLoaded = false;
+        tab.catalogLoading = false;
+        tab.catalogError = "";
+      }
+      return tab;
     }
 
     const tab: ChenDatabaseWorkspaceTab = {
@@ -140,6 +148,7 @@ export function useChenWorkspaceTabs() {
       kind: "database",
       nodeKey: node.key,
       node,
+      schemaOverview: null,
       activeSection: "basic",
       catalogLoaded: false,
       catalogLoading: false,
diff --git a/ui/chen/types.ts b/ui/chen/types.ts
index 665bd7b34..ee4593d64 100644
--- a/ui/chen/types.ts
+++ b/ui/chen/types.ts
@@ -1,3 +1,5 @@
+import type { ChenSchemaOverview } from "~/chen/types/schemaOverview";
+
 export interface ChenAuthResponse {
   token: string;
   lang: string;
@@ -314,6 +316,7 @@ export type ChenDatabaseSection = "basic" | "schemas" | "tables" | "views" | "in
 export interface ChenDatabaseWorkspaceTab extends ChenTabDefinition {
   kind: "database";
   node: ChenTreeNode;
+  schemaOverview: ChenSchemaOverview | null;
   activeSection: ChenDatabaseSection;
   catalogLoaded: boolean;
   catalogLoading: boolean;
diff --git a/ui/chen/types/schemaOverview.ts b/ui/chen/types/schemaOverview.ts
new file mode 100644
index 000000000..f276ad9fd
--- /dev/null
+++ b/ui/chen/types/schemaOverview.ts
@@ -0,0 +1,49 @@
+export interface ChenSchemaOverviewCapabilities {
+  tableRows: boolean;
+  tableSize: boolean;
+  tableEngine: boolean;
+  tableCharacterSet: boolean;
+  tableCollation: boolean;
+  tableComment: boolean;
+  viewComment: boolean;
+  indexes: boolean;
+  ddl: boolean;
+}
+
+export interface ChenSchemaOverviewTable {
+  name: string;
+  schema: string;
+  estimatedRows: number | null;
+  totalSizeBytes: number | null;
+  engine: string | null;
+  characterSet: string | null;
+  collation: string | null;
+  comment: string | null;
+}
+
+export interface ChenSchemaOverviewView {
+  name: string;
+  schema: string;
+  type: string;
+  comment: string | null;
+}
+
+export interface ChenSchemaOverviewIndex {
+  name: string;
+  schema: string;
+  table: string;
+  columns: string[];
+  unique: boolean | null;
+  method: string | null;
+  definition: string | null;
+}
+
+export interface ChenSchemaOverview {
+  catalog: string | null;
+  schema: string;
+  capabilities: ChenSchemaOverviewCapabilities;
+  tables: ChenSchemaOverviewTable[];
+  views: ChenSchemaOverviewView[];
+  indexes: ChenSchemaOverviewIndex[];
+  ddl: string | null;
+}
diff --git a/ui/chen/types/sqlMetadata.ts b/ui/chen/types/sqlMetadata.ts
index 899ef2f94..ac66abf62 100644
--- a/ui/chen/types/sqlMetadata.ts
+++ b/ui/chen/types/sqlMetadata.ts
@@ -7,7 +7,7 @@ export interface ChenQualifiedRelation {
   catalog: string | null;
   schema: string;
   name: string;
-  kind: "table" | "view";
+  kind: "table" | "view" | "materialized_view";
 }
 
 export interface ChenSqlColumnMetadata {
diff --git a/ui/chen/workspaces/DatabaseSessionSurface.vue b/ui/chen/workspaces/DatabaseSessionSurface.vue
index bba67a715..2b631195c 100644
--- a/ui/chen/workspaces/DatabaseSessionSurface.vue
+++ b/ui/chen/workspaces/DatabaseSessionSurface.vue
@@ -35,6 +35,7 @@ import type { WorkspaceSessionTab } from "~/composables/useWorkspaceTabs";
 import {
   fetchChenActions,
   fetchChenExport,
+  fetchChenSchemaOverview,
   fetchChenSqlColumns,
   fetchChenSqlRelations,
   uploadChenSqlFile
@@ -177,6 +178,23 @@ const sqlMetadataStore = new ChenSqlMetadataStore({
   listColumns: (scope, relations) =>
     fetchChenSqlColumns(auth.chenToken.value, scope, relations, undefined, endpointUrl.value)
 });
+const databaseCatalogLoads = new WeakMap<ChenDatabaseWorkspaceTab, symbol>();
+
+function invalidateDatabaseCatalogs() {
+  for (const tab of Object.values(workspace.workspaceTabState)) {
+    if (tab.kind !== "database") continue;
+    databaseCatalogLoads.set(tab, Symbol("invalidated schema metadata load"));
+    tab.schemaOverview = null;
+    tab.catalogLoaded = false;
+    tab.catalogLoading = false;
+    tab.catalogError = "";
+  }
+}
+
+function clearMetadataCaches() {
+  sqlMetadataStore.clear();
+  invalidateDatabaseCatalogs();
+}
 
 const currentWorkspaceNodeKey = computed(() => {
   return (
@@ -322,7 +340,7 @@ const session = useChenSession({
   },
   onDisconnected: () => {
     closeSqlAiSession();
-    sqlMetadataStore.clear();
+    clearMetadataCaches();
     closeAllConsoleSockets("Database session disconnected");
   },
   showMessage: (data) => {
@@ -898,6 +916,7 @@ async function finishCreateTable(tab: ChenCreateTableWorkspaceTab, succeeded: bo
 
   tab.created = true;
   tab.title = tab.tableName.trim() || tab.title;
+  clearMetadataCaches();
   toast.add({ title: "Table created", description: tab.tableName.trim(), color: "success" });
   await tree.loadNodeChildren(tab.parentNode, true);
 }
@@ -941,6 +960,7 @@ function finishTableStructure(tab: ChenTableStructureWorkspaceTab, succeeded: bo
   }
 
   tab.saved = true;
+  clearMetadataCaches();
   tab.columns = tab.columns
     .filter((column) => !column.deleted)
     .map((column) => ({
@@ -1003,30 +1023,57 @@ function openDataViewWorkspace(nodeKey: string, title = "Data View") {
 }
 
 function openDatabaseWorkspace(node: ChenTreeNode) {
-  workspace.openDatabaseTab(node, node.label || node.name || (node.type === "schema" ? "Schema" : "Database"));
+  const tab = workspace.openDatabaseTab(
+    node,
+    node.label || node.name || (node.type === "schema" ? "Schema" : "Database")
+  );
+  if (node.type === "schema") void loadDatabaseCatalog(tab);
 }
 
-async function loadDatabaseCatalog(tab: ChenDatabaseWorkspaceTab) {
-  if (tab.catalogLoaded || tab.catalogLoading) return;
+async function loadDatabaseCatalog(tab: ChenDatabaseWorkspaceTab, force = false) {
+  if ((!force && tab.catalogLoaded) || tab.catalogLoading) return;
+  const load = Symbol("schema metadata load");
+  databaseCatalogLoads.set(tab, load);
   tab.catalogLoading = true;
   tab.catalogError = "";
 
   try {
-    if (!tab.node.children?.length && tab.node.hasChildren !== false) await tree.loadNodeChildren(tab.node);
-
     if (tab.node.type === "schema") {
-      const objectFolders = (tab.node.children || []).filter((child) => child.type === "folder" && !child.leaf);
-      await Promise.all(
-        objectFolders.map(async (folder) => {
-          if (!folder.children?.length && folder.hasChildren !== false) await tree.loadNodeChildren(folder);
-        })
-      );
+      const overview = await fetchChenSchemaOverview(auth.chenToken.value, tab.nodeKey, undefined, endpointUrl.value);
+      if (databaseCatalogLoads.get(tab) !== load) return;
+      tab.schemaOverview = overview;
+    } else if ((force || !Array.isArray(tab.node.children)) && tab.node.hasChildren !== false) {
+      await tree.loadNodeChildren(tab.node, force);
     }
+    if (databaseCatalogLoads.get(tab) !== load) return;
     tab.catalogLoaded = true;
   } catch (cause) {
+    if (databaseCatalogLoads.get(tab) !== load) return;
     tab.catalogError = cause instanceof Error ? cause.message : String(cause);
   } finally {
-    tab.catalogLoading = false;
+    if (databaseCatalogLoads.get(tab) === load) tab.catalogLoading = false;
+  }
+}
+
+async function openSchemaOverviewTable(tab: ChenDatabaseWorkspaceTab, tableName: string) {
+  if (tab.node.type !== "schema") return;
+  try {
+    if (!Array.isArray(tab.node.children)) await tree.loadNodeChildren(tab.node);
+    const tablesFolder = (tab.node.children || []).find(
+      (child) => child.type === "folder" && String(child.label || child.name || "").toLowerCase() === "tables"
+    );
+    if (!tablesFolder) throw new Error("Tables folder is unavailable");
+    if (!Array.isArray(tablesFolder.children)) await tree.loadNodeChildren(tablesFolder);
+    const tableNode = (tablesFolder.children || []).find(
+      (child) => child.type === "table" && String(child.label || child.name || "") === tableName
+    );
+    if (!tableNode) throw new Error(`Table ${tableName} is unavailable`);
+    await handleNodeClick(tableNode);
+  } catch (cause) {
+    addErrorToast({
+      title: "Failed to open table",
+      description: cause instanceof Error ? cause.message : String(cause)
+    });
   }
 }
 
@@ -1201,8 +1248,14 @@ async function applyTreeAction(node: ChenTreeNode, action: string) {
     const response = await tree.runTreeAction(node, action);
     switch (response.event) {
       case "refresh_node":
-        sqlMetadataStore.clear();
+        clearMetadataCaches();
         await tree.loadNodeChildren(node, true);
+        {
+          const databaseTab = Object.values(workspace.workspaceTabState).find(
+            (tab): tab is ChenDatabaseWorkspaceTab => tab.kind === "database" && tab.nodeKey === node.key
+          );
+          if (databaseTab?.node.type === "schema") await loadDatabaseCatalog(databaseTab, true);
+        }
         break;
       case "new_query":
         openQueryWorkspace(response.data, "Query");
@@ -1455,6 +1508,7 @@ function clearRecentTables() {
 
 function runQueryTab(tab: ChenQueryLikeWorkspaceTab, selectedSql = "") {
   if (tab.kind === "console") {
+    if (mayChangeSqlMetadata(tab.pendingSql)) clearMetadataCaches();
     queryConsole.runConsoleTab(tab);
     return;
   }
@@ -1475,7 +1529,7 @@ function runQueryTab(tab: ChenQueryLikeWorkspaceTab, selectedSql = "") {
 
 function executeQueryTab(tab: ChenQueryConsoleTab, statement: string) {
   queryConsole.runQueryTab(tab, statement);
-  if (mayChangeSqlMetadata(statement)) sqlMetadataStore.clear();
+  if (mayChangeSqlMetadata(statement)) clearMetadataCaches();
 }
 
 function updateUnrestrictedMutationDialog(open: boolean) {
@@ -1523,7 +1577,7 @@ async function performUploadQuerySql(tab: ChenQueryConsoleTab, file: File) {
   try {
     const result = await uploadChenSqlFile(auth.chenToken.value, file, undefined, endpointUrl.value);
     queryConsole.runQueryFile(tab, result.path);
-    sqlMetadataStore.clear();
+    clearMetadataCaches();
     toast.add({ title: "SQL file uploaded", description: file.name, color: "success" });
   } catch (cause) {
     addErrorToast({
@@ -1668,7 +1722,7 @@ function stopResize() {
 function focus() {}
 
 async function refreshResourceRoot() {
-  sqlMetadataStore.clear();
+  clearMetadataCaches();
   await tree.refreshRoot();
 }
 
@@ -1690,7 +1744,7 @@ onBeforeUnmount(() => {
   stopResize();
   closeSqlAiSession();
   closeAllConsoleSockets();
-  sqlMetadataStore.clear();
+  clearMetadataCaches();
   workspace.closeAllTabs();
   session.cleanupSession();
   window.removeEventListener("pointermove", handlePointerMove);
@@ -1815,7 +1869,7 @@ defineExpose({ focus });
             :db-type="auth.profile.value?.dbType"
             @select-section="updateDatabaseSection(activeDatabaseTab, $event)"
             @load-catalog="loadDatabaseCatalog(activeDatabaseTab)"
-            @open-table="handleNodeClick"
+            @open-table="openSchemaOverviewTable(activeDatabaseTab, $event)"
           />
 
           <CreateTablePanel