feat(sqlserver): support manual transactions with SQL Server 2000 compatibility

Closes #7542
This commit is contained in:
Rendegou authored and GitHub committed 2026-10-06 01:32:53 +08:00
1 parent 220dfa2170
commit 1539b6233c
61 files changed
+4861 -113

No files matched your search

@@ -389,6 +389,10 @@ const showTxnActions = computed(() => {
});
const transactionTooltip = computed(() => {
if (hasOpenAutoCommitTransaction.value) return t("settings.keepExplicitTransactionInAutoCommitDescription");
if (props.activeConnection?.db_type === "sqlserver" && isManualTransactionMode.value) {
const status = props.activeTab.txnStatus;
return status ? t(`toolbar.sqlserverTxnStatus.${status}`) : t("toolbar.sqlserverIndependentTransaction");
}
const isAgent = (props.activeConnection?.db_type as string) === "agent";
const isManual = isManualTransactionMode.value;
if (isAgent && isManual) return t("toolbar.manualTransactionAgent");
@@ -876,7 +880,7 @@ async function changeCatalog(selectedCatalog: string) {
size="icon"
class="h-6 w-8 px-1"
:class="isManualTransactionMode ? 'bg-orange-100 text-orange-600 dark:bg-orange-900/30 dark:text-orange-300' : 'text-orange-600/70 hover:bg-orange-500/10 hover:text-orange-700 dark:text-orange-300/70 dark:hover:text-orange-200'"
:disabled="activeTab.isExecuting || activeTab.isExplaining"
:disabled="activeTab.isExecuting || activeTab.isExplaining || activeTab.txnStatus === 'opening' || activeTab.txnStatus === 'ending'"
:aria-label="transactionTooltip"
:aria-pressed="isManualTransactionMode || hasOpenAutoCommitTransaction"
@click="emit('update:autoCommit', autoCommit === false)"
@@ -895,7 +899,14 @@ async function changeCatalog(selectedCatalog: string) {
<!-- Commit button (only when a transaction action is warranted) -->
<Tooltip v-if="showTxnActions">
<TooltipTrigger as-child>
<Button variant="ghost" size="icon" class="h-6 w-6 text-green-600 hover:bg-green-500/10 hover:text-green-700 dark:text-green-300 dark:hover:text-green-200" :disabled="activeTab.isExecuting" :aria-label="t('toolbar.commit')" @click="emit('commit')">
<Button
variant="ghost"
size="icon"
class="h-6 w-6 text-green-600 hover:bg-green-500/10 hover:text-green-700 dark:text-green-300 dark:hover:text-green-200"
:disabled="activeTab.isExecuting || activeTab.txnStatus === 'ending' || activeTab.txnStatus === 'opening'"
:aria-label="t('toolbar.commit')"
@click="emit('commit')"
>
<Check class="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
@@ -905,7 +916,14 @@ async function changeCatalog(selectedCatalog: string) {
<!-- Rollback button (only when a transaction action is warranted) -->
<Tooltip v-if="showTxnActions">
<TooltipTrigger as-child>
<Button variant="ghost" size="icon" class="h-6 w-6 text-red-600 hover:bg-red-500/10 hover:text-red-700 dark:text-red-300 dark:hover:text-red-200" :disabled="activeTab.isExecuting" :aria-label="t('toolbar.rollback')" @click="emit('rollback')">
<Button
variant="ghost"
size="icon"
class="h-6 w-6 text-red-600 hover:bg-red-500/10 hover:text-red-700 dark:text-red-300 dark:hover:text-red-200"
:disabled="activeTab.isExecuting || activeTab.txnStatus === 'ending' || activeTab.txnStatus === 'opening'"
:aria-label="t('toolbar.rollback')"
@click="emit('rollback')"
>
<RotateCcw class="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
@@ -1089,6 +1107,10 @@ async function changeCatalog(selectedCatalog: string) {
<X class="h-3 w-3" />
</Button>
</div>
<div v-if="activeTab.txnNotice" data-sqlserver-transaction-notice class="flex items-center gap-2 px-3 py-1 text-xs bg-amber-500/10 text-amber-700 dark:text-amber-300 border-b border-amber-500/20">
<span>{{ activeTab.txnNotice }}</span>
<Button variant="ghost" size="icon" class="ml-auto h-5 w-5 shrink-0" :aria-label="t('common.close')" @click="activeTab.txnNotice = undefined"><X class="h-3 w-3" /></Button>
</div>
<div v-if="txnAutoRolledBack" class="flex items-center gap-2 px-3 py-1 text-xs bg-amber-500/10 text-amber-700 dark:text-amber-300 border-b border-amber-500/20">
<AlertTriangle class="h-3.5 w-3.5 shrink-0" />
<span>{{ t("toolbar.txnAutoRolledBack") }}</span>
@@ -85,7 +85,7 @@ describe("EditorToolbar commit/rollback visibility", () => {
});
});
async function mountToolbar(props: { dbType: string; stickyProvenReadOnlyState: boolean; txnPossiblyDirty?: boolean; txnSessionId?: string }) {
async function mountToolbar(props: { dbType: string; stickyProvenReadOnlyState: boolean; txnPossiblyDirty?: boolean; txnSessionId?: string; txnStatus?: string; isExecuting?: boolean }) {
const connectionStore = useConnectionStore();
connectionStore.connections = [
{
@@ -105,7 +105,8 @@ describe("EditorToolbar commit/rollback visibility", () => {
database: "db",
sql: "SELECT 1",
mode: "query",
isExecuting: false,
isExecuting: props.isExecuting ?? false,
txnStatus: props.txnStatus,
isCancelling: false,
isExplaining: false,
},
@@ -162,4 +163,17 @@ describe("EditorToolbar commit/rollback visibility", () => {
expect(host.querySelector(rollbackSelector)).not.toBeNull();
host.remove();
});
it.each(["opening", "ending"])("SQL Server disables transaction actions while %s", async (txnStatus) => {
const host = await mountToolbar({ dbType: "sqlserver", stickyProvenReadOnlyState: false, txnSessionId: "sqlserver-txn-1", txnStatus });
expect(host.querySelector<HTMLButtonElement>(commitSelector)?.disabled).toBe(true);
expect(host.querySelector<HTMLButtonElement>(rollbackSelector)?.disabled).toBe(true);
host.remove();
});
it("SQL Server exposes Commit/Rollback for its dedicated active transaction", async () => {
const host = await mountToolbar({ dbType: "sqlserver", stickyProvenReadOnlyState: false, txnSessionId: "sqlserver-txn-1", txnStatus: "active" });
expect(host.querySelector<HTMLButtonElement>(commitSelector)?.disabled).toBe(false);
expect(host.querySelector<HTMLButtonElement>(rollbackSelector)?.disabled).toBe(false);
host.remove();
});
});
+14
View File
@@ -438,6 +438,10 @@ export default {
insertValueHintsToggleOn: "INSERT column hints: On (click to disable)",
insertValueHintsToggleOff: "INSERT column hints: Off (click to enable)",
autoCommit: "Auto Commit",
sqlserverIndependentTransaction: "Manual transactions use a separate connection. Temporary tables and SET options from auto-commit mode are not inherited.",
txnRollbackConfirmed: "Rollback confirmed.",
txnCommitConfirmed: "Commit confirmed.",
sqlserverTxnStatus: { opening: "Opening manual transaction", active: "Manual transaction active", executing: "Executing in manual transaction", ending: "Ending manual transaction", lost: "Transaction session lost", unknown: "Transaction outcome unknown" },
manualTransaction: "Manual Transaction",
autoCommitAgent: "Auto Commit (depends on Agent backend)",
manualTransactionAgent: "Manual Transaction (depends on Agent backend)",
@@ -2980,6 +2984,16 @@ export default {
legacyFailure: "Database agent returned an unclassified error.",
},
transaction: {
unsupported: "The selected SQL Server driver does not support manual transactions.",
busy: "The transaction is busy. Wait for the current operation to finish.",
contextChanged: "The transaction context changed and this session cannot continue.",
connectionLost: "The transaction connection was lost. This SQL was not replayed; start a new transaction to continue.",
rollbackFailed: "The transaction ended, but rollback could not be confirmed. Verify the database before running the SQL again.",
commitUnknown: "The COMMIT response was lost. The transaction may already be committed. Verify the database before running the SQL again.",
controlConflict: "Manual mode manages transaction control and the database context. Remove BEGIN/COMMIT/ROLLBACK/SAVE, SET IMPLICIT_TRANSACTIONS or USE from the script.",
idleTimeout: "The transaction ended after five minutes of inactivity. Start a new transaction to continue.",
executionFailed: "SQL execution failed and this manual transaction ended.",
sessionExpired: "The manual transaction expired after {timeoutSecs} seconds of inactivity and was rolled back. A new transaction will be started automatically.",
},
legacy: "Backend returned an error.",
+13
View File
@@ -431,6 +431,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "Sugerencias de columnas INSERT: activadas (clic para desactivar)",
insertValueHintsToggleOff: "Sugerencias de columnas INSERT: desactivadas (clic para activar)",
autoCommit: "Auto Commit",
sqlserverIndependentTransaction: "Las transacciones manuales usan una conexión independiente. No heredan las tablas temporales ni las opciones SET del modo de confirmación automática.",
txnRollbackConfirmed: "Reversión confirmada.",
txnCommitConfirmed: "Confirmación de la transacción recibida.",
sqlserverTxnStatus: { opening: "Abriendo transacción manual", active: "Transacción manual activa", executing: "Ejecutando en transacción manual", ending: "Finalizando transacción manual", lost: "Sesión de transacción perdida", unknown: "Resultado de transacción desconocido" },
manualTransaction: "Transacción Manual",
autoCommitAgent: "Auto Commit (depende del backend del Agente)",
manualTransactionAgent: "Transacción Manual (depende del backend del Agente)",
@@ -2926,6 +2930,15 @@ export default withEnglishFallback({
legacyFailure: "El agente de la base de datos devolvió un error no clasificado.",
},
transaction: {
unsupported: "El controlador de SQL Server seleccionado no admite transacciones manuales.",
busy: "La transacción está ocupada. Espere a que termine la operación actual.",
contextChanged: "El contexto de la transacción cambió y esta sesión no puede continuar.",
connectionLost: "Se perdió la conexión de la transacción. Este SQL no se volvió a ejecutar; inicie una nueva transacción para continuar.",
rollbackFailed: "La transacción terminó, pero no se pudo confirmar la reversión. Verifique la base de datos antes de volver a ejecutar el SQL.",
commitUnknown: "Se perdió la respuesta de COMMIT. La transacción puede haberse confirmado. Verifique la base de datos antes de volver a ejecutar el SQL.",
controlConflict: "El modo manual administra las transacciones y el contexto de la base de datos. Quite BEGIN/COMMIT/ROLLBACK/SAVE, SET IMPLICIT_TRANSACTIONS o USE del script.",
idleTimeout: "La transacción terminó tras cinco minutos de inactividad. Inicie una nueva transacción para continuar.",
executionFailed: "La ejecución del SQL falló y esta transacción manual terminó.",
sessionExpired: "La transacción manual expiró después de {timeoutSecs} segundos de inactividad y se revirtió. Se iniciará una nueva transacción automáticamente.",
},
legacy: "El backend devolvió un error.",
+13
View File
@@ -425,6 +425,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "Suggerimenti colonne INSERT: attivi (clic per disattivare)",
insertValueHintsToggleOff: "Suggerimenti colonne INSERT: disattivi (clic per attivare)",
autoCommit: "Auto Commit",
sqlserverIndependentTransaction: "Le transazioni manuali usano una connessione separata. Non ereditano le tabelle temporanee e le opzioni SET della modalità di commit automatico.",
txnRollbackConfirmed: "Rollback confermato.",
txnCommitConfirmed: "Commit confermato.",
sqlserverTxnStatus: { opening: "Apertura della transazione manuale", active: "Transazione manuale attiva", executing: "Esecuzione nella transazione manuale", ending: "Chiusura della transazione manuale", lost: "Sessione della transazione persa", unknown: "Esito della transazione sconosciuto" },
manualTransaction: "Transazione Manuale",
autoCommitAgent: "Auto Commit (dipende dal backend dell'Agente)",
manualTransactionAgent: "Transazione Manuale (dipende dal backend dell'Agente)",
@@ -2781,6 +2785,15 @@ export default withEnglishFallback({
legacyFailure: "L'agente del database ha restituito un errore non classificato.",
},
transaction: {
unsupported: "Il driver SQL Server selezionato non supporta le transazioni manuali.",
busy: "La transazione è occupata. Attendere il completamento dell'operazione corrente.",
contextChanged: "Il contesto della transazione è cambiato e questa sessione non può continuare.",
connectionLost: "La connessione della transazione è stata persa. Questo SQL non è stato rieseguito; avviare una nuova transazione per continuare.",
rollbackFailed: "La transazione è terminata, ma il rollback non è stato confermato. Verificare il database prima di rieseguire il SQL.",
commitUnknown: "La risposta a COMMIT è stata persa. La transazione potrebbe essere già stata confermata. Verificare il database prima di rieseguire il SQL.",
controlConflict: "La modalità manuale gestisce le transazioni e il contesto del database. Rimuovere BEGIN/COMMIT/ROLLBACK/SAVE, SET IMPLICIT_TRANSACTIONS o USE dallo script.",
idleTimeout: "La transazione è terminata dopo cinque minuti di inattività. Avviare una nuova transazione per continuare.",
executionFailed: "L'esecuzione del SQL è fallita e questa transazione manuale è terminata.",
sessionExpired: "La transazione manuale è scaduta dopo {timeoutSecs} secondi di inattività ed è stata annullata. Verrà avviata automaticamente una nuova transazione.",
},
legacy: "Il backend ha restituito un errore.",
+13
View File
@@ -426,6 +426,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "INSERT 列名ヒント:オン(クリックでオフ)",
insertValueHintsToggleOff: "INSERT 列名ヒント:オフ(クリックでオン)",
autoCommit: "自動コミット",
sqlserverIndependentTransaction: "手動トランザクションは専用の接続を使用します。自動コミットモードの一時テーブルや SET オプションは引き継がれません。",
txnRollbackConfirmed: "ロールバックを確認しました。",
txnCommitConfirmed: "コミットを確認しました。",
sqlserverTxnStatus: { opening: "手動トランザクションを開始中", active: "手動トランザクションが有効", executing: "手動トランザクションで実行中", ending: "手動トランザクションを終了中", lost: "トランザクションセッションが失われました", unknown: "トランザクションの結果が不明です" },
manualTransaction: "手動トランザクション",
autoCommitAgent: "自動コミット(Agentバックエンドに依存)",
manualTransactionAgent: "手動トランザクション(Agentバックエンドに依存)",
@@ -2807,6 +2811,15 @@ export default withEnglishFallback({
legacyFailure: "データベース Agent が分類できないエラーを返しました。",
},
transaction: {
unsupported: "選択した SQL Server ドライバーは手動トランザクションに対応していません。",
busy: "トランザクションは処理中です。現在の操作が完了するまでお待ちください。",
contextChanged: "トランザクションのコンテキストが変更されたため、このセッションは継続できません。",
connectionLost: "トランザクションの接続が失われました。この SQL は再実行されていません。続行するには新しいトランザクションを開始してください。",
rollbackFailed: "トランザクションは終了しましたが、ロールバックは確認できませんでした。SQL を再実行する前にデータベースを確認してください。",
commitUnknown: "COMMIT の応答が失われました。トランザクションは既にコミットされている可能性があります。SQL を再実行する前にデータベースを確認してください。",
controlConflict: "手動モードがトランザクション制御とデータベースのコンテキストを管理します。スクリプトから BEGIN/COMMIT/ROLLBACK/SAVE、SET IMPLICIT_TRANSACTIONS、USE を削除してください。",
idleTimeout: "5 分間操作がなかったためトランザクションが終了しました。続行するには新しいトランザクションを開始してください。",
executionFailed: "SQL の実行に失敗し、この手動トランザクションは終了しました。",
sessionExpired: "手動トランザクションは {timeoutSecs} 秒間操作がなかったため期限切れとなり、ロールバックされました。新しいトランザクションを自動的に開始します。",
},
legacy: "バックエンドがエラーを返しました。",
+13
View File
@@ -434,6 +434,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "INSERT 열 이름 힌트: 켜짐 (클릭하여 끄기)",
insertValueHintsToggleOff: "INSERT 열 이름 힌트: 꺼짐 (클릭하여 켜기)",
autoCommit: "자동 커밋",
sqlserverIndependentTransaction: "수동 트랜잭션은 별도의 연결을 사용합니다. 자동 커밋 모드의 임시 테이블과 SET 옵션은 상속되지 않습니다.",
txnRollbackConfirmed: "롤백이 확인되었습니다.",
txnCommitConfirmed: "커밋이 확인되었습니다.",
sqlserverTxnStatus: { opening: "수동 트랜잭션 시작 중", active: "수동 트랜잭션 활성", executing: "수동 트랜잭션에서 실행 중", ending: "수동 트랜잭션 종료 중", lost: "트랜잭션 세션이 손실되었습니다", unknown: "트랜잭션 결과를 알 수 없습니다" },
manualTransaction: "수동 트랜잭션",
autoCommitAgent: "자동 커밋 (Agent 백엔드에 따라)",
manualTransactionAgent: "수동 트랜잭션 (Agent 백엔드에 따라)",
@@ -2697,6 +2701,15 @@ export default withEnglishFallback({
legacyFailure: "데이터베이스 Agent가 분류되지 않은 오류를 반환했습니다.",
},
transaction: {
unsupported: "선택한 SQL Server 드라이버는 수동 트랜잭션을 지원하지 않습니다.",
busy: "트랜잭션이 사용 중입니다. 현재 작업이 완료될 때까지 기다리세요.",
contextChanged: "트랜잭션 컨텍스트가 변경되어 이 세션을 계속할 수 없습니다.",
connectionLost: "트랜잭션 연결이 손실되었습니다. 이 SQL은 다시 실행되지 않았습니다. 계속하려면 새 트랜잭션을 시작하세요.",
rollbackFailed: "트랜잭션은 종료되었지만 롤백을 확인할 수 없습니다. SQL을 다시 실행하기 전에 데이터베이스를 확인하세요.",
commitUnknown: "COMMIT 응답이 손실되었습니다. 트랜잭션이 이미 커밋되었을 수 있습니다. SQL을 다시 실행하기 전에 데이터베이스를 확인하세요.",
controlConflict: "수동 모드에서 트랜잭션 제어와 데이터베이스 컨텍스트를 관리합니다. 스크립트에서 BEGIN/COMMIT/ROLLBACK/SAVE, SET IMPLICIT_TRANSACTIONS 또는 USE를 제거하세요.",
idleTimeout: "5분간 활동이 없어 트랜잭션이 종료되었습니다. 계속하려면 새 트랜잭션을 시작하세요.",
executionFailed: "SQL 실행이 실패하여 이 수동 트랜잭션이 종료되었습니다.",
sessionExpired: "수동 트랜잭션이 {timeoutSecs}초 동안 활동이 없어 만료되고 롤백되었습니다. 새 트랜잭션을 자동으로 시작합니다.",
},
legacy: "백엔드에서 오류를 반환했습니다.",
+13
View File
@@ -426,6 +426,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "Dicas de colunas INSERT: ativadas (clique para desativar)",
insertValueHintsToggleOff: "Dicas de colunas INSERT: desativadas (clique para ativar)",
autoCommit: "Auto Commit",
sqlserverIndependentTransaction: "As transações manuais usam uma conexão separada. As tabelas temporárias e as opções SET do modo de confirmação automática não são herdadas.",
txnRollbackConfirmed: "Reversão confirmada.",
txnCommitConfirmed: "Confirmação da transação recebida.",
sqlserverTxnStatus: { opening: "Abrindo transação manual", active: "Transação manual ativa", executing: "Executando na transação manual", ending: "Encerrando transação manual", lost: "Sessão da transação perdida", unknown: "Resultado da transação desconhecido" },
manualTransaction: "Transação Manual",
autoCommitAgent: "Auto Commit (depende do backend do Agente)",
manualTransactionAgent: "Transação Manual (depende do backend do Agente)",
@@ -2783,6 +2787,15 @@ export default withEnglishFallback({
legacyFailure: "O Agent do banco retornou um erro não classificado.",
},
transaction: {
unsupported: "O driver do SQL Server selecionado não oferece suporte a transações manuais.",
busy: "A transação está ocupada. Aguarde a conclusão da operação atual.",
contextChanged: "O contexto da transação mudou e esta sessão não pode continuar.",
connectionLost: "A conexão da transação foi perdida. Este SQL não foi executado novamente; inicie uma nova transação para continuar.",
rollbackFailed: "A transação terminou, mas a reversão não pôde ser confirmada. Verifique o banco de dados antes de executar o SQL novamente.",
commitUnknown: "A resposta de COMMIT foi perdida. A transação pode já ter sido confirmada. Verifique o banco de dados antes de executar o SQL novamente.",
controlConflict: "O modo manual gerencia as transações e o contexto do banco de dados. Remova BEGIN/COMMIT/ROLLBACK/SAVE, SET IMPLICIT_TRANSACTIONS ou USE do script.",
idleTimeout: "A transação terminou após cinco minutos de inatividade. Inicie uma nova transação para continuar.",
executionFailed: "A execução do SQL falhou e esta transação manual terminou.",
sessionExpired: "A transação manual expirou após {timeoutSecs} segundos de inatividade e foi revertida. Uma nova transação será iniciada automaticamente.",
},
legacy: "O backend retornou um erro.",
+13
View File
@@ -408,6 +408,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "Подсказки столбцов INSERT: вкл. (нажмите, чтобы отключить)",
insertValueHintsToggleOff: "Подсказки столбцов INSERT: выкл. (нажмите, чтобы включить)",
autoCommit: "Автофиксация",
sqlserverIndependentTransaction: "Ручные транзакции используют отдельное соединение. Временные таблицы и параметры SET из режима автоматической фиксации не наследуются.",
txnRollbackConfirmed: "Откат подтверждён.",
txnCommitConfirmed: "Фиксация подтверждена.",
sqlserverTxnStatus: { opening: "Открытие ручной транзакции", active: "Ручная транзакция активна", executing: "Выполнение в ручной транзакции", ending: "Завершение ручной транзакции", lost: "Сеанс транзакции потерян", unknown: "Результат транзакции неизвестен" },
manualTransaction: "Ручная транзакция",
autoCommitAgent: "Автофиксация (зависит от бэкенда агента)",
manualTransactionAgent: "Ручная транзакция (зависит от бэкенда агента)",
@@ -2848,6 +2852,15 @@ export default withEnglishFallback({
legacyFailure: "Агент базы данных вернул неклассифицированную ошибку.",
},
transaction: {
unsupported: "Выбранный драйвер SQL Server не поддерживает ручные транзакции.",
busy: "Транзакция занята. Дождитесь завершения текущей операции.",
contextChanged: "Контекст транзакции изменился; этот сеанс не может продолжаться.",
connectionLost: "Соединение транзакции потеряно. Этот SQL не выполнялся повторно; начните новую транзакцию, чтобы продолжить.",
rollbackFailed: "Транзакция завершена, но откат не подтверждён. Проверьте базу данных перед повторным выполнением SQL.",
commitUnknown: "Ответ на COMMIT потерян. Возможно, транзакция уже зафиксирована. Проверьте базу данных перед повторным выполнением SQL.",
controlConflict: "Ручной режим управляет транзакциями и контекстом базы данных. Удалите из скрипта BEGIN/COMMIT/ROLLBACK/SAVE, SET IMPLICIT_TRANSACTIONS или USE.",
idleTimeout: "Транзакция завершена после пяти минут бездействия. Начните новую транзакцию, чтобы продолжить.",
executionFailed: "Выполнение SQL завершилось ошибкой; эта ручная транзакция завершена.",
sessionExpired: "Ручная транзакция истекла после {timeoutSecs} секунд бездействия и была отменена. Новая транзакция будет запущена автоматически.",
},
legacy: "Бэкенд вернул ошибку.",
+14
View File
@@ -375,6 +375,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "INSERT 列名提示:已开启(点击关闭)",
insertValueHintsToggleOff: "INSERT 列名提示:已关闭(点击开启)",
autoCommit: "自动提交",
sqlserverIndependentTransaction: "手动事务使用独立连接,不继承自动提交连接上的临时表和 SET 设置。",
txnRollbackConfirmed: "已确认回滚。",
txnCommitConfirmed: "已确认提交。",
sqlserverTxnStatus: { opening: "正在开启手动事务", active: "手动事务活动中", executing: "正在事务内执行", ending: "正在结束手动事务", lost: "事务会话已失效", unknown: "事务结果未知" },
manualTransaction: "手动事务",
autoCommitAgent: "自动提交(取决于 Agent 后端数据库)",
manualTransactionAgent: "手动事务(取决于 Agent 后端数据库)",
@@ -2914,6 +2918,16 @@ export default withEnglishFallback({
legacyFailure: "数据库 Agent 返回了未分类错误。",
},
transaction: {
unsupported: "当前 SQL Server 驱动不支持手动事务。",
busy: "事务正在处理请求,请等待当前操作结束。",
contextChanged: "事务上下文已改变,此会话无法继续。",
connectionLost: "事务连接已丢失,本次 SQL 未自动重跑;请重新执行以开启新事务。",
rollbackFailed: "事务会话已结束,但无法确认回滚结果;再次执行 SQL 前请核对数据库。",
commitUnknown: "提交响应丢失,事务可能已经提交;再次执行 SQL 前请核对数据库。",
controlConflict: "手动模式统一管理事务与数据库上下文,请移除 SQL 中的 BEGIN/COMMIT/ROLLBACK/SAVE、SET IMPLICIT_TRANSACTIONS 或 USE。",
idleTimeout: "事务已因 5 分钟无操作而结束,请重新执行以开启新事务。",
executionFailed: "SQL 执行失败,本次手动事务已结束。",
sessionExpired: "手动事务因 {timeoutSecs} 秒无操作已过期并回滚,DBX 将自动开始新事务。",
},
legacy: "后端返回了错误。",
+14
View File
@@ -430,6 +430,10 @@ export default withEnglishFallback({
insertValueHintsToggleOn: "INSERT 欄位提示:已開啟(點擊關閉)",
insertValueHintsToggleOff: "INSERT 欄位提示:已關閉(點擊開啟)",
autoCommit: "自動提交",
sqlserverIndependentTransaction: "手動交易使用獨立連線,不繼承自動提交連線上的暫存資料表和 SET 設定。",
txnRollbackConfirmed: "已確認復原。",
txnCommitConfirmed: "已確認提交。",
sqlserverTxnStatus: { opening: "正在開啟手動交易", active: "手動交易進行中", executing: "正在交易內執行", ending: "正在結束手動交易", lost: "交易工作階段已失效", unknown: "交易結果未知" },
manualTransaction: "手動事務",
autoCommitAgent: "自動提交(取決於 Agent 後端資料庫)",
manualTransactionAgent: "手動事務(取決於 Agent 後端資料庫)",
@@ -2788,6 +2792,16 @@ export default withEnglishFallback({
legacyFailure: "資料庫 Agent 回傳了未分類錯誤。",
},
transaction: {
unsupported: "目前 SQL Server 驅動程式不支援手動交易。",
busy: "交易正在處理請求,請等待目前操作結束。",
contextChanged: "交易上下文已改變,此工作階段無法繼續。",
connectionLost: "交易連線已中斷,本次 SQL 未自動重跑;請重新執行以開啟新交易。",
rollbackFailed: "交易工作階段已結束,但無法確認復原結果;再次執行 SQL 前請核對資料庫。",
commitUnknown: "提交回應遺失,交易可能已經提交;再次執行 SQL 前請核對資料庫。",
controlConflict: "手動模式統一管理交易與資料庫上下文,請移除 SQL 中的 BEGIN/COMMIT/ROLLBACK/SAVE、SET IMPLICIT_TRANSACTIONS 或 USE。",
idleTimeout: "交易已因 5 分鐘無操作而結束,請重新執行以開啟新交易。",
executionFailed: "SQL 執行失敗,本次手動交易已結束。",
sessionExpired: "手動交易因 {timeoutSecs} 秒無操作而過期並回滾,DBX 將自動開始新的交易。",
},
legacy: "後端回傳了錯誤。",
@@ -181,7 +181,7 @@ describe("supportsTransaction", () => {
expect(supportsTransaction("cloudflare-d1")).toBe(false);
expect(supportsTransaction("sqlite")).toBe(false);
expect(supportsTransaction("clickhouse")).toBe(false);
expect(supportsTransaction("sqlserver")).toBe(false);
expect(supportsTransaction("sqlserver")).toBe(true);
expect(supportsTransaction("rqlite")).toBe(false);
expect(supportsTransaction("agent")).toBe(false);
});
@@ -204,6 +204,8 @@ describe("defaultAutoCommitForDbType", () => {
it("honors the configured default transaction mode", () => {
expect(defaultAutoCommitForDbType("mysql", "manual")).toBe(false);
expect(defaultAutoCommitForDbType("postgres", "manual")).toBe(false);
expect(defaultAutoCommitForDbType("sqlserver", "manual")).toBe(false);
expect(defaultAutoCommitForDbType("sqlserver", "auto")).toBe(true);
expect(defaultAutoCommitForDbType("oracle", "manual")).toBe(false);
expect(defaultAutoCommitForDbType("jdbc", "manual")).toBe(false);
expect(defaultAutoCommitForDbType("oceanbase-oracle", "manual")).toBe(false);
@@ -57,6 +57,12 @@ describe("HTTP backend error parsing", () => {
}
});
test.each(["committed", "rolled_back", "unknown"] as const)("preserves a confirmed transaction outcome (%s)", async (outcome) => {
const transaction = { ...envelope, code: "DBX-TXN-1007", transactionOutcome: outcome };
const error = await backendResponseError(new Response(JSON.stringify(transaction), { status: 500 }));
expect(error.backendError.transactionOutcome).toBe(outcome);
});
test("uses a stable summary for an empty body", async () => {
const error = await backendResponseError(new Response("", { status: 503 }));
expect(error.backendError.code).toBe("DBX-LEGACY-0001");
+1
View File
@@ -277,6 +277,7 @@ export const executeInManualTransaction = forward("executeInManualTransaction");
export const commitManualTransaction = forward("commitManualTransaction");
export const rollbackManualTransaction = forward("rollbackManualTransaction");
export const cancelQuery = forward("cancelQuery");
export const cancelQueryAndWait = forward("cancelQueryAndWait");
export const cancelConditionalUpdate = forward("cancelConditionalUpdate");
export const closeQuerySession = forward("closeQuerySession");
export const closeClientConnectionSession = forward("closeClientConnectionSession");
@@ -25,6 +25,7 @@ export interface BackendError {
/** Compatibility provenance. New callers should prefer origin metadata. */
source: string;
operationOutcome: "not_started" | "unknown";
transactionOutcome?: "committed" | "rolled_back" | "unknown";
origin?: {
subsystem: string;
adapter: string;
@@ -161,6 +162,7 @@ function isBackendError(value: unknown): value is BackendError {
}
}
if (candidate.detail !== undefined && typeof candidate.detail !== "string") return false;
if (candidate.transactionOutcome !== undefined && !["committed", "rolled_back", "unknown"].includes(String(candidate.transactionOutcome))) return false;
// Optional driver-reported position. Malformed values are rejected so a
// corrupted envelope never drives a wrong editor jump, while a missing field
// stays valid (all non-PostgreSQL errors and older backends).
+17 -1
View File
@@ -1638,7 +1638,19 @@ export async function beginManualTransaction(_connectionId: string, _database: s
throw new Error("Manual transaction management is only available in the desktop app.");
}
export async function executeInManualTransaction(_txnSessionId: string, _sql: string, _database: string, _schema?: string, _maxRows?: number, _tableDataPreview?: boolean, _pageSize?: number, _resultSessionId?: string, _classificationSql?: string): Promise<QueryResult[]> {
export async function executeInManualTransaction(
_txnSessionId: string,
_sql: string,
_database: string,
_schema?: string,
_maxRows?: number,
_tableDataPreview?: boolean,
_pageSize?: number,
_resultSessionId?: string,
_classificationSql?: string,
_executionId?: string,
_timeoutSecs?: number,
): Promise<QueryResult[]> {
throw new Error("Manual transaction management is only available in the desktop app.");
}
@@ -1650,6 +1662,10 @@ export async function rollbackManualTransaction(_txnSessionId: string): Promise<
throw new Error("Manual transaction management is only available in the desktop app.");
}
export async function cancelQueryAndWait(_executionId: string): Promise<{ requested: boolean; terminal: boolean }> {
throw new Error("Manual transaction cancellation confirmation is only available in the desktop app.");
}
export async function cancelQuery(executionId: string): Promise<boolean> {
const result = await post<boolean | { cancelled?: boolean }>("/api/query/cancel", { executionId });
return typeof result === "boolean" ? result : result.cancelled === true;
+23 -5
View File
@@ -1961,6 +1961,10 @@ export async function refreshConnections(): Promise<void> {
return invoke("refresh_connections");
}
export async function cancelQueryAndWait(executionId: string): Promise<{ requested: boolean; terminal: boolean }> {
return invokeBackend("cancel_conditional_update", { executionId });
}
export async function cancelQuery(executionId: string): Promise<boolean> {
return invoke("cancel_query", { executionId });
}
@@ -2029,11 +2033,23 @@ export async function executeInTransaction(connectionId: string, database: strin
}
export async function beginManualTransaction(connectionId: string, database: string, schema?: string, catalog?: string): Promise<string> {
return invoke("begin_manual_transaction", { connectionId, database, schema, catalog });
return invokeBackend("begin_manual_transaction", { connectionId, database, schema, catalog });
}
export async function executeInManualTransaction(txnSessionId: string, sql: string, database: string, schema?: string, maxRows?: number, tableDataPreview?: boolean, pageSize?: number, resultSessionId?: string, classificationSql?: string): Promise<QueryResult[]> {
return invoke("execute_in_manual_transaction", {
export async function executeInManualTransaction(
txnSessionId: string,
sql: string,
database: string,
schema?: string,
maxRows?: number,
tableDataPreview?: boolean,
pageSize?: number,
resultSessionId?: string,
classificationSql?: string,
executionId?: string,
timeoutSecs?: number,
): Promise<QueryResult[]> {
return invokeBackend("execute_in_manual_transaction", {
txnSessionId,
sql,
database,
@@ -2043,15 +2059,17 @@ export async function executeInManualTransaction(txnSessionId: string, sql: stri
pageSize,
resultSessionId,
classificationSql,
executionId,
timeoutSecs,
});
}
export async function commitManualTransaction(txnSessionId: string): Promise<QueryResult> {
return invoke("commit_manual_transaction", { txnSessionId });
return invokeBackend("commit_manual_transaction", { txnSessionId });
}
export async function rollbackManualTransaction(txnSessionId: string): Promise<QueryResult> {
return invoke("rollback_manual_transaction", { txnSessionId });
return invokeBackend("rollback_manual_transaction", { txnSessionId });
}
export async function analyzeSqlReferences(sql: string, dialect?: string): Promise<SqlReferenceAnalysis> {
@@ -281,7 +281,7 @@ export function usesPostgresLikeStructureCopy(dbType?: DatabaseType): boolean {
return !!dbType && PG_LIKE_STRUCTURE_TYPES.has(dbType);
}
const TRANSACTION_SUPPORTED_TYPES: readonly string[] = ["postgres", "mysql", "oracle", "jdbc", "oceanbase-oracle", "dameng"];
const TRANSACTION_SUPPORTED_TYPES: readonly string[] = ["postgres", "mysql", "oracle", "jdbc", "oceanbase-oracle", "dameng", "sqlserver"];
/** Oracle-family databases, kept ONLY for the Oracle-specific ALTER SESSION SET
* CURRENT_SCHEMA compensation in queryStore. Do not use for toolbar/dirty-bit
@@ -4,6 +4,9 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
analyzeEditableQueryEditability: vi.fn(),
beginManualTransaction: vi.fn(),
commitManualTransaction: vi.fn(),
rollbackManualTransaction: vi.fn(),
cancelQueryAndWait: vi.fn(),
closeClientConnectionSession: vi.fn(),
closeQuerySession: vi.fn(),
executeInManualTransaction: vi.fn(),
@@ -16,6 +19,9 @@ const mocks = vi.hoisted(() => ({
vi.mock("@/lib/backend/api", () => ({
analyzeEditableQueryEditability: mocks.analyzeEditableQueryEditability,
beginManualTransaction: mocks.beginManualTransaction,
commitManualTransaction: mocks.commitManualTransaction,
rollbackManualTransaction: mocks.rollbackManualTransaction,
cancelQueryAndWait: mocks.cancelQueryAndWait,
closeClientConnectionSession: mocks.closeClientConnectionSession,
closeQuerySession: mocks.closeQuerySession,
executeInManualTransaction: mocks.executeInManualTransaction,
@@ -319,4 +325,142 @@ describe("queryStore manual transaction expiry recovery", () => {
expect(mocks.executeMulti).toHaveBeenCalledOnce();
expect(tab.result?.execution_error).toBe(true);
});
async function sqlServerTab() {
mocks.getConnectionConfig.mockReturnValue({ id: "sqlserver-1", name: "SQL Server", db_type: "sqlserver", database: "db", query_timeout_secs: 30 });
mocks.rollbackManualTransaction.mockResolvedValue({ columns: [], rows: [] });
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const id = store.createTab("sqlserver-1", "db", "SQL", "query", "dbo");
store.setAutoCommit(id, false);
return { store, id, tab: store.tabs.find((tab) => tab.id === id)! };
}
function transactionError(code: string, outcome: "unknown" | "rolled_back" | "committed" = "unknown") {
return { ...expiredTransactionError(), code, messageKey: code === "DBX-TXN-1007" ? "backendErrors.transaction.commitUnknown" : "backendErrors.transaction.connectionLost", transactionOutcome: outcome };
}
it("SQL Server retains one session across executions and forwards cancellation identity and timeout", async () => {
const { store, id, tab } = await sqlServerTab();
mocks.beginManualTransaction.mockResolvedValue("sqlserver-txn-fixed");
mocks.executeInManualTransaction.mockResolvedValue(successfulUpdate());
await store.executeTabSql(id, "UPDATE users SET active = 1");
await store.executeTabSql(id, "UPDATE users SET active = 2");
expect(mocks.beginManualTransaction).toHaveBeenCalledOnce();
expect(mocks.executeInManualTransaction).toHaveBeenCalledTimes(2);
for (const call of mocks.executeInManualTransaction.mock.calls) {
expect(call[0]).toBe("sqlserver-txn-fixed");
expect(call[9]).toEqual(expect.any(String));
expect(call[10]).toBe(30);
}
expect(tab.txnStatus).toBe("active");
expect(tab.autoCommit).toBe(false);
});
it.each([expiredTransactionError(), transactionError("DBX-TXN-1005"), transactionError("DBX-TXN-1009", "rolled_back")])("SQL Server never silently replays a failed execution (%s)", async (error) => {
const { store, id, tab } = await sqlServerTab();
mocks.beginManualTransaction.mockResolvedValueOnce("sqlserver-txn-old").mockResolvedValueOnce("sqlserver-txn-new");
mocks.executeInManualTransaction.mockRejectedValueOnce(error).mockResolvedValueOnce(successfulUpdate());
await store.executeTabSql(id, "UPDATE users SET active = 1");
expect(mocks.executeInManualTransaction).toHaveBeenCalledOnce();
expect(mocks.beginManualTransaction).toHaveBeenCalledOnce();
expect(mocks.executeMulti).not.toHaveBeenCalled();
expect(tab.txnSessionId).toBeUndefined();
expect(tab.autoCommit).toBe(false);
expect(tab.txnAutoRolledBack).toBe(false);
expect(tab.result?.execution_error).toBe(true);
await store.executeTabSql(id, "UPDATE users SET active = 2");
expect(mocks.beginManualTransaction).toHaveBeenCalledTimes(2);
expect(mocks.executeInManualTransaction).toHaveBeenCalledTimes(2);
expect(tab.txnSessionId).toBe("sqlserver-txn-new");
});
it("SQL Server refuses unsupported BEGIN even for a read without automatic execution", async () => {
const { store, id, tab } = await sqlServerTab();
mocks.beginManualTransaction.mockRejectedValueOnce(new Error("Unknown method: begin_manual_transaction"));
await store.executeTabSql(id, "SELECT 1");
expect(mocks.executeInManualTransaction).not.toHaveBeenCalled();
expect(mocks.executeMulti).not.toHaveBeenCalled();
expect(tab.autoCommit).toBe(false);
expect(tab.result?.execution_error).toBe(true);
});
it("SQL Server clears a lost commit session, reports unknown and never retries commit", async () => {
const { store, id, tab } = await sqlServerTab();
tab.txnSessionId = "sqlserver-txn-commit";
mocks.commitManualTransaction.mockRejectedValueOnce(transactionError("DBX-TXN-1007"));
await store.commitTransaction(id);
expect(mocks.commitManualTransaction).toHaveBeenCalledOnce();
expect(mocks.rollbackManualTransaction).not.toHaveBeenCalled();
expect(tab.txnStatus).toBe("unknown");
expect(tab.txnSessionId).toBeUndefined();
expect(tab.autoCommit).toBe(false);
});
it("SQL Server refuses switching to auto commit when rollback is unconfirmed", async () => {
const { store, id, tab } = await sqlServerTab();
tab.txnSessionId = "sqlserver-txn-rollback";
mocks.rollbackManualTransaction.mockRejectedValueOnce(transactionError("DBX-TXN-1006"));
store.setAutoCommit(id, true);
await vi.waitFor(() => expect(tab.txnStatus).toBe("lost"));
expect(tab.autoCommit).toBe(false);
expect(tab.txnSessionId).toBeUndefined();
expect(tab.txnAutoRolledBack).toBe(false);
});
it("SQL Server preserves the transaction handle on a busy rollback rejection", async () => {
const { store, id, tab } = await sqlServerTab();
tab.txnSessionId = "sqlserver-txn-busy";
mocks.rollbackManualTransaction.mockRejectedValueOnce(transactionError("DBX-TXN-1003"));
await store.rollbackTransaction(id);
expect(tab.txnSessionId).toBe("sqlserver-txn-busy");
expect(tab.txnStatus).toBe("active");
});
it("SQL Server keeps manual mode while cancellation is not terminal", async () => {
const { store, id, tab } = await sqlServerTab();
tab.txnSessionId = "sqlserver-txn-running";
tab.isExecuting = true;
tab.executionId = "running-id";
mocks.cancelQueryAndWait.mockResolvedValueOnce({ requested: true, terminal: false });
store.setAutoCommit(id, true);
await vi.waitFor(() => expect(mocks.cancelQueryAndWait).toHaveBeenCalledWith("running-id"));
await Promise.resolve();
expect(tab.autoCommit).toBe(false);
expect(tab.txnSessionId).toBe("sqlserver-txn-running");
expect(mocks.rollbackManualTransaction).not.toHaveBeenCalled();
});
it("SQL Server treats a lost desktop commit response as unknown even without a backend envelope", async () => {
const { store, id, tab } = await sqlServerTab();
tab.txnSessionId = "sqlserver-txn-transport";
mocks.commitManualTransaction.mockRejectedValueOnce(new Error("IPC response lost"));
await store.commitTransaction(id);
expect(tab.txnStatus).toBe("unknown");
expect(tab.txnSessionId).toBeUndefined();
expect(tab.txnNotice).toContain("COMMIT");
expect(mocks.commitManualTransaction).toHaveBeenCalledOnce();
expect(mocks.rollbackManualTransaction).not.toHaveBeenCalled();
});
it.each(["database", "close"])("SQL Server cleans a late BEGIN after a %s change without dispatching SQL", async (action) => {
const { store, id, tab } = await sqlServerTab();
let finishBegin!: (session: string) => void;
mocks.beginManualTransaction.mockReturnValueOnce(
new Promise<string>((resolve) => {
finishBegin = resolve;
}),
);
const execution = store.executeTabSql(id, "UPDATE users SET active = 1");
await vi.waitFor(() => expect(mocks.beginManualTransaction).toHaveBeenCalledOnce());
if (action === "database") store.updateDatabase(id, "other_database");
else store.closeTab(id, { force: true });
finishBegin("sqlserver-txn-late");
await execution;
expect(mocks.rollbackManualTransaction).toHaveBeenCalledOnce();
expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("sqlserver-txn-late");
expect(mocks.executeInManualTransaction).not.toHaveBeenCalled();
expect(mocks.executeMulti).not.toHaveBeenCalled();
expect(tab.txnSessionId).toBeUndefined();
});
});
+133 -9
View File
@@ -5202,11 +5202,32 @@ export const useQueryStore = defineStore("query", () => {
manualTransactionTargetEpochs.set(tab, manualTransactionTargetEpoch(tab) + 1);
}
const pendingSqlServerTransactionEnds = new Map<string, Promise<void>>();
function isSqlServerTransactionTab(tab: QueryTab): boolean {
return tab.txnSessionId?.startsWith("sqlserver-txn-") === true || useConnectionStore().getConfig(tab.connectionId)?.db_type === "sqlserver";
}
function reportSqlServerTransactionError(tab: QueryTab, error: unknown) {
const backend = normalizeBackendError(error);
const recoverable = backend?.code === "DBX-TXN-1003" || backend?.code === "DBX-TXN-1008";
if (!recoverable) clearManualTransactionSession(tab);
tab.txnStatus = recoverable ? (tab.txnSessionId ? "active" : undefined) : backend?.code === "DBX-TXN-1007" ? "unknown" : "lost";
tab.txnNotice = translateBackendError(i18n.global.t, error);
if (backend?.transactionOutcome === "rolled_back") tab.txnNotice += " " + i18n.global.t("toolbar.txnRollbackConfirmed");
if (backend?.transactionOutcome === "committed") tab.txnNotice += " " + i18n.global.t("toolbar.txnCommitConfirmed");
}
async function ensureManualTransactionSession(id: string, database: string, schema?: string, catalog?: string): Promise<string> {
const tab = tabs.value.find((item) => item.id === id);
if (!tab || tab.mode !== "query" || tab.autoCommit !== false || !tab.connectionId) {
throw new Error("Manual transaction mode is no longer active for this query tab");
}
const sqlserver = isSqlServerTransactionTab(tab);
if (sqlserver && pendingSqlServerTransactionEnds.has(id)) {
await pendingSqlServerTransactionEnds.get(id);
return ensureManualTransactionSession(id, database, schema, catalog);
}
if (tab.txnSessionId) return tab.txnSessionId;
const epoch = manualTransactionTargetEpoch(tab);
const pending = pendingManualTransactionStarts.get(id);
@@ -5216,6 +5237,13 @@ export const useQueryStore = defineStore("query", () => {
const originalDatabase = tab.database;
const originalCatalog = tab.catalog;
const originalSchema = tab.schema;
if (sqlserver) {
tab.txnStatus = "opening";
if (!tab.txnIndependentConnectionExplained) {
tab.txnNotice = i18n.global.t("toolbar.sqlserverIndependentTransaction");
tab.txnIndependentConnectionExplained = true;
}
}
const start = api
.beginManualTransaction(connectionId, database, schema, catalog)
.then(async (sessionId) => {
@@ -5224,8 +5252,13 @@ export const useQueryStore = defineStore("query", () => {
throw new Error("Query tab changed while the manual transaction was starting");
}
tab.txnSessionId = sessionId;
if (sqlserver) tab.txnStatus = "active";
return sessionId;
})
.catch((error) => {
if (sqlserver && tabs.value.find((item) => item.id === id) === tab && manualTransactionTargetEpoch(tab) === epoch) reportSqlServerTransactionError(tab, error);
throw error;
})
.finally(() => {
if (pendingManualTransactionStarts.get(id)?.promise === start) pendingManualTransactionStarts.delete(id);
});
@@ -5238,10 +5271,18 @@ export const useQueryStore = defineStore("query", () => {
if (tab) {
if (tab.autoCommit !== autoCommit) invalidateManualTransactionTarget(tab);
const wasManual = tab.autoCommit === false;
if (autoCommit && wasManual && isSqlServerTransactionTab(tab) && tab.txnSessionId) {
void rollbackTransaction(id).then(() => {
if (!tab.txnSessionId && tab.txnStatus !== "lost" && tab.txnStatus !== "unknown") tab.autoCommit = true;
});
return;
}
tab.autoCommit = autoCommit;
if (autoCommit && wasManual) {
if (tab.txnSessionId) {
void rollbackTransaction(id);
void rollbackTransaction(id).catch((error) => {
if (isSqlServerTransactionTab(tab)) reportSqlServerTransactionError(tab, error);
});
} else {
clearManualTransactionSession(tab);
}
@@ -5293,6 +5334,7 @@ export const useQueryStore = defineStore("query", () => {
* discarded. Callers must not assign these fields individually. */
function clearManualTransactionSession(tab: QueryTab) {
tab.txnSessionId = undefined;
tab.txnStatus = undefined;
tab.txnAutoRolledBack = false;
if (tab.txnPossiblyDirty !== undefined) tab.txnPossiblyDirty = false;
}
@@ -5323,6 +5365,35 @@ export const useQueryStore = defineStore("query", () => {
if (tab.autoCommitOpenTransaction) await executeCurrentSql("COMMIT", { tabId: tab.id });
return;
}
if (isSqlServerTransactionTab(tab)) {
if (tab.isExecuting || pendingSqlServerTransactionEnds.has(id)) return;
const sessionId = tab.txnSessionId;
const epoch = manualTransactionTargetEpoch(tab);
tab.txnStatus = "ending";
const ending = (async () => {
try {
await api.commitManualTransaction(sessionId);
if (tab.txnSessionId === sessionId) {
clearManualTransactionSession(tab);
if (manualTransactionTargetEpoch(tab) === epoch) tab.txnNotice = undefined;
}
} catch (error) {
if (tab.txnSessionId === sessionId) {
if (manualTransactionTargetEpoch(tab) === epoch) {
reportSqlServerTransactionError(tab, error);
if (!normalizeBackendError(error)) {
tab.txnStatus = "unknown";
tab.txnNotice = i18n.global.t("backendErrors.transaction.commitUnknown") + " " + formatError(error);
}
} else clearManualTransactionSession(tab);
}
} finally {
pendingSqlServerTransactionEnds.delete(id);
}
})();
pendingSqlServerTransactionEnds.set(id, ending);
return ending;
}
try {
await api.commitManualTransaction(tab.txnSessionId);
} finally {
@@ -5337,6 +5408,43 @@ export const useQueryStore = defineStore("query", () => {
if (tab.autoCommitOpenTransaction) await executeCurrentSql("ROLLBACK", { tabId: tab.id });
return;
}
if (isSqlServerTransactionTab(tab)) {
const pending = pendingSqlServerTransactionEnds.get(id);
if (pending) return pending;
const sessionId = tab.txnSessionId;
const epoch = manualTransactionTargetEpoch(tab);
tab.txnStatus = "ending";
const ending = (async () => {
try {
if (tab.isExecuting && tab.executionId) {
const cancellation = await api.cancelQueryAndWait(tab.executionId);
if (!cancellation.terminal) {
tab.txnStatus = "executing";
tab.txnNotice = i18n.global.t("backendErrors.transaction.busy");
return;
}
}
if (tab.txnSessionId !== sessionId) return;
await api.rollbackManualTransaction(sessionId);
if (tab.txnSessionId === sessionId) {
clearManualTransactionSession(tab);
if (manualTransactionTargetEpoch(tab) === epoch) tab.txnNotice = undefined;
}
} catch (error) {
if (tab.txnSessionId === sessionId) {
if (manualTransactionTargetEpoch(tab) === epoch) reportSqlServerTransactionError(tab, error);
else {
clearManualTransactionSession(tab);
tab.txnNotice = translateBackendError(i18n.global.t, error);
}
}
} finally {
pendingSqlServerTransactionEnds.delete(id);
}
})();
pendingSqlServerTransactionEnds.set(id, ending);
return ending;
}
const sessionId = tab.txnSessionId;
// Remove the old session before the backend responds: a target switch may
// start a new transaction while this rollback is still in flight.
@@ -7969,7 +8077,7 @@ export const useQueryStore = defineStore("query", () => {
queryExecutionLog("info", "begin-manual-txn:done", { traceId, txnSessionId: tab.txnSessionId, elapsed: elapsed() });
} catch (error) {
const risk = classifySqlRisk(sqlToExecute, { dialect: effectiveDbType }).risk;
if (!isUnsupportedManualTransactionMethod(error) || risk !== "read") throw error;
if (effectiveDbType === "sqlserver" || !isUnsupportedManualTransactionMethod(error) || risk !== "read") throw error;
tab.autoCommit = true;
clearManualTransactionSession(tab);
useLegacyReadFallback = true;
@@ -7999,14 +8107,28 @@ export const useQueryStore = defineStore("query", () => {
// single-shot call: the session-consume loop only runs in the
// auto-commit path, and opening a cursor session here would
// strand it after returning the first page.
const executeInTransaction = (sessionId: string) =>
useAgentResultSession && !isOffsetJumpPage
? api.executeInManualTransaction(sessionId, sqlToExecute, executionDatabase, executionSchema, agentProtocolQueryResultMaxRows(queryResultMaxRows), useLargeValuePreview, pageLimit, options?.pagination?.sessionId, classificationSql)
: api.executeInManualTransaction(sessionId, sqlToExecute, executionDatabase, executionSchema, pageLimit ?? agentProtocolQueryResultMaxRows(queryResultMaxRows), useLargeValuePreview, undefined, undefined, classificationSql);
const executeInTransaction = (sessionId: string) => {
const cursor = useAgentResultSession && !isOffsetJumpPage;
const args = [
sessionId,
sqlToExecute,
executionDatabase,
executionSchema,
cursor ? agentProtocolQueryResultMaxRows(queryResultMaxRows) : (pageLimit ?? agentProtocolQueryResultMaxRows(queryResultMaxRows)),
useLargeValuePreview,
cursor ? pageLimit : undefined,
cursor ? options?.pagination?.sessionId : undefined,
classificationSql,
] as const;
return effectiveDbType === "sqlserver" ? api.executeInManualTransaction(...args, executionId, frontendTimeoutSecs) : api.executeInManualTransaction(...args);
};
try {
return await executeInTransaction(txnSessionId);
if (effectiveDbType === "sqlserver") tab.txnStatus = "executing";
const results = await executeInTransaction(txnSessionId);
if (effectiveDbType === "sqlserver" && tab.txnSessionId === txnSessionId) tab.txnStatus = "active";
return results;
} catch (error) {
if (options?.pagination?.sessionId || manualTransactionRecoveryAttempted || !isManualTransactionSessionExpired(error)) throw error;
if (effectiveDbType === "sqlserver" || options?.pagination?.sessionId || manualTransactionRecoveryAttempted || !isManualTransactionSessionExpired(error)) throw error;
if (tab.executionId !== executionId || tab.autoCommit !== false || manualTransactionTargetEpoch(tab) !== executionTargetEpoch) throw error;
manualTransactionRecoveryAttempted = true;
// A session that only ever ran proven read-only statements lost
@@ -8303,7 +8425,9 @@ export const useQueryStore = defineStore("query", () => {
if (findExecutionTab(id) !== tab || tab.executionId !== executionId || manualTransactionTargetEpoch(tab) !== executionTargetEpoch) return false;
// Handle manual transaction auto-rollback (idle timeout only for the banner;
// other statement failures still clear the session without the 5-minute notice).
if (tab.autoCommit === false) {
if (tab.autoCommit === false && isSqlServerTransactionTab(tab)) {
reportSqlServerTransactionError(tab, e);
} else if (tab.autoCommit === false) {
const errMsg: string = e?.message ?? String(e);
const idleTimeout = /5 minutes of inactivity/i.test(errMsg) || errMsg.includes("5 分钟无操作") || errMsg.includes("已自动回滚");
if (idleTimeout) {
+4
View File
@@ -2342,6 +2342,10 @@ export interface QueryTab {
autoCommit?: boolean;
/** Session ID for an active manual transaction, set after beginManualTransaction */
txnSessionId?: string;
/** Runtime-only SQL Server transaction lifecycle and last terminal notice. */
txnStatus?: "opening" | "active" | "executing" | "ending" | "lost" | "unknown";
txnNotice?: string;
txnIndependentConnectionExplained?: boolean;
/** Set to true when a manual transaction was auto-rolled back due to inactivity */
txnAutoRolledBack?: boolean;
/** Sticky proven-read-only dialects (Oracle/OceanBase-Oracle/MySQL/PostgreSQL),