⚡️ perf(table): 表数据打开加速，主键/统计等耗时操作异步化

- DataViewer 主键列元数据异步拉取，首屏数据优先渲染
  - 查询页增加结果集最大行数限制，减少大表全量返回
  - DBQuery 引入 Context 超时，降低长查询对 UI 的阻塞风险
  - 查询行数设置持久化保存
  Closes #48
  Closes #49

frontend/src/components/DataViewer.tsx

@@ -14,6 +14,8 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
   const fetchSeqRef = useRef(0);
   const countSeqRef = useRef(0);
   const countKeyRef = useRef<string>('');
+  const pkSeqRef = useRef(0);
+  const pkKeyRef = useRef<string>('');
 
   const [pagination, setPagination] = useState({
       current: 1,
@@ -27,6 +29,13 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
   const [showFilter, setShowFilter] = useState(false);
   const [filterConditions, setFilterConditions] = useState<any[]>([]);
 
+  useEffect(() => {
+    setPkColumns([]);
+    pkKeyRef.current = '';
+    countKeyRef.current = '';
+    setPagination(prev => ({ ...prev, current: 1, total: 0, totalKnown: false }));
+  }, [tab.connectionId, tab.dbName, tab.tableName]);
+
   const fetchData = useCallback(async (page = pagination.current, size = pagination.pageSize) => {
     const seq = ++fetchSeqRef.current;
     setLoading(true);
@@ -103,11 +112,6 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
     try {
         const pData = DBQuery(config as any, dbName, sql);
 
-        let pCols: Promise<any> | null = null;
-        if (pkColumns.length === 0) {
-             pCols = DBGetColumns(config as any, dbName, tableName);
-        }
-
         const resData = await pData;
         const duration = Date.now() - startTime;
         
@@ -123,11 +127,23 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
             dbName
         });
         
-        if (pCols) {
-            const resCols = await pCols;
-            if (resCols.success) {
-                const pks = (resCols.data as ColumnDefinition[]).filter(c => c.key === 'PRI').map(c => c.name);
-                setPkColumns(pks);
+        if (pkColumns.length === 0) {
+            const pkKey = `${tab.connectionId}|${dbName}|${tableName}`;
+            if (pkKeyRef.current !== pkKey) {
+                pkKeyRef.current = pkKey;
+                const pkSeq = ++pkSeqRef.current;
+                DBGetColumns(config as any, dbName, tableName)
+                    .then((resCols: any) => {
+                        if (pkSeqRef.current !== pkSeq) return;
+                        if (pkKeyRef.current !== pkKey) return;
+                        if (!resCols?.success) return;
+                        const pks = (resCols.data as ColumnDefinition[]).filter((c: any) => c.key === 'PRI').map((c: any) => c.name);
+                        setPkColumns(pks);
+                    })
+                    .catch(() => {
+                        if (pkSeqRef.current !== pkSeq) return;
+                        if (pkKeyRef.current !== pkKey) return;
+                    });
             }
         }
 

frontend/src/components/QueryEditor.tsx

@@ -19,6 +19,8 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
       tableName?: string;
       pkColumns: string[];
       readOnly: boolean;
+      truncated?: boolean;
+      pkLoading?: boolean;
   };
 
   // Result Sets
@@ -26,6 +28,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
   const [activeResultKey, setActiveResultKey] = useState<string>('');
   
   const [loading, setLoading] = useState(false);
+  const runSeqRef = useRef(0);
   const [isSaveModalOpen, setIsSaveModalOpen] = useState(false);
   const [saveForm] = Form.useForm();
   
@@ -47,6 +50,13 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
   const darkMode = useStore(state => state.darkMode);
   const sqlFormatOptions = useStore(state => state.sqlFormatOptions);
   const setSqlFormatOptions = useStore(state => state.setSqlFormatOptions);
+  const queryOptions = useStore(state => state.queryOptions);
+  const setQueryOptions = useStore(state => state.setQueryOptions);
+
+  const currentDbRef = useRef(currentDb);
+  useEffect(() => {
+      currentDbRef.current = currentDb;
+  }, [currentDb]);
 
   // If opening a saved query, load its SQL
   useEffect(() => {
@@ -72,7 +82,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
           if (res.success && Array.isArray(res.data)) {
               const dbs = res.data.map((row: any) => row.Database || row.database);
               setDbList(dbs);
-              if (!currentDb) {
+              if (!currentDbRef.current) {
                   if (conn.config.database) setCurrentDb(conn.config.database);
                   else if (dbs.length > 0 && dbs[0] !== 'information_schema') setCurrentDb(dbs[0]);
               }
@@ -81,7 +91,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
           }
       };
       fetchDbs();
-  }, [currentConnectionId, connections, currentDb]);
+  }, [currentConnectionId, connections]);
 
   // Fetch Metadata for Autocomplete
   useEffect(() => {
@@ -343,6 +353,327 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
     return statements;
   };
 
+  const getLeadingKeyword = (sql: string): string => {
+      const text = (sql || '').replace(/\r\n/g, '\n');
+      const isWS = (ch: string) => ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+      const isWord = (ch: string) => /[A-Za-z0-9_]/.test(ch);
+
+      let inSingle = false;
+      let inDouble = false;
+      let inBacktick = false;
+      let escaped = false;
+      let inLineComment = false;
+      let inBlockComment = false;
+      let dollarTag: string | null = null;
+
+      for (let i = 0; i < text.length; i++) {
+          const ch = text[i];
+          const next = i + 1 < text.length ? text[i + 1] : '';
+          const prev = i > 0 ? text[i - 1] : '';
+          const next2 = i + 2 < text.length ? text[i + 2] : '';
+
+          if (!inSingle && !inDouble && !inBacktick) {
+              if (inLineComment) {
+                  if (ch === '\n') inLineComment = false;
+                  continue;
+              }
+              if (inBlockComment) {
+                  if (ch === '*' && next === '/') {
+                      i++;
+                      inBlockComment = false;
+                  }
+                  continue;
+              }
+
+              if (ch === '/' && next === '*') {
+                  i++;
+                  inBlockComment = true;
+                  continue;
+              }
+              if (ch === '#') {
+                  inLineComment = true;
+                  continue;
+              }
+              if (ch === '-' && next === '-' && (i === 0 || isWS(prev)) && (next2 === '' || isWS(next2))) {
+                  i++;
+                  inLineComment = true;
+                  continue;
+              }
+
+              if (dollarTag) {
+                  if (text.startsWith(dollarTag, i)) {
+                      i += dollarTag.length - 1;
+                      dollarTag = null;
+                  }
+                  continue;
+              }
+              if (ch === '$') {
+                  const m = text.slice(i).match(/^\$[A-Za-z0-9_]*\$/);
+                  if (m && m[0]) {
+                      dollarTag = m[0];
+                      i += dollarTag.length - 1;
+                      continue;
+                  }
+              }
+          }
+
+          if (escaped) {
+              escaped = false;
+              continue;
+          }
+          if ((inSingle || inDouble) && ch === '\\') {
+              escaped = true;
+              continue;
+          }
+
+          if (!inDouble && !inBacktick && ch === '\'') {
+              inSingle = !inSingle;
+              continue;
+          }
+          if (!inSingle && !inBacktick && ch === '"') {
+              inDouble = !inDouble;
+              continue;
+          }
+          if (!inSingle && !inDouble && ch === '`') {
+              inBacktick = !inBacktick;
+              continue;
+          }
+
+          if (inSingle || inDouble || inBacktick || dollarTag) continue;
+          if (isWS(ch)) continue;
+
+          if (isWord(ch)) {
+              let j = i;
+              while (j < text.length && isWord(text[j])) j++;
+              return text.slice(i, j).toLowerCase();
+          }
+          return '';
+      }
+      return '';
+  };
+
+  const splitSqlTail = (sql: string): { main: string; tail: string } => {
+      const text = (sql || '').replace(/\r\n/g, '\n');
+      const isWS = (ch: string) => ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+
+      let inSingle = false;
+      let inDouble = false;
+      let inBacktick = false;
+      let escaped = false;
+      let inLineComment = false;
+      let inBlockComment = false;
+      let dollarTag: string | null = null;
+      let lastMeaningful = -1;
+
+      for (let i = 0; i < text.length; i++) {
+          const ch = text[i];
+          const next = i + 1 < text.length ? text[i + 1] : '';
+          const prev = i > 0 ? text[i - 1] : '';
+          const next2 = i + 2 < text.length ? text[i + 2] : '';
+
+          if (!inSingle && !inDouble && !inBacktick) {
+              if (dollarTag) {
+                  if (text.startsWith(dollarTag, i)) {
+                      lastMeaningful = i + dollarTag.length - 1;
+                      i += dollarTag.length - 1;
+                      dollarTag = null;
+                  } else if (!isWS(ch)) {
+                      lastMeaningful = i;
+                  }
+                  continue;
+              }
+              if (inLineComment) {
+                  if (ch === '\n') inLineComment = false;
+                  continue;
+              }
+              if (inBlockComment) {
+                  if (ch === '*' && next === '/') {
+                      i++;
+                      inBlockComment = false;
+                  }
+                  continue;
+              }
+
+              // Start comments
+              if (ch === '/' && next === '*') {
+                  i++;
+                  inBlockComment = true;
+                  continue;
+              }
+              if (ch === '#') {
+                  inLineComment = true;
+                  continue;
+              }
+              if (ch === '-' && next === '-' && (i === 0 || isWS(prev)) && (next2 === '' || isWS(next2))) {
+                  i++;
+                  inLineComment = true;
+                  continue;
+              }
+
+              if (ch === '$') {
+                  const m = text.slice(i).match(/^\$[A-Za-z0-9_]*\$/);
+                  if (m && m[0]) {
+                      dollarTag = m[0];
+                      lastMeaningful = i + dollarTag.length - 1;
+                      i += dollarTag.length - 1;
+                      continue;
+                  }
+              }
+          }
+
+          if (escaped) {
+              escaped = false;
+          } else if ((inSingle || inDouble) && ch === '\\') {
+              escaped = true;
+          } else {
+              if (!inDouble && !inBacktick && ch === '\'') inSingle = !inSingle;
+              else if (!inSingle && !inBacktick && ch === '"') inDouble = !inDouble;
+              else if (!inSingle && !inDouble && ch === '`') inBacktick = !inBacktick;
+          }
+
+          if (!inLineComment && !inBlockComment && !isWS(ch)) {
+              lastMeaningful = i;
+          }
+      }
+
+      if (lastMeaningful < 0) return { main: '', tail: text };
+      return { main: text.slice(0, lastMeaningful + 1), tail: text.slice(lastMeaningful + 1) };
+  };
+
+  const findTopLevelKeyword = (sql: string, keyword: string): number => {
+      const text = sql;
+      const kw = keyword.toLowerCase();
+      const isWS = (ch: string) => ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+      const isWord = (ch: string) => /[A-Za-z0-9_]/.test(ch);
+
+      let inSingle = false;
+      let inDouble = false;
+      let inBacktick = false;
+      let escaped = false;
+      let inLineComment = false;
+      let inBlockComment = false;
+      let dollarTag: string | null = null;
+      let parenDepth = 0;
+
+      for (let i = 0; i < text.length; i++) {
+          const ch = text[i];
+          const next = i + 1 < text.length ? text[i + 1] : '';
+          const prev = i > 0 ? text[i - 1] : '';
+          const next2 = i + 2 < text.length ? text[i + 2] : '';
+
+          if (!inSingle && !inDouble && !inBacktick) {
+              if (inLineComment) {
+                  if (ch === '\n') inLineComment = false;
+                  continue;
+              }
+              if (inBlockComment) {
+                  if (ch === '*' && next === '/') {
+                      i++;
+                      inBlockComment = false;
+                  }
+                  continue;
+              }
+
+              if (ch === '/' && next === '*') {
+                  i++;
+                  inBlockComment = true;
+                  continue;
+              }
+              if (ch === '#') {
+                  inLineComment = true;
+                  continue;
+              }
+              if (ch === '-' && next === '-' && (i === 0 || isWS(prev)) && (next2 === '' || isWS(next2))) {
+                  i++;
+                  inLineComment = true;
+                  continue;
+              }
+
+              if (dollarTag) {
+                  if (text.startsWith(dollarTag, i)) {
+                      i += dollarTag.length - 1;
+                      dollarTag = null;
+                  }
+                  continue;
+              }
+              if (ch === '$') {
+                  const m = text.slice(i).match(/^\$[A-Za-z0-9_]*\$/);
+                  if (m && m[0]) {
+                      dollarTag = m[0];
+                      i += dollarTag.length - 1;
+                      continue;
+                  }
+              }
+          }
+
+          if (escaped) {
+              escaped = false;
+              continue;
+          }
+          if ((inSingle || inDouble) && ch === '\\') {
+              escaped = true;
+              continue;
+          }
+
+          if (!inDouble && !inBacktick && ch === '\'') {
+              inSingle = !inSingle;
+              continue;
+          }
+          if (!inSingle && !inBacktick && ch === '"') {
+              inDouble = !inDouble;
+              continue;
+          }
+          if (!inSingle && !inDouble && ch === '`') {
+              inBacktick = !inBacktick;
+              continue;
+          }
+
+          if (inSingle || inDouble || inBacktick || dollarTag) continue;
+
+          if (ch === '(') { parenDepth++; continue; }
+          if (ch === ')') { if (parenDepth > 0) parenDepth--; continue; }
+          if (parenDepth !== 0) continue;
+
+          if (!isWord(ch)) continue;
+
+          if (text.slice(i, i + kw.length).toLowerCase() !== kw) continue;
+          const before = i - 1 >= 0 ? text[i - 1] : '';
+          const after = i + kw.length < text.length ? text[i + kw.length] : '';
+          if ((before && isWord(before)) || (after && isWord(after))) continue;
+          return i;
+      }
+      return -1;
+  };
+
+  const applyAutoLimit = (sql: string, dbType: string, maxRows: number): { sql: string; applied: boolean; maxRows: number } => {
+      const normalizedType = (dbType || 'mysql').toLowerCase();
+      const supportsLimit = normalizedType === 'mysql' || normalizedType === 'postgres' || normalizedType === 'kingbase' || normalizedType === 'sqlite' || normalizedType === '';
+      if (!supportsLimit) return { sql, applied: false, maxRows };
+      if (!Number.isFinite(maxRows) || maxRows <= 0) return { sql, applied: false, maxRows };
+
+      const { main, tail } = splitSqlTail(sql);
+      if (!main.trim()) return { sql, applied: false, maxRows };
+
+      const fromPos = findTopLevelKeyword(main, 'from');
+      const limitPos = findTopLevelKeyword(main, 'limit');
+      if (limitPos >= 0 && (fromPos < 0 || limitPos > fromPos)) return { sql, applied: false, maxRows };
+      const fetchPos = findTopLevelKeyword(main, 'fetch');
+      if (fetchPos >= 0 && (fromPos < 0 || fetchPos > fromPos)) return { sql, applied: false, maxRows };
+
+      const offsetPos = findTopLevelKeyword(main, 'offset');
+      const forPos = findTopLevelKeyword(main, 'for');
+      const lockPos = findTopLevelKeyword(main, 'lock');
+
+      const candidates = [offsetPos, forPos, lockPos]
+          .filter(pos => pos >= 0 && (fromPos < 0 || pos > fromPos));
+
+      const insertAt = candidates.length > 0 ? Math.min(...candidates) : main.length;
+      const before = main.slice(0, insertAt).trimEnd();
+      const after = main.slice(insertAt).trimStart();
+      const nextMain = [before, `LIMIT ${maxRows}`, after].filter(Boolean).join(' ').trim();
+      return { sql: nextMain + tail, applied: true, maxRows };
+  };
+
   const getSelectedSQL = (): string => {
       const editor = editorRef.current;
       if (!editor) return '';
@@ -362,12 +693,13 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         message.error("请先选择数据库");
         return;
     }
+    const runSeq = ++runSeqRef.current;
     setLoading(true);
     const runStartTime = Date.now();
     const conn = connections.find(c => c.id === currentConnectionId);
     if (!conn) {
         message.error("Connection not found");
-        setLoading(false);
+        if (runSeqRef.current === runSeq) setLoading(false);
         return;
     }
 
@@ -391,17 +723,29 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         }
 
         const nextResultSets: ResultSet[] = [];
+        const maxRows = Number(queryOptions?.maxRows) || 0;
+        const dbType = String((config as any).type || 'mysql');
+        const wantsLimitProbe = Number.isFinite(maxRows) && maxRows > 0;
+        const probeLimit = wantsLimitProbe ? (maxRows + 1) : 0;
+        let anyTruncated = false;
+        const pendingPk: Array<{ resultKey: string; tableName: string }> = [];
 
         for (let idx = 0; idx < statements.length; idx++) {
-            const sql = statements[idx];
+            const rawStatement = statements[idx];
+            const leadingKeyword = getLeadingKeyword(rawStatement);
+            const shouldAutoLimit = leadingKeyword === 'select' || leadingKeyword === 'with';
+
+            const limitApplied = shouldAutoLimit && wantsLimitProbe;
+            const limited = limitApplied ? applyAutoLimit(rawStatement, dbType, probeLimit) : { sql: rawStatement, applied: false, maxRows: probeLimit };
+            const executedSql = limited.sql;
             const startTime = Date.now();
-            const res = await DBQuery(config as any, currentDb, sql);
+            const res = await DBQuery(config as any, currentDb, executedSql);
             const duration = Date.now() - startTime;
 
             addSqlLog({
                 id: `log-${Date.now()}-query-${idx + 1}`,
                 timestamp: Date.now(),
-                sql,
+                sql: executedSql,
                 status: res.success ? 'success' : 'error',
                 duration,
                 message: res.success ? '' : res.message,
@@ -418,7 +762,13 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
             }
 
             if (Array.isArray(res.data)) {
-                const rows = (res.data as any[]) || [];
+                let rows = (res.data as any[]) || [];
+                let truncated = false;
+                if (limited.applied && Number.isFinite(maxRows) && maxRows > 0 && rows.length > maxRows) {
+                    truncated = true;
+                    anyTruncated = true;
+                    rows = rows.slice(0, maxRows);
+                }
                 const cols = (res.fields && res.fields.length > 0)
                     ? (res.fields as string[])
                     : (rows.length > 0 ? Object.keys(rows[0]) : []);
@@ -428,24 +778,22 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
                 });
 
                 let simpleTableName: string | undefined = undefined;
-                let primaryKeys: string[] = [];
-                const tableMatch = sql.match(/^\s*SELECT\s+\*\s+FROM\s+[`"]?(\w+)[`"]?\s*(?:WHERE.*)?(?:ORDER BY.*)?(?:LIMIT.*)?$/i);
+                const tableMatch = rawStatement.match(/^\s*SELECT\s+\*\s+FROM\s+[`"]?(\w+)[`"]?\s*(?:WHERE.*)?(?:ORDER BY.*)?(?:LIMIT.*)?$/i);
                 if (tableMatch) {
                     simpleTableName = tableMatch[1];
-                    const resCols = await DBGetColumns(config as any, currentDb, simpleTableName);
-                    if (resCols.success) {
-                        primaryKeys = (resCols.data as ColumnDefinition[]).filter(c => c.key === 'PRI').map(c => c.name);
-                    }
+                    pendingPk.push({ resultKey: `result-${idx + 1}`, tableName: simpleTableName });
                 }
 
                 nextResultSets.push({
                     key: `result-${idx + 1}`,
-                    sql,
+                    sql: rawStatement,
                     rows,
                     columns: cols,
                     tableName: simpleTableName,
-                    pkColumns: primaryKeys,
-                    readOnly: !simpleTableName
+                    pkColumns: [],
+                    readOnly: true,
+                    pkLoading: !!simpleTableName,
+                    truncated
                 });
             } else {
                 const affected = Number((res.data as any)?.affectedRows);
@@ -454,7 +802,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
                     (row as any)[GONAVI_ROW_KEY] = 0;
                     nextResultSets.push({
                         key: `result-${idx + 1}`,
-                        sql,
+                        sql: rawStatement,
                         rows: [row],
                         columns: ['affectedRows'],
                         pkColumns: [],
@@ -467,11 +815,31 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         setResultSets(nextResultSets);
         setActiveResultKey(nextResultSets[0]?.key || '');
 
+        pendingPk.forEach(({ resultKey, tableName }) => {
+            DBGetColumns(config as any, currentDb, tableName)
+                .then((resCols: any) => {
+                    if (runSeqRef.current !== runSeq) return;
+                    if (!resCols?.success) {
+                        setResultSets(prev => prev.map(rs => rs.key === resultKey ? { ...rs, pkLoading: false, readOnly: false } : rs));
+                        return;
+                    }
+                    const primaryKeys = (resCols.data as ColumnDefinition[]).filter(c => c.key === 'PRI').map(c => c.name);
+                    setResultSets(prev => prev.map(rs => rs.key === resultKey ? { ...rs, pkColumns: primaryKeys, pkLoading: false, readOnly: false } : rs));
+                })
+                .catch(() => {
+                    if (runSeqRef.current !== runSeq) return;
+                    setResultSets(prev => prev.map(rs => rs.key === resultKey ? { ...rs, pkLoading: false, readOnly: false } : rs));
+                });
+        });
+
         if (statements.length > 1) {
             message.success(`已执行 ${statements.length} 条语句，生成 ${nextResultSets.length} 个结果集。`);
         } else if (nextResultSets.length === 0) {
             message.success('执行成功。');
         }
+        if (anyTruncated && maxRows > 0) {
+            message.warning(`结果集已自动限制为最多 ${maxRows} 行（可在工具栏调整）。`);
+        }
     } catch (e: any) {
         message.error("Error executing query: " + e.message);
         addSqlLog({
@@ -486,7 +854,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         setResultSets([]);
         setActiveResultKey('');
     } finally {
-        setLoading(false);
+        if (runSeqRef.current === runSeq) setLoading(false);
     }
   };
 
@@ -587,6 +955,20 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
             options={dbList.map(db => ({ label: db, value: db }))}
             showSearch
         />
+        <Tooltip title="最大返回行数（会对 SELECT 自动加 LIMIT，防止大结果集卡死）">
+            <Select
+                style={{ width: 170 }}
+                value={queryOptions?.maxRows ?? 5000}
+                onChange={(val) => setQueryOptions({ maxRows: Number(val) })}
+                options={[
+                    { label: '最大行数：500', value: 500 },
+                    { label: '最大行数：1000', value: 1000 },
+                    { label: '最大行数：5000', value: 5000 },
+                    { label: '最大行数：20000', value: 20000 },
+                    { label: '最大行数：不限', value: 0 },
+                ]}
+            />
+        </Tooltip>
         <Button type="primary" icon={<PlayCircleOutlined />} onClick={handleRun} loading={loading}>
           运行
         </Button>
@@ -649,7 +1031,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
                   label: (
                       <div style={{ display: 'inline-flex', alignItems: 'center', gap: 6 }}>
                           <Tooltip title={rs.sql}>
-                              <span>{`结果 ${idx + 1}${Array.isArray(rs.rows) ? ` (${rs.rows.length})` : ''}`}</span>
+                              <span>{`结果 ${idx + 1}${Array.isArray(rs.rows) ? ` (${rs.rows.length}${rs.truncated ? '+' : ''})` : ''}`}</span>
                           </Tooltip>
                           <Tooltip title="关闭结果">
                               <span

frontend/src/store.ts

@@ -21,6 +21,7 @@ interface AppState {
   savedQueries: SavedQuery[];
   darkMode: boolean;
   sqlFormatOptions: { keywordCase: 'upper' | 'lower' };
+  queryOptions: { maxRows: number };
   sqlLogs: SqlLog[];
   
   addConnection: (conn: SavedConnection) => void;
@@ -41,6 +42,7 @@ interface AppState {
 
   toggleDarkMode: () => void;
   setSqlFormatOptions: (options: { keywordCase: 'upper' | 'lower' }) => void;
+  setQueryOptions: (options: Partial<{ maxRows: number }>) => void;
   
   addSqlLog: (log: SqlLog) => void;
   clearSqlLogs: () => void;
@@ -56,6 +58,7 @@ export const useStore = create<AppState>()(
       savedQueries: [],
       darkMode: false,
       sqlFormatOptions: { keywordCase: 'upper' },
+      queryOptions: { maxRows: 5000 },
       sqlLogs: [],
 
       addConnection: (conn) => set((state) => ({ connections: [...state.connections, conn] })),
@@ -124,13 +127,14 @@ export const useStore = create<AppState>()(
 
       toggleDarkMode: () => set((state) => ({ darkMode: !state.darkMode })),
       setSqlFormatOptions: (options) => set({ sqlFormatOptions: options }),
+      setQueryOptions: (options) => set((state) => ({ queryOptions: { ...state.queryOptions, ...options } })),
       
       addSqlLog: (log) => set((state) => ({ sqlLogs: [log, ...state.sqlLogs].slice(0, 1000) })), // Keep last 1000 logs
       clearSqlLogs: () => set({ sqlLogs: [] }),
     }),
     {
       name: 'lite-db-storage', // name of the item in the storage (must be unique)
-      partialize: (state) => ({ connections: state.connections, savedQueries: state.savedQueries, darkMode: state.darkMode, sqlFormatOptions: state.sqlFormatOptions }), // Don't persist logs
+      partialize: (state) => ({ connections: state.connections, savedQueries: state.savedQueries, darkMode: state.darkMode, sqlFormatOptions: state.sqlFormatOptions, queryOptions: state.queryOptions }), // Don't persist logs
     }
   )
 );

internal/app/methods_db.go

@@ -1,11 +1,14 @@
 package app
 
 import (
+	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	"GoNavi-Wails/internal/connection"
 	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/utils"
 )
 
 // Generic DB Methods
@@ -92,17 +95,38 @@ func (a *App) DBQuery(config connection.ConnectionConfig, dbName string, query s
 	}
 
 	query = sanitizeSQLForPgLike(runConfig.Type, query)
+	timeoutSeconds := runConfig.Timeout
+	if timeoutSeconds <= 0 {
+		timeoutSeconds = 30
+	}
+	ctx, cancel := utils.ContextWithTimeout(time.Duration(timeoutSeconds) * time.Second)
+	defer cancel()
 
 	lowerQuery := strings.TrimSpace(strings.ToLower(query))
 	if strings.HasPrefix(lowerQuery, "select") || strings.HasPrefix(lowerQuery, "show") || strings.HasPrefix(lowerQuery, "describe") || strings.HasPrefix(lowerQuery, "explain") {
-		data, columns, err := dbInst.Query(query)
+		var data []map[string]interface{}
+		var columns []string
+		if q, ok := dbInst.(interface {
+			QueryContext(context.Context, string) ([]map[string]interface{}, []string, error)
+		}); ok {
+			data, columns, err = q.QueryContext(ctx, query)
+		} else {
+			data, columns, err = dbInst.Query(query)
+		}
 		if err != nil {
 			logger.Error(err, "DBQuery 查询失败：%s SQL片段=%q", formatConnSummary(runConfig), sqlSnippet(query))
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
 		return connection.QueryResult{Success: true, Data: data, Fields: columns}
 	} else {
-		affected, err := dbInst.Exec(query)
+		var affected int64
+		if e, ok := dbInst.(interface {
+			ExecContext(context.Context, string) (int64, error)
+		}); ok {
+			affected, err = e.ExecContext(ctx, query)
+		} else {
+			affected, err = dbInst.Exec(query)
+		}
 		if err != nil {
 			logger.Error(err, "DBQuery 执行失败：%s SQL片段=%q", formatConnSummary(runConfig), sqlSnippet(query))
 			return connection.QueryResult{Success: false, Message: err.Error()}

internal/db/custom_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"strings"
@@ -57,6 +58,20 @@ func (c *CustomDB) Ping() error {
 	return c.conn.PingContext(ctx)
 }
 
+func (c *CustomDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if c.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := c.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (c *CustomDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if c.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -96,6 +111,17 @@ func (c *CustomDB) Query(query string) ([]map[string]interface{}, []string, erro
 	return resultData, columns, nil
 }
 
+func (c *CustomDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if c.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := c.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (c *CustomDB) Exec(query string) (int64, error) {
 	if c.conn == nil {
 		return 0, fmt.Errorf("connection not open")

internal/db/dameng_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"net"
@@ -88,6 +89,20 @@ func (d *DamengDB) Ping() error {
 	return d.conn.PingContext(ctx)
 }
 
+func (d *DamengDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if d.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := d.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (d *DamengDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if d.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -127,6 +142,17 @@ func (d *DamengDB) Query(query string) ([]map[string]interface{}, []string, erro
 	return resultData, columns, nil
 }
 
+func (d *DamengDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if d.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := d.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (d *DamengDB) Exec(query string) (int64, error) {
 	if d.conn == nil {
 		return 0, fmt.Errorf("connection not open")

internal/db/kingbase_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"strings"
@@ -119,6 +120,20 @@ func (k *KingbaseDB) Ping() error {
 	return k.conn.PingContext(ctx)
 }
 
+func (k *KingbaseDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if k.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := k.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (k *KingbaseDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if k.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -158,6 +173,17 @@ func (k *KingbaseDB) Query(query string) ([]map[string]interface{}, []string, er
 	return resultData, columns, nil
 }
 
+func (k *KingbaseDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if k.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := k.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (k *KingbaseDB) Exec(query string) (int64, error) {
 	if k.conn == nil {
 		return 0, fmt.Errorf("connection not open")

internal/db/mysql_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"strings"
@@ -76,6 +77,20 @@ func (m *MySQLDB) Ping() error {
 	return m.conn.PingContext(ctx)
 }
 
+func (m *MySQLDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if m.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := m.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (m *MySQLDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if m.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -115,6 +130,17 @@ func (m *MySQLDB) Query(query string) ([]map[string]interface{}, []string, error
 	return resultData, columns, nil
 }
 
+func (m *MySQLDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if m.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := m.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (m *MySQLDB) Exec(query string) (int64, error) {
 	if m.conn == nil {
 		return 0, fmt.Errorf("connection not open")

internal/db/oracle_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"net"
@@ -94,6 +95,20 @@ func (o *OracleDB) Ping() error {
 	return o.conn.PingContext(ctx)
 }
 
+func (o *OracleDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if o.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := o.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (o *OracleDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if o.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -133,6 +148,17 @@ func (o *OracleDB) Query(query string) ([]map[string]interface{}, []string, erro
 	return resultData, columns, nil
 }
 
+func (o *OracleDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if o.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := o.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (o *OracleDB) Exec(query string) (int64, error) {
 	if o.conn == nil {
 		return 0, fmt.Errorf("connection not open")

internal/db/postgres_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"net"
@@ -77,6 +78,20 @@ func (p *PostgresDB) Ping() error {
 	return p.conn.PingContext(ctx)
 }
 
+func (p *PostgresDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if p.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := p.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (p *PostgresDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if p.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -116,6 +131,17 @@ func (p *PostgresDB) Query(query string) ([]map[string]interface{}, []string, er
 	return resultData, columns, nil
 }
 
+func (p *PostgresDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if p.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := p.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (p *PostgresDB) Exec(query string) (int64, error) {
 	if p.conn == nil {
 		return 0, fmt.Errorf("connection not open")

internal/db/scan_rows.go

@@ -0,0 +1,36 @@
+package db
+
+import "database/sql"
+
+func scanRows(rows *sql.Rows) ([]map[string]interface{}, []string, error) {
+	columns, err := rows.Columns()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultData := make([]map[string]interface{}, 0)
+
+	for rows.Next() {
+		values := make([]interface{}, len(columns))
+		valuePtrs := make([]interface{}, len(columns))
+		for i := range columns {
+			valuePtrs[i] = &values[i]
+		}
+
+		if err := rows.Scan(valuePtrs...); err != nil {
+			continue
+		}
+
+		entry := make(map[string]interface{}, len(columns))
+		for i, col := range columns {
+			entry[col] = normalizeQueryValue(values[i])
+		}
+		resultData = append(resultData, entry)
+	}
+
+	if err := rows.Err(); err != nil {
+		return resultData, columns, err
+	}
+	return resultData, columns, nil
+}
+

internal/db/sqlite_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"strings"
@@ -53,6 +54,20 @@ func (s *SQLiteDB) Ping() error {
 	return s.conn.PingContext(ctx)
 }
 
+func (s *SQLiteDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if s.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := s.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (s *SQLiteDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if s.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -92,6 +107,17 @@ func (s *SQLiteDB) Query(query string) ([]map[string]interface{}, []string, erro
 	return resultData, columns, nil
 }
 
+func (s *SQLiteDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if s.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := s.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
 func (s *SQLiteDB) Exec(query string) (int64, error) {
 	if s.conn == nil {
 		return 0, fmt.Errorf("connection not open")