feat(sidebar): lazily load database object groups

This commit is contained in:
t8y2
2026-06-07 23:44:40 +08:00
parent cdad4a32ff
commit 7bd8d29a79
15 changed files with 484 additions and 68 deletions
@@ -350,14 +350,19 @@ async function toggle() {
return;
}
if (
if (node.type === "group-partitions") {
node.isExpanded = !node.isExpanded;
emit("node-toggled", node, wasExpanded);
return;
}
const databaseObjectGroup =
node.type === "group-tables" ||
node.type === "group-views" ||
node.type === "group-procedures" ||
node.type === "group-functions" ||
node.type === "group-packages" ||
node.type === "group-partitions"
) {
node.type === "group-packages";
if (databaseObjectGroup && connectionStore.isTreeNodeChildrenLoaded(node.id)) {
node.isExpanded = !node.isExpanded;
emit("node-toggled", node, wasExpanded);
return;
@@ -428,6 +433,8 @@ async function toggle() {
node.tableName
) {
await connectionStore.loadTriggers(node.connectionId, node.database, node.tableName, node.schema, node.id);
} else if (databaseObjectGroup) {
await connectionStore.loadObjectGroupChildren(node);
}
emit("node-toggled", node, wasExpanded);
} catch (e: any) {
@@ -1,3 +1,4 @@
export * from "./databaseCapabilitySets";
export * from "./databaseFeatureSupport";
export * from "./databaseObjectCapabilities";
export * from "./databaseTableDataCapabilities";
@@ -0,0 +1,59 @@
import type { DatabaseType } from "@/types/database";
export type SidebarObjectKind = "TABLE" | "VIEW" | "PROCEDURE" | "FUNCTION" | "PACKAGE" | "PACKAGE_BODY";
export interface DatabaseObjectCapabilities {
sidebarObjects: SidebarObjectKind[];
sourceReadable: SidebarObjectKind[];
executable: SidebarObjectKind[];
}
const TABLE_VIEW_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW"];
const ROUTINE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "PROCEDURE", "FUNCTION"];
const ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "PACKAGE", "PACKAGE_BODY"];
const TABLE_VIEW_ONLY_TYPES = new Set<DatabaseType>([
"sqlite",
"rqlite",
"duckdb",
"clickhouse",
"doris",
"starrocks",
"databend",
"hive",
"trino",
"cassandra",
"bigquery",
"kylin",
"tdengine",
"iotdb",
"neo4j",
]);
const ORACLE_PACKAGE_TYPES = new Set<DatabaseType>(["oracle", "oceanbase-oracle"]);
export function databaseObjectCapabilities(dbType?: DatabaseType): DatabaseObjectCapabilities {
const sidebarObjects = sidebarObjectKindsForDatabase(dbType);
return {
sidebarObjects,
sourceReadable: sidebarObjects.filter((kind) => kind !== "TABLE"),
executable: sidebarObjects.filter((kind) => kind === "PROCEDURE"),
};
}
export function sidebarObjectKindsForDatabase(dbType?: DatabaseType): SidebarObjectKind[] {
if (!dbType) return [...TABLE_VIEW_OBJECTS];
if (ORACLE_PACKAGE_TYPES.has(dbType)) return [...ORACLE_OBJECTS];
if (TABLE_VIEW_ONLY_TYPES.has(dbType)) return [...TABLE_VIEW_OBJECTS];
return [...ROUTINE_OBJECTS];
}
export function normalizeSidebarObjectKind(type: string): SidebarObjectKind {
const value = type.toUpperCase();
if (value.includes("PACKAGE BODY") || value.includes("PACKAGE_BODY")) return "PACKAGE_BODY";
if (value.includes("PACKAGE")) return "PACKAGE";
if (value.includes("VIEW")) return "VIEW";
if (value.includes("PROC")) return "PROCEDURE";
if (value.includes("FUNC")) return "FUNCTION";
return "TABLE";
}
+15 -2
View File
@@ -20,6 +20,7 @@ import type {
SavedSqlFolder,
SavedSqlLibrary,
} from "@/types/database";
import type { SidebarObjectKind } from "@/lib/databaseObjectCapabilities";
import type { AiConfig } from "@/stores/settingsStore";
import type {
AgentDriverInfo,
@@ -394,8 +395,20 @@ export async function listTables(
return get(`/api/schema/tables?${qs({ connection_id: connectionId, database, schema, filter, limit })}`);
}
export async function listObjects(connectionId: string, database: string, schema: string): Promise<ObjectInfo[]> {
return get(`/api/schema/objects?${qs({ connection_id: connectionId, database, schema })}`);
export async function listObjects(
connectionId: string,
database: string,
schema: string,
objectTypes?: SidebarObjectKind[],
): Promise<ObjectInfo[]> {
return get(
`/api/schema/objects?${qs({
connection_id: connectionId,
database,
schema,
object_types: objectTypes?.join(","),
})}`,
);
}
export async function listCompletionObjects(
+25 -12
View File
@@ -1,6 +1,11 @@
import type { ObjectInfo, TreeNode } from "@/types/database";
import { sortSidebarNames } from "@/lib/databaseTree";
import { buildGroupedObjectTreeNodes, buildSimpleObjectTreeNodes } from "@/lib/tableTree";
import {
buildGroupedObjectTreeNodes,
buildObjectGroupPlaceholderNodes,
buildSimpleObjectTreeNodes,
type DatabaseObjectTreeKind,
} from "@/lib/tableTree";
export const SQLSERVER_DEFAULT_SCHEMA = "dbo";
@@ -13,26 +18,34 @@ export function buildSqlServerDatabaseTreeNodes(
database: string,
schemas: string[],
defaultSchemaObjects: ObjectInfo[],
options: { simpleObjectDisplay?: boolean } = {},
options: { lazyObjectTypes?: DatabaseObjectTreeKind[]; simpleObjectDisplay?: boolean } = {},
): TreeNode[] {
const databaseNodeId = `${connectionId}:${database}`;
const defaultSchema = schemas.find(isDefaultSchema) || SQLSERVER_DEFAULT_SCHEMA;
const defaultObjectNodes = options.simpleObjectDisplay
? buildSimpleObjectTreeNodes({
const defaultObjectNodes = options.lazyObjectTypes
? buildObjectGroupPlaceholderNodes({
nodeId: databaseNodeId,
connectionId,
database,
schema: defaultSchema,
objects: defaultSchemaObjects,
objectTypes: options.lazyObjectTypes,
})
: buildGroupedObjectTreeNodes({
nodeId: databaseNodeId,
connectionId,
database,
schema: defaultSchema,
objects: defaultSchemaObjects,
});
: options.simpleObjectDisplay
? buildSimpleObjectTreeNodes({
nodeId: databaseNodeId,
connectionId,
database,
schema: defaultSchema,
objects: defaultSchemaObjects,
})
: buildGroupedObjectTreeNodes({
nodeId: databaseNodeId,
connectionId,
database,
schema: defaultSchema,
objects: defaultSchemaObjects,
});
const schemaNodes = sortSidebarNames(schemas.filter((schema) => !isDefaultSchema(schema))).map((schema) => ({
id: `${databaseNodeId}:${schema}`,
+54 -17
View File
@@ -1,4 +1,5 @@
import type { ObjectInfo, TableInfo, TreeNode, TreeNodeType } from "@/types/database";
import { normalizeSidebarObjectKind, type SidebarObjectKind } from "@/lib/databaseObjectCapabilities";
const databaseObjectNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
@@ -315,7 +316,7 @@ export function hasTablePartitionGroups(node: TreeNode): boolean {
return partitionGroupChildren(node).length > 0;
}
type DatabaseObjectTreeKind = "TABLE" | "VIEW" | "PROCEDURE" | "FUNCTION" | "PACKAGE" | "PACKAGE_BODY";
export type DatabaseObjectTreeKind = SidebarObjectKind;
function buildObjectTreeEntries({
nodeId,
@@ -369,12 +370,11 @@ export function buildSimpleObjectTreeNodes({
}): TreeNode[] {
const seen = new Set<string>();
const tableEntries: TableTreeEntry[] = [];
const viewNodes: TreeNode[] = [];
const objectNodes: TreeNode[] = [];
for (const obj of objects) {
const objectType = normalizeObjectType(obj.object_type);
if (objectType !== "TABLE" && objectType !== "VIEW" && objectType !== "PACKAGE" && objectType !== "PACKAGE_BODY")
continue;
if (!["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "PACKAGE", "PACKAGE_BODY"].includes(objectType)) continue;
const name = normalizeDatabaseObjectName(obj.name);
if (!name) continue;
@@ -397,13 +397,15 @@ export function buildSimpleObjectTreeNodes({
});
if (objectType === "TABLE") {
tableEntries.push(entry);
} else if (objectType === "VIEW") {
viewNodes.push(entry.node);
} else {
viewNodes.push({
id: `${nodeId}:${childSchema ? `${childSchema}:` : ""}${name}:${objectType}`,
const simpleNodeType = simpleObjectNodeType(objectType);
objectNodes.push({
id:
objectType === "VIEW"
? entry.node.id
: `${nodeId}:${childSchema ? `${childSchema}:` : ""}${name}:${objectType}`,
label: name,
type: objectType === "PACKAGE_BODY" ? "package-body" : "package",
type: simpleNodeType,
comment: obj.comment,
connectionId,
database,
@@ -416,18 +418,21 @@ export function buildSimpleObjectTreeNodes({
return [
...buildPartitionTree(tableEntries, connectionId, database),
...sortDatabaseObjectsByName(viewNodes, (node) => node.label),
...sortDatabaseObjectsByName(objectNodes, (node) => node.label),
];
}
function simpleObjectNodeType(objectType: DatabaseObjectTreeKind): TreeNodeType {
if (objectType === "VIEW") return "view";
if (objectType === "PROCEDURE") return "procedure";
if (objectType === "FUNCTION") return "function";
if (objectType === "PACKAGE_BODY") return "package-body";
if (objectType === "PACKAGE") return "package";
return "table";
}
function normalizeObjectType(type: string): DatabaseObjectTreeKind {
const v = type.toUpperCase();
if (v.includes("PACKAGE BODY") || v.includes("PACKAGE_BODY")) return "PACKAGE_BODY";
if (v.includes("PACKAGE")) return "PACKAGE";
if (v.includes("VIEW")) return "VIEW";
if (v.includes("PROC")) return "PROCEDURE";
if (v.includes("FUNC")) return "FUNCTION";
return "TABLE";
return normalizeSidebarObjectKind(type);
}
const groupDefs: Array<{
@@ -470,6 +475,34 @@ const objectGroupNodeTypes = new Set<TreeNodeType>([
"group-packages",
]);
export function buildObjectGroupPlaceholderNodes({
nodeId,
connectionId,
database,
schema,
objectTypes,
}: {
nodeId: string;
connectionId: string;
database: string;
schema?: string;
objectTypes: DatabaseObjectTreeKind[];
}): TreeNode[] {
const supported = new Set(objectTypes);
return groupDefs
.filter((def) => def.objectTypes.some((objectType) => supported.has(objectType)))
.map((def) => ({
id: `${nodeId}:${def.key}`,
label: def.label,
type: def.nodeType,
connectionId,
database,
schema,
isExpanded: false,
children: [],
}));
}
export function objectGroupRefreshParentId(node: TreeNode): string | null {
if (!objectGroupNodeTypes.has(node.type)) return null;
const suffixStart = node.id.lastIndexOf(":__");
@@ -477,6 +510,10 @@ export function objectGroupRefreshParentId(node: TreeNode): string | null {
return node.id.slice(0, suffixStart);
}
export function objectTypesForGroupNode(type: TreeNodeType): DatabaseObjectTreeKind[] | null {
return groupDefs.find((def) => def.nodeType === type)?.objectTypes ?? null;
}
export function buildGroupedObjectTreeNodes({
nodeId,
connectionId,
+8 -2
View File
@@ -21,6 +21,7 @@ import type {
SavedSqlFolder,
SavedSqlLibrary,
} from "@/types/database";
import type { SidebarObjectKind } from "@/lib/databaseObjectCapabilities";
import type { AiConfig } from "@/stores/settingsStore";
import type { QueryEditability } from "@/lib/sqlAnalysis";
import type {
@@ -452,8 +453,13 @@ export async function listTables(
return invoke("list_tables", { connectionId, database, schema, filter, limit });
}
export async function listObjects(connectionId: string, database: string, schema: string): Promise<ObjectInfo[]> {
return invoke("list_objects", { connectionId, database, schema });
export async function listObjects(
connectionId: string,
database: string,
schema: string,
objectTypes?: SidebarObjectKind[],
): Promise<ObjectInfo[]> {
return invoke("list_objects", { connectionId, database, schema, objectTypes });
}
export async function listCompletionObjects(
+110 -15
View File
@@ -20,11 +20,17 @@ import {
import type { SqlCompletionColumn, SqlCompletionObject, SqlCompletionTable } from "@/lib/sqlCompletion";
import * as api from "@/lib/api";
import { isTauriRuntime } from "@/lib/tauriRuntime";
import { isSchemaAware, usesTreeSchemaMode } from "@/lib/databaseCapabilities";
import {
isSchemaAware,
normalizeSidebarObjectKind,
sidebarObjectKindsForDatabase,
usesTreeSchemaMode,
} from "@/lib/databaseCapabilities";
import {
connectionObjectTreeNodeSchema,
connectionObjectTreeQuerySchema,
connectionUsesDatabaseObjectTreeMode,
effectiveDatabaseTypeForConnection,
} from "@/lib/jdbcDialect";
import {
buildDatabaseTreeNodes,
@@ -42,12 +48,16 @@ import {
normalizeVisibleDatabaseSelection,
} from "@/lib/visibleDatabases";
import {
buildObjectGroupPlaceholderNodes,
buildGroupedObjectTreeNodes,
buildSimpleObjectTreeNodes,
buildTableTreeNodes,
expandCachedObjectBrowserNodes,
mergeTableInfosIntoObjects,
objectGroupRefreshParentId,
objectTypesForGroupNode,
tablePartitionGroups,
type DatabaseObjectTreeKind,
} from "@/lib/tableTree";
import {
hasTreeNodeDatabaseContext,
@@ -439,6 +449,11 @@ export const useConnectionStore = defineStore("connection", () => {
return parts.map((part) => encodeURIComponent(part)).join(":");
}
function supportedSidebarObjectTypes(config?: ConnectionConfig): DatabaseObjectTreeKind[] {
const dbType = effectiveDatabaseTypeForConnection(config);
return sidebarObjectKindsForDatabase(dbType);
}
function refreshStaleTreeNode(node: TreeNode) {
if (staleTreeRefreshIds.has(node.id)) return;
staleTreeRefreshIds.add(node.id);
@@ -1070,7 +1085,12 @@ export const useConnectionStore = defineStore("connection", () => {
try {
await ensureConnected(connectionId);
if (useCachedChildren(node, options)) return;
const cacheKey = schemaCacheKey(connectionId, database, "sqlserver-objects");
const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
const cacheKey = schemaCacheKey(
connectionId,
database,
simpleObjectDisplay ? "sqlserver-objects-simple-v2" : "sqlserver-objects-grouped-v2",
);
if (!options?.force) {
const cached = await loadPersistedTreeChildren(node, cacheKey);
if (cached.hit) {
@@ -1079,12 +1099,14 @@ export const useConnectionStore = defineStore("connection", () => {
}
}
const [schemas, defaultSchemaObjects] = await Promise.all([
api.listSchemas(connectionId, database),
api.listObjects(connectionId, database, SQLSERVER_DEFAULT_SCHEMA),
]);
const config = getConfig(connectionId);
const schemas = await api.listSchemas(connectionId, database);
const defaultSchemaObjects = simpleObjectDisplay
? await api.listObjects(connectionId, database, SQLSERVER_DEFAULT_SCHEMA)
: [];
const children = buildSqlServerDatabaseTreeNodes(connectionId, database, schemas, defaultSchemaObjects, {
simpleObjectDisplay: useSettingsStore().editorSettings.sidebarObjectDisplay === "simple",
lazyObjectTypes: simpleObjectDisplay ? undefined : supportedSidebarObjectTypes(config),
simpleObjectDisplay,
});
setChildren(node, children);
await savePersistedTreeChildren(cacheKey, children);
@@ -1105,7 +1127,13 @@ export const useConnectionStore = defineStore("connection", () => {
try {
await ensureConnected(connectionId);
if (useCachedChildren(node, options)) return;
const cacheKey = schemaCacheKey(connectionId, database, schema || "", "objects");
const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
const cacheKey = schemaCacheKey(
connectionId,
database,
schema || "",
simpleObjectDisplay ? "objects-simple-v2" : "objects-grouped-v2",
);
if (!options?.force) {
const cached = await loadPersistedTreeChildren(node, cacheKey);
if (cached.hit) {
@@ -1117,18 +1145,14 @@ export const useConnectionStore = defineStore("connection", () => {
const config = getConfig(connectionId);
const querySchema = connectionObjectTreeQuerySchema(config, database, schema);
const effectiveSchema = connectionObjectTreeNodeSchema(config, database, schema);
const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
let children: TreeNode[];
if (simpleObjectDisplay) {
const tables = await api.listTables(connectionId, database, querySchema);
children = buildTableTreeNodes({ nodeId, connectionId, database, schema: effectiveSchema, tables });
} else {
try {
const [objects, tables] = await Promise.all([
api.listObjects(connectionId, database, querySchema),
api.listTables(connectionId, database, querySchema),
]);
children = buildGroupedObjectTreeNodes({
children = buildSimpleObjectTreeNodes({
nodeId,
connectionId,
database,
@@ -1139,6 +1163,14 @@ export const useConnectionStore = defineStore("connection", () => {
const tables = await api.listTables(connectionId, database, querySchema);
children = buildTableTreeNodes({ nodeId, connectionId, database, schema: effectiveSchema, tables });
}
} else {
children = buildObjectGroupPlaceholderNodes({
nodeId,
connectionId,
database,
schema: effectiveSchema,
objectTypes: supportedSidebarObjectTypes(config),
});
}
setChildren(node, children);
await savePersistedTreeChildren(cacheKey, children);
@@ -1151,6 +1183,61 @@ export const useConnectionStore = defineStore("connection", () => {
}
}
async function loadObjectGroupChildren(node: TreeNode, options?: LoadTreeOptions) {
if (!node.connectionId || !hasTreeNodeDatabaseContext(node)) return;
node.isLoading = true;
try {
await ensureConnected(node.connectionId);
if (useCachedChildren(node, options)) return;
const objectTypes = objectTypesForGroupNode(node.type);
const parentNodeId = objectGroupRefreshParentId(node);
if (!objectTypes || !parentNodeId) return;
const config = getConfig(node.connectionId);
const querySchema = connectionObjectTreeQuerySchema(config, node.database, node.schema);
const effectiveSchema = connectionObjectTreeNodeSchema(config, node.database, node.schema);
const cacheKey = schemaCacheKey(node.connectionId, node.database, node.schema || "", node.type, "objects-v1");
if (!options?.force) {
const cached = await loadPersistedTreeChildren(node, cacheKey);
if (cached.hit) {
if (cached.isStale) refreshStaleTreeNode(node);
return;
}
}
const wantsOnlyTablesOrViews = objectTypes.every((objectType) => objectType === "TABLE" || objectType === "VIEW");
const objects = wantsOnlyTablesOrViews
? mergeTableInfosIntoObjects(
[],
await api.listTables(node.connectionId, node.database, querySchema),
effectiveSchema,
)
: await api.listObjects(node.connectionId, node.database, querySchema, objectTypes);
const grouped = buildGroupedObjectTreeNodes({
nodeId: parentNodeId,
connectionId: node.connectionId,
database: node.database,
schema: effectiveSchema,
objects: objects.filter((object) => objectTypes.includes(normalizedObjectTreeKind(object.object_type))),
});
const refreshedGroup = grouped.find((group) => group.type === node.type);
const children = refreshedGroup?.children ?? [];
node.objectCount = refreshedGroup?.objectCount ?? children.length;
setChildren(node, children);
await savePersistedTreeChildren(cacheKey, children);
node.isExpanded = true;
} catch (e) {
recordMetadataLoadError(node.connectionId, e);
throw e;
} finally {
node.isLoading = false;
}
}
function normalizedObjectTreeKind(type: string): DatabaseObjectTreeKind {
return normalizeSidebarObjectKind(type);
}
async function loadTableGroups(
connectionId: string,
database: string,
@@ -1431,9 +1518,10 @@ export const useConnectionStore = defineStore("connection", () => {
node.type === "group-views" ||
node.type === "group-procedures" ||
node.type === "group-functions" ||
node.type === "group-packages" ||
node.type === "group-partitions"
node.type === "group-packages"
) {
await loadObjectGroupChildren(node, options);
} else if (node.type === "group-partitions") {
node.isExpanded = true;
}
}
@@ -1448,6 +1536,12 @@ export const useConnectionStore = defineStore("connection", () => {
}
async function refreshTreeNode(node: TreeNode) {
if (objectTypesForGroupNode(node.type)) {
clearLoadedChildrenCache(node.id);
await loadObjectGroupChildren(node, { force: true });
return;
}
const parentId = objectGroupRefreshParentId(node);
const parentNode = parentId ? findNode(treeNodes.value, parentId) : null;
if (parentNode) {
@@ -2166,6 +2260,7 @@ export const useConnectionStore = defineStore("connection", () => {
loadSchemas,
loadSqlServerDatabaseObjects,
loadTables,
loadObjectGroupChildren,
loadTableGroups,
loadColumns,
loadIndexes,
+2 -1
View File
@@ -378,7 +378,8 @@ pub async fn export_database_sql_core(
if request.include_objects && request.selected_tables.is_empty() {
if let Ok(objects) =
crate::schema::list_objects_core(state, &request.connection_id, &request.database, &request.schema).await
crate::schema::list_objects_core(state, &request.connection_id, &request.database, &request.schema, None)
.await
{
for obj in &objects {
let ot = obj.object_type.to_uppercase();
+89 -3
View File
@@ -2,6 +2,7 @@ use crate::connection::{connection_url_for_endpoint, database_connection_config,
use crate::db;
use crate::models::connection::{ConnectionConfig, DatabaseType};
use crate::query::{agent_execute_query_params, QueryExecutionOptions};
use std::collections::HashSet;
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
@@ -555,7 +556,7 @@ fn filter_table_infos(tables: Vec<db::TableInfo>, filter: Option<&str>, limit: O
mod tests {
use super::{
clickhouse_metadata_database, deduplicate_column_infos, duckdb_attach_database, duckdb_list_databases,
duckdb_query_tables_in_database, is_agent_postgres_metadata_fallback_config,
duckdb_query_tables_in_database, filter_objects_by_types, is_agent_postgres_metadata_fallback_config,
};
use crate::models::connection::{ConnectionConfig, DatabaseType};
@@ -682,6 +683,49 @@ mod tests {
assert!(!is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Postgres)));
assert!(!is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Mysql)));
}
#[test]
fn filters_list_objects_by_normalized_object_types() {
let objects = vec![
super::db::ObjectInfo {
name: "orders".to_string(),
object_type: "BASE TABLE".to_string(),
schema: None,
comment: None,
created_at: None,
updated_at: None,
parent_schema: None,
parent_name: None,
},
super::db::ObjectInfo {
name: "active_orders".to_string(),
object_type: "MATERIALIZED VIEW".to_string(),
schema: None,
comment: None,
created_at: None,
updated_at: None,
parent_schema: None,
parent_name: None,
},
super::db::ObjectInfo {
name: "payroll".to_string(),
object_type: "PACKAGE BODY".to_string(),
schema: None,
comment: None,
created_at: None,
updated_at: None,
parent_schema: None,
parent_name: None,
},
];
let filtered = filter_objects_by_types(objects, Some(&["VIEW".to_string(), "PACKAGE_BODY".to_string()]));
assert_eq!(
filtered.iter().map(|object| object.name.as_str()).collect::<Vec<_>>(),
["active_orders", "payroll"]
);
}
}
pub async fn list_objects_core(
@@ -689,9 +733,10 @@ pub async fn list_objects_core(
connection_id: &str,
database: &str,
schema: &str,
object_types: Option<Vec<String>>,
) -> Result<Vec<db::ObjectInfo>, String> {
retry_metadata_connection(state, connection_id, Some(database), || {
list_objects_once(state, connection_id, database, schema)
list_objects_once(state, connection_id, database, schema, object_types.as_deref())
})
.await
}
@@ -713,6 +758,18 @@ async fn list_objects_once(
connection_id: &str,
database: &str,
schema: &str,
object_types: Option<&[String]>,
) -> Result<Vec<db::ObjectInfo>, String> {
list_objects_once_unfiltered(state, connection_id, database, schema)
.await
.map(|objects| filter_objects_by_types(objects, object_types))
}
async fn list_objects_once_unfiltered(
state: &AppState,
connection_id: &str,
database: &str,
schema: &str,
) -> Result<Vec<db::ObjectInfo>, String> {
let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
let db_config = connection_config(state, connection_id).await;
@@ -832,6 +889,35 @@ async fn list_objects_once(
}
}
fn filter_objects_by_types(objects: Vec<db::ObjectInfo>, object_types: Option<&[String]>) -> Vec<db::ObjectInfo> {
let Some(object_types) = object_types else {
return objects;
};
if object_types.is_empty() {
return objects;
}
let wanted: HashSet<String> =
object_types.iter().map(|object_type| normalize_object_info_type(object_type)).collect();
objects.into_iter().filter(|object| wanted.contains(&normalize_object_info_type(&object.object_type))).collect()
}
fn normalize_object_info_type(object_type: &str) -> String {
let value = object_type.to_ascii_uppercase().replace(' ', "_");
if value.contains("PACKAGE_BODY") {
"PACKAGE_BODY".to_string()
} else if value.contains("PACKAGE") {
"PACKAGE".to_string()
} else if value.contains("VIEW") {
"VIEW".to_string()
} else if value.contains("PROC") {
"PROCEDURE".to_string()
} else if value.contains("FUNC") {
"FUNCTION".to_string()
} else {
"TABLE".to_string()
}
}
async fn list_completion_objects_once(
state: &AppState,
connection_id: &str,
@@ -919,7 +1005,7 @@ async fn list_completion_objects_once(
PoolKind::Postgres(p) => db::postgres::list_objects(p, schema).await.map(filter_completion_objects),
PoolKind::SqlServer(_) => {
drop(connections);
let objects = list_objects_once(state, connection_id, database, schema).await?;
let objects = list_objects_once(state, connection_id, database, schema, None).await?;
Ok(filter_completion_objects(objects))
}
_ => Ok(Vec::new()),
+9 -2
View File
@@ -16,6 +16,7 @@ pub struct SchemaQuery {
pub filter: Option<String>,
pub limit: Option<usize>,
pub object_type: Option<dbx_core::db::ObjectSourceKind>,
pub object_types: Option<String>,
}
pub async fn list_databases(
@@ -60,11 +61,17 @@ pub async fn list_objects(
) -> Result<Json<serde_json::Value>, AppError> {
let database = q.database.as_deref().unwrap_or("");
let schema = q.schema.as_deref().unwrap_or("");
let result =
dbx_core::schema::list_objects_core(&state.app, &q.connection_id, database, schema).await.map_err(AppError)?;
let object_types = q.object_types.as_deref().map(parse_object_types).filter(|types| !types.is_empty());
let result = dbx_core::schema::list_objects_core(&state.app, &q.connection_id, database, schema, object_types)
.await
.map_err(AppError)?;
Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
}
fn parse_object_types(value: &str) -> Vec<String> {
value.split(',').map(str::trim).filter(|value| !value.is_empty()).map(ToString::to_string).collect()
}
pub async fn list_completion_objects(
State(state): State<Arc<WebState>>,
Query(q): Query<SchemaQuery>,
@@ -6,6 +6,7 @@ import {
databaseObjectTreeNodeSchema,
databaseObjectTreeQuerySchema,
getDatabaseCapability,
sidebarObjectKindsForDatabase,
supportsDatabaseCreation,
supportsDatabaseSearch,
supportsDriverManagement,
@@ -266,3 +267,16 @@ test("object browser entry follows database tree shape", () => {
assert.equal(supportsObjectBrowserTreeNode("jdbc", "database"), true);
assert.equal(supportsObjectBrowserTreeNode("mongodb", "database"), false);
});
test("sidebar object capability registry describes object groups by database type", () => {
assert.deepEqual(sidebarObjectKindsForDatabase("databend"), ["TABLE", "VIEW"]);
assert.deepEqual(sidebarObjectKindsForDatabase("postgres"), ["TABLE", "VIEW", "PROCEDURE", "FUNCTION"]);
assert.deepEqual(sidebarObjectKindsForDatabase("oracle"), [
"TABLE",
"VIEW",
"PROCEDURE",
"FUNCTION",
"PACKAGE",
"PACKAGE_BODY",
]);
});
+34 -9
View File
@@ -11,11 +11,12 @@ function obj(name: string, objectType = "TABLE"): ObjectInfo {
}
test("SQL Server database tree groups dbo objects and keeps non-default schemas", () => {
const nodes = buildSqlServerDatabaseTreeNodes("conn", "app", ["dbo", "zeta", "sales"], [
obj("customers"),
obj("customer_view", "VIEW"),
obj("get_total", "FUNCTION"),
]);
const nodes = buildSqlServerDatabaseTreeNodes(
"conn",
"app",
["dbo", "zeta", "sales"],
[obj("customers"), obj("customer_view", "VIEW"), obj("get_total", "FUNCTION")],
);
const topLevel = nodes.map((n) => ({ id: n.id, label: n.label, type: n.type }));
assert.deepEqual(topLevel, [
@@ -52,10 +53,12 @@ test("SQL Server database tree shows only schemas when dbo has no objects", () =
});
test("SQL Server database tree groups procedures alongside tables", () => {
const nodes = buildSqlServerDatabaseTreeNodes("conn", "app", ["dbo"], [
obj("orders"),
obj("sp_refresh", "PROCEDURE"),
]);
const nodes = buildSqlServerDatabaseTreeNodes(
"conn",
"app",
["dbo"],
[obj("orders"), obj("sp_refresh", "PROCEDURE")],
);
assert.deepEqual(
nodes.map((n) => ({ label: n.label, type: n.type })),
@@ -65,3 +68,25 @@ test("SQL Server database tree groups procedures alongside tables", () => {
],
);
});
test("SQL Server database tree can render lazy object groups before metadata is loaded", () => {
const nodes = buildSqlServerDatabaseTreeNodes("conn", "app", ["dbo", "sales"], [], {
lazyObjectTypes: ["TABLE", "VIEW", "PROCEDURE", "FUNCTION"],
});
assert.deepEqual(
nodes.map((n) => ({ label: n.label, type: n.type, count: n.objectCount, children: n.children })),
[
{ label: "tree.tables", type: "group-tables", count: undefined, children: [] },
{ label: "tree.views", type: "group-views", count: undefined, children: [] },
{ label: "tree.procedures", type: "group-procedures", count: undefined, children: [] },
{ label: "tree.functions", type: "group-functions", count: undefined, children: [] },
{
label: "sales",
type: "schema",
count: undefined,
children: [],
},
],
);
});
+51
View File
@@ -2,6 +2,8 @@ import test from "node:test";
import assert from "node:assert/strict";
import {
buildGroupedObjectTreeNodes,
buildObjectGroupPlaceholderNodes,
buildSimpleObjectTreeNodes,
buildTableTreeNodes,
mergeTableInfosIntoObjects,
} from "../../apps/desktop/src/lib/tableTree.ts";
@@ -169,6 +171,55 @@ test("buildGroupedObjectTreeNodes groups Oracle packages and package bodies", ()
);
});
test("buildObjectGroupPlaceholderNodes creates capability-driven lazy sidebar groups", () => {
const groups = buildObjectGroupPlaceholderNodes({
nodeId: "conn:app:HR",
connectionId: "conn",
database: "app",
schema: "HR",
objectTypes: ["TABLE", "VIEW", "PROCEDURE", "FUNCTION"],
});
assert.deepEqual(
groups.map((node) => ({ label: node.label, type: node.type, count: node.objectCount, children: node.children })),
[
{ label: "tree.tables", type: "group-tables", count: undefined, children: [] },
{ label: "tree.views", type: "group-views", count: undefined, children: [] },
{ label: "tree.procedures", type: "group-procedures", count: undefined, children: [] },
{ label: "tree.functions", type: "group-functions", count: undefined, children: [] },
],
);
});
test("buildSimpleObjectTreeNodes keeps routines and packages visible in flat sidebar mode", () => {
const nodes = buildSimpleObjectTreeNodes({
nodeId: "conn:app:HR",
connectionId: "conn",
database: "app",
schema: "HR",
objects: [
{ name: "ORDERS", object_type: "TABLE", schema: "HR" },
{ name: "ACTIVE_ORDERS", object_type: "VIEW", schema: "HR" },
{ name: "REFRESH_STATS", object_type: "PROCEDURE", schema: "HR" },
{ name: "TOTAL_DUE", object_type: "FUNCTION", schema: "HR" },
{ name: "PAYROLL", object_type: "PACKAGE", schema: "HR" },
{ name: "PAYROLL", object_type: "PACKAGE_BODY", schema: "HR" },
],
});
assert.deepEqual(
nodes.map((node) => ({ label: node.label, type: node.type })),
[
{ label: "ORDERS", type: "table" },
{ label: "ACTIVE_ORDERS", type: "view" },
{ label: "PAYROLL", type: "package" },
{ label: "PAYROLL", type: "package-body" },
{ label: "REFRESH_STATS", type: "procedure" },
{ label: "TOTAL_DUE", type: "function" },
],
);
});
test("mergeTableInfosIntoObjects restores views missing from object metadata", () => {
const merged = mergeTableInfosIntoObjects(
[object("orders")],
+2 -1
View File
@@ -39,8 +39,9 @@ pub async fn list_objects(
connection_id: String,
database: String,
schema: String,
object_types: Option<Vec<String>>,
) -> Result<Vec<db::ObjectInfo>, String> {
dbx_core::schema::list_objects_core(&state, &connection_id, &database, &schema).await
dbx_core::schema::list_objects_core(&state, &connection_id, &database, &schema, object_types).await
}
#[tauri::command]