feat(data-grid): add configurable default sorting

apps/desktop/src/composables/useSidebarDataOpenRuntime.ts

@@ -11,6 +11,7 @@ import { canApplyDataTabMetadata, dataTabMetadataNeedsRefresh, findExistingDataT
 import type { SidebarDataOpenRequest } from "@/lib/sidebar/sidebarDataOpenCoordinator";
 import { hasTreeNodeDatabaseContext } from "@/lib/sidebar/treeNodeContext";
 import { buildTableSelectSql } from "@/lib/table/tableSelectSql";
+import { applyOpenTableDefaultSortState, buildOpenTableDefaultSort } from "@/lib/table/tableDefaultSort";
 import { usesSyntheticRowIdKey } from "@/lib/table/tableEditing";
 import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
 import { canActivateExistingDataTableTab } from "@/lib/tabs/dataTabActivation";
@@ -141,6 +142,8 @@ export function useSidebarDataOpenRuntime() {
       tab.resultLocalSortOriginalMongoDocuments = undefined;
       tab.resultLocalSortOriginalMongoCopyDocuments = undefined;
       tab.resultSortedSql = undefined;
+      tab.openTableDefaultSortApplied = undefined;
+      tab.openTableDefaultSortOrderBy = undefined;
       tab.resultPageSql = undefined;
       tab.resultPageLimit = undefined;
       tab.resultPageOffset = undefined;
@@ -274,22 +277,48 @@ export function useSidebarDataOpenRuntime() {
       if (!config) throw new Error("Connection config not found");
 
       const limit = tableOpenPageLimit(settingsStore.editorSettings.tableOpenPageSize);
-      const shouldRefreshTableMeta = !cachedTableMeta;
+      const openTableDefaultSortMode = settingsStore.editorSettings.openTableDefaultSortMode;
+      let tableMetaForQuery = cachedTableMeta;
+      let shouldRefreshTableMeta = !tableMetaForQuery;
       // Dameng metadata calls must remain serialized behind the table query.
       const deferTableMetaRefresh = effectiveDbType === "dameng";
-      if (cachedTableMeta) {
+      let attemptedDefaultSortMetadataLoad = false;
+      if (openTableDefaultSortMode !== "none" && !tableMetaForQuery && !deferTableMetaRefresh) {
+        attemptedDefaultSortMetadataLoad = true;
+        try {
+          const loadedMetadata = await loadTableMetadata({
+            connectionId: node.connectionId,
+            database: node.database,
+            schema: querySchema,
+            tableName: node.label,
+            tableType,
+            databaseType: metadataDatabaseType,
+            driverProfile: config.driver_profile || config.db_type,
+            catalog: node.catalog,
+            traceLogger: isDebugLoggingEnabled() ? (event) => openDataLog("debug", "metadata:trace", { sourceTraceId: traceId, ...event }) : undefined,
+          });
+          if (!isActive() || !canApplyTableMetadata(tabId)) return;
+          tableMetaForQuery = tableMetadataToDataTabMeta(loadedMetadata.metadata, tableSchema);
+          queryStore.setTableMeta(tabId, tableMetaForQuery);
+          shouldRefreshTableMeta = false;
+          logPhase("metadata-loaded-for-default-sort", { tabId, columnCount: tableMetaForQuery.columns.length, primaryKeyCount: tableMetaForQuery.primaryKeys.length });
+        } catch (error) {
+          openDataLog("warn", "metadata:default-sort:error", { traceId, tabId, elapsed: elapsed(), error });
+        }
+      }
+      if (tableMetaForQuery) {
         openDataLog("info", "metadata:cache-hit", {
           traceId,
           tabId,
-          columnCount: cachedTableMeta.columns.length,
-          primaryKeyCount: cachedTableMeta.primaryKeys.length,
+          columnCount: tableMetaForQuery.columns.length,
+          primaryKeyCount: tableMetaForQuery.primaryKeys.length,
           source: cachedTableMetaSource,
           ageMs: Math.round(cachedTableMetaAgeMs),
           elapsed: elapsed(),
         });
       } else if (deferTableMetaRefresh) {
         logPhase("metadata-deferred", { tabId });
-      } else {
+      } else if (!attemptedDefaultSortMetadataLoad) {
         void refreshTableMetaInBackground(tabId);
         logPhase("metadata-started", { tabId });
       }
@@ -300,8 +329,15 @@ export function useSidebarDataOpenRuntime() {
         return;
       }
 
-      const columns = cachedTableMeta?.columns ?? [];
-      const primaryKeys = cachedTableMeta?.primaryKeys ?? [];
+      const columns = tableMetaForQuery?.columns ?? [];
+      const primaryKeys = tableMetaForQuery?.primaryKeys ?? [];
+      const defaultSort = buildOpenTableDefaultSort({
+        mode: openTableDefaultSortMode,
+        databaseType: effectiveDbType,
+        identifierQuote: connectionStore.connectionIdentifierQuote?.(node.connectionId),
+        primaryKeys,
+        columns: columns.map((column) => column.name),
+      });
       const includeRowId = usesSyntheticRowIdKey(effectiveDbType, primaryKeys, tableType);
       const sql = await buildTableSelectSql({
         databaseType: effectiveDbType,
@@ -313,6 +349,7 @@ export function useSidebarDataOpenRuntime() {
         catalog: node.catalog,
         columns: columns.map((column) => column.name),
         primaryKeys,
+        orderBy: defaultSort?.orderBy,
         limit,
         includeRowId,
       });
@@ -339,6 +376,8 @@ export function useSidebarDataOpenRuntime() {
         skipEnsureConnected: true,
         pagination: { limit, offset: 0 },
       });
+      const currentTab = queryStore.tabs.find((item) => item.id === tabId);
+      if (currentTab) applyOpenTableDefaultSortState(currentTab, defaultSort);
       openDataLog("info", "execute:done", { traceId, tabId, elapsed: elapsed() });
       logPhase("execute-tab-sql", { tabId });
       if (shouldRefreshTableMeta && deferTableMetaRefresh && canApplyTableMetadata(tabId)) {