diff --git a/messages/ar.json b/messages/ar.json
index 62efe68..0ec21ee 100644
--- a/messages/ar.json
+++ b/messages/ar.json
@@ -235,6 +235,16 @@
 	"query_copy_cell": "نسخ قيمة الخلية",
 	"query_copy_row": "نسخ الصف كـ JSON",
 	"query_copy_column": "نسخ قيم العمود",
+	"query_statements_count": "{count} عبارات",
+	"query_error": "خطأ",
+	"query_statement_n": "العبارة {n}",
+	"query_result_rows_time": "({rows} صفوف، {time}مللي ثانية)",
+	"query_result_affected_time": "({affected} متأثرة، {time}مللي ثانية)",
+	"query_result_time": "({time}مللي ثانية)",
+	"query_result_error": "(خطأ)",
+	"query_statement_failed": "فشلت العبارة {n}",
+	"query_show_sql": "عرض SQL",
+	"query_no_executable_statements": "لم يتم العثور على عبارات قابلة للتنفيذ (تعليقات فقط)",
 	"history_title": "الاستعلامات",
 	"history_stats": "{executed} منفذة • {saved} محفوظة",
 	"history_search_placeholder": "البحث في الاستعلامات...",
diff --git a/messages/de.json b/messages/de.json
index 0398266..8da9dc4 100644
--- a/messages/de.json
+++ b/messages/de.json
@@ -235,6 +235,16 @@
 	"query_copy_cell": "Zellwert kopieren",
 	"query_copy_row": "Zeile als JSON kopieren",
 	"query_copy_column": "Spaltenwerte kopieren",
+	"query_statements_count": "{count} Anweisungen",
+	"query_error": "Fehler",
+	"query_statement_n": "Anweisung {n}",
+	"query_result_rows_time": "({rows} Zeilen, {time}ms)",
+	"query_result_affected_time": "({affected} betroffen, {time}ms)",
+	"query_result_time": "({time}ms)",
+	"query_result_error": "(Fehler)",
+	"query_statement_failed": "Anweisung {n} fehlgeschlagen",
+	"query_show_sql": "SQL anzeigen",
+	"query_no_executable_statements": "Keine ausführbaren Anweisungen gefunden (nur Kommentare)",
 	"history_title": "Abfragen",
 	"history_stats": "{executed} ausgeführt • {saved} gespeichert",
 	"history_search_placeholder": "Abfragen suchen...",
diff --git a/messages/en.json b/messages/en.json
index 42bf64d..fe0f324 100644
--- a/messages/en.json
+++ b/messages/en.json
@@ -235,6 +235,16 @@
 	"query_copy_cell": "Copy Cell Value",
 	"query_copy_row": "Copy Row as JSON",
 	"query_copy_column": "Copy Column Values",
+	"query_statements_count": "{count} statements",
+	"query_error": "Error",
+	"query_statement_n": "Statement {n}",
+	"query_result_rows_time": "({rows} rows, {time}ms)",
+	"query_result_affected_time": "({affected} affected, {time}ms)",
+	"query_result_time": "({time}ms)",
+	"query_result_error": "(error)",
+	"query_statement_failed": "Statement {n} failed",
+	"query_show_sql": "Show SQL",
+	"query_no_executable_statements": "No executable statements found (only comments)",
 	"history_title": "Queries",
 	"history_stats": "{executed} executed • {saved} saved",
 	"history_search_placeholder": "Search queries...",
diff --git a/messages/es.json b/messages/es.json
index 7c01bcb..7df06fa 100644
--- a/messages/es.json
+++ b/messages/es.json
@@ -235,6 +235,16 @@
 	"query_copy_cell": "Copiar valor de celda",
 	"query_copy_row": "Copiar fila como JSON",
 	"query_copy_column": "Copiar valores de columna",
+	"query_statements_count": "{count} sentencias",
+	"query_error": "Error",
+	"query_statement_n": "Sentencia {n}",
+	"query_result_rows_time": "({rows} filas, {time}ms)",
+	"query_result_affected_time": "({affected} afectadas, {time}ms)",
+	"query_result_time": "({time}ms)",
+	"query_result_error": "(error)",
+	"query_statement_failed": "Sentencia {n} falló",
+	"query_show_sql": "Mostrar SQL",
+	"query_no_executable_statements": "No se encontraron sentencias ejecutables (solo comentarios)",
 	"history_title": "Consultas",
 	"history_stats": "{executed} ejecutadas • {saved} guardadas",
 	"history_search_placeholder": "Buscar consultas...",
diff --git a/messages/fr.json b/messages/fr.json
index 7337230..18490e3 100644
--- a/messages/fr.json
+++ b/messages/fr.json
@@ -235,6 +235,16 @@
 	"query_copy_cell": "Copier la valeur de la cellule",
 	"query_copy_row": "Copier la ligne en JSON",
 	"query_copy_column": "Copier les valeurs de la colonne",
+	"query_statements_count": "{count} instructions",
+	"query_error": "Erreur",
+	"query_statement_n": "Instruction {n}",
+	"query_result_rows_time": "({rows} lignes, {time}ms)",
+	"query_result_affected_time": "({affected} affectées, {time}ms)",
+	"query_result_time": "({time}ms)",
+	"query_result_error": "(erreur)",
+	"query_statement_failed": "Instruction {n} échouée",
+	"query_show_sql": "Afficher SQL",
+	"query_no_executable_statements": "Aucune instruction exécutable trouvée (seulement des commentaires)",
 	"history_title": "Requêtes",
 	"history_stats": "{executed} exécutées • {saved} enregistrées",
 	"history_search_placeholder": "Rechercher des requêtes...",
diff --git a/messages/ko.json b/messages/ko.json
index 43d8240..3064389 100644
--- a/messages/ko.json
+++ b/messages/ko.json
@@ -235,6 +235,16 @@
 	"query_copy_cell": "셀 값 복사",
 	"query_copy_row": "행을 JSON으로 복사",
 	"query_copy_column": "열 값 복사",
+	"query_statements_count": "{count}개 문장",
+	"query_error": "오류",
+	"query_statement_n": "문장 {n}",
+	"query_result_rows_time": "({rows}행, {time}ms)",
+	"query_result_affected_time": "({affected}개 영향, {time}ms)",
+	"query_result_time": "({time}ms)",
+	"query_result_error": "(오류)",
+	"query_statement_failed": "문장 {n} 실패",
+	"query_show_sql": "SQL 보기",
+	"query_no_executable_statements": "실행 가능한 문장이 없습니다 (주석만 있음)",
 	"history_title": "쿼리",
 	"history_stats": "{executed}개 실행됨 • {saved}개 저장됨",
 	"history_search_placeholder": "쿼리 검색...",
diff --git a/src/lib/components/command-palette.svelte b/src/lib/components/command-palette.svelte
index 73f6557..e1fde09 100644
--- a/src/lib/components/command-palette.svelte
+++ b/src/lib/components/command-palette.svelte
@@ -33,7 +33,8 @@
 	const savedQueries = $derived(db.state.activeConnectionSavedQueries);
 	const recentHistory = $derived(db.state.activeConnectionQueryHistory?.slice(0, 10) || []);
 	const openTabs = $derived(db.tabs.ordered);
-	const hasResults = $derived((db.state.activeQueryTab?.results?.rows?.length ?? 0) > 0);
+	const activeResult = $derived(db.state.activeQueryResult);
+	const hasResults = $derived((activeResult?.rows?.length ?? 0) > 0);
 	const isConnected = $derived(!!db.state.activeConnectionId && !!db.state.activeConnection?.database);
 	const hasActiveQueryTab = $derived(isConnected && !!db.state.activeQueryTab);
 	const hasQueryContent = $derived(hasActiveQueryTab && !!db.state.activeQueryTab?.query?.trim());
@@ -166,19 +167,18 @@
 	}
 
 	function exportResults(format: "csv" | "json") {
-		const results = db.state.activeQueryTab?.results;
-		if (!results) return;
+		if (!activeResult) return;
 
 		let content: string;
 		let filename: string;
 		const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
 
 		if (format === "csv") {
-			const headers = results.columns.join(",");
-			const rows = results.rows
-				.map((row) =>
-					results.columns
-						.map((col) => {
+			const headers = activeResult.columns.join(",");
+			const rows = activeResult.rows
+				.map((row: Record<string, unknown>) =>
+					activeResult.columns
+						.map((col: string) => {
 							const val = row[col];
 							if (val === null || val === undefined) return "";
 							const str = String(val);
@@ -192,7 +192,7 @@
 			content = `${headers}\n${rows}`;
 			filename = `query-results-${timestamp}.csv`;
 		} else {
-			content = JSON.stringify(results.rows, null, 2);
+			content = JSON.stringify(activeResult.rows, null, 2);
 			filename = `query-results-${timestamp}.json`;
 		}
 
@@ -208,10 +208,9 @@
 	}
 
 	function copyResults() {
-		const results = db.state.activeQueryTab?.results;
-		if (!results) return;
+		if (!activeResult) return;
 
-		const content = JSON.stringify(results.rows, null, 2);
+		const content = JSON.stringify(activeResult.rows, null, 2);
 		navigator.clipboard.writeText(content);
 		open = false;
 	}
diff --git a/src/lib/components/monaco-editor.svelte b/src/lib/components/monaco-editor.svelte
index 61023d7..da15e8b 100644
--- a/src/lib/components/monaco-editor.svelte
+++ b/src/lib/components/monaco-editor.svelte
@@ -1,3 +1,9 @@
+<script lang="ts" module>
+	export interface MonacoEditorRef {
+		getCursorOffset: () => number;
+	}
+</script>
+
 <script lang="ts">
 	import { onMount, onDestroy } from "svelte";
 	import { mode } from "mode-watcher";
@@ -6,12 +12,14 @@
 
 	let {
 		value = $bindable(""),
+		ref = $bindable<MonacoEditorRef | null>(null),
 		schema = [] as SchemaTable[],
 		onExecute = () => {},
 		onChange = (_value: string) => {},
 		class: className = ""
 	}: {
 		value?: string;
+		ref?: MonacoEditorRef | null;
 		schema?: SchemaTable[];
 		onExecute?: () => void;
 		onChange?: (value: string) => void;
@@ -69,6 +77,16 @@
 		editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter, () => {
 			onExecute();
 		});
+
+		// Expose ref for external access
+		ref = {
+			getCursorOffset: () => {
+				if (!editor) return 0;
+				const position = editor.getPosition();
+				if (!position) return 0;
+				return editor.getModel()?.getOffsetAt(position) ?? 0;
+			}
+		};
 	});
 
 	onDestroy(() => {
diff --git a/src/lib/components/query-editor.svelte b/src/lib/components/query-editor.svelte
index 4c6001f..f8be5d7 100644
--- a/src/lib/components/query-editor.svelte
+++ b/src/lib/components/query-editor.svelte
@@ -6,11 +6,11 @@
 	import { Button, buttonVariants } from "$lib/components/ui/button";
 	import * as DropdownMenu from "$lib/components/ui/dropdown-menu/index.js";
 	import * as Dialog from "$lib/components/ui/dialog/index.js";
-	import { PlayIcon, SaveIcon, DownloadIcon, LoaderIcon, CopyIcon, ChevronDownIcon, WandSparklesIcon, ChevronLeftIcon, ChevronRightIcon, ChevronsLeftIcon, ChevronsRightIcon, PlusIcon, SearchIcon, ActivityIcon } from "@lucide/svelte";
+	import { PlayIcon, SaveIcon, DownloadIcon, LoaderIcon, CopyIcon, ChevronDownIcon, WandSparklesIcon, ChevronLeftIcon, ChevronRightIcon, ChevronsLeftIcon, ChevronsRightIcon, PlusIcon, SearchIcon, ActivityIcon, XCircleIcon, TableIcon, ZapIcon } from "@lucide/svelte";
 	import { Badge } from "$lib/components/ui/badge";
 	import { toast } from "svelte-sonner";
 	import SaveQueryDialog from "$lib/components/save-query-dialog.svelte";
-	import MonacoEditor from "$lib/components/monaco-editor.svelte";
+	import MonacoEditor, { type MonacoEditorRef } from "$lib/components/monaco-editor.svelte";
 	import * as Resizable from "$lib/components/ui/resizable";
 	import { save } from "@tauri-apps/plugin-dialog";
 	import { writeTextFile } from "@tauri-apps/plugin-fs";
@@ -22,6 +22,8 @@
 	import VirtualResultsTable from "$lib/components/virtual-results-table.svelte";
 	import { formatConfig, getExportContent, type ExportFormat } from "$lib/utils/export-formats.js";
 	import { m } from "$lib/paraglide/messages.js";
+	import { cn } from "$lib/utils.js";
+	import { splitSqlStatements } from "$lib/db/sql-parser.js";
 
 	const db = useDatabase();
 	const shortcuts = useShortcuts();
@@ -30,10 +32,32 @@
 	let deletingRowIndex = $state<number | null>(null);
 	let pendingDeleteRow = $state<{ index: number; row: Record<string, unknown> } | null>(null);
 	let showDeleteConfirm = $state(false);
+	let monacoRef = $state<MonacoEditorRef | null>(null);
+
+	// Get the active result (for multi-statement support)
+	const activeResult = $derived(db.state.activeQueryResult);
+	const activeResultIndex = $derived(db.state.activeQueryTab?.activeResultIndex ?? 0);
+	const allResults = $derived(db.state.activeQueryTab?.results ?? []);
+	const hasMultipleResults = $derived(allResults.length > 1);
+
+	// Track query content for live statement count
+	let currentQuery = $state(db.state.activeQueryTab?.query ?? '');
+
+	// Update currentQuery when active tab changes
+	$effect(() => {
+		currentQuery = db.state.activeQueryTab?.query ?? '';
+	});
+
+	// Live statement count from current query text
+	const liveStatementCount = $derived.by(() => {
+		if (!currentQuery?.trim()) return 0;
+		const dbType = db.state.activeConnection?.type ?? "postgres";
+		return splitSqlStatements(currentQuery, dbType).length;
+	});
 
 	// Get columns for the source table (for insert dialog)
 	const sourceTableColumns = $derived.by(() => {
-		const sourceTable = db.state.activeQueryTab?.results?.sourceTable;
+		const sourceTable = activeResult?.sourceTable;
 		if (!sourceTable || !db.state.activeConnectionId) return [];
 		const tables = db.state.schemas.get(db.state.activeConnectionId) || [];
 		const table = tables.find(t => t.name === sourceTable.name && t.schema === sourceTable.schema);
@@ -42,19 +66,21 @@
 
 	// Check if results are editable (have source table with primary keys)
 	const isEditable = $derived(
-		db.state.activeQueryTab?.results?.sourceTable &&
-		db.state.activeQueryTab?.results?.sourceTable.primaryKeys.length > 0
+		activeResult?.sourceTable &&
+		activeResult?.sourceTable.primaryKeys.length > 0 &&
+		!activeResult?.isError
 	);
 
 	async function handleCellSave(rowIndex: number, column: string, newValue: string) {
-		if (!db.state.activeQueryTabId || !db.state.activeQueryTab?.results?.sourceTable) return;
+		if (!db.state.activeQueryTabId || !activeResult?.sourceTable) return;
 
 		const result = await db.queries.updateCell(
 			db.state.activeQueryTabId,
+			activeResultIndex,
 			rowIndex,
 			column,
 			newValue,
-			db.state.activeQueryTab.results.sourceTable
+			activeResult.sourceTable
 		);
 
 		if (result.success) {
@@ -70,13 +96,13 @@
 	}
 
 	async function handleDeleteRow() {
-		if (!pendingDeleteRow || !db.state.activeQueryTabId || !db.state.activeQueryTab?.results?.sourceTable) return;
+		if (!pendingDeleteRow || !db.state.activeQueryTabId || !activeResult?.sourceTable) return;
 
 		deletingRowIndex = pendingDeleteRow.index;
 		showDeleteConfirm = false;
 
 		const result = await db.queries.deleteRow(
-			db.state.activeQueryTab.results.sourceTable,
+			activeResult.sourceTable,
 			pendingDeleteRow.row
 		);
 
@@ -100,7 +126,8 @@
 
 	const handleExplain = (analyze: boolean) => {
 		if (db.state.activeQueryTabId) {
-			db.explainTabs.execute(db.state.activeQueryTabId, analyze);
+			const cursorOffset = monacoRef?.getCursorOffset() ?? 0;
+			db.explainTabs.execute(db.state.activeQueryTabId, analyze, cursorOffset);
 		}
 	};
 
@@ -124,13 +151,12 @@
 	};
 
 	const getContent = (format: ExportFormat): string => {
-		const results = db.state.activeQueryTab?.results;
-		if (!results) return format === "json" ? "[]" : "";
-		return getExportContent(format, results.columns, results.rows);
+		if (!activeResult) return format === "json" ? "[]" : "";
+		return getExportContent(format, activeResult.columns, activeResult.rows);
 	};
 
 	const handleExport = async (format: ExportFormat) => {
-		if (!db.state.activeQueryTab?.results) return;
+		if (!activeResult) return;
 
 		const config = formatConfig[format];
 		const timestamp = new Date().toISOString().slice(0, 19).replace(/[:-]/g, "");
@@ -149,7 +175,7 @@
 	};
 
 	const handleCopy = async (format: ExportFormat) => {
-		if (!db.state.activeQueryTab?.results) return;
+		if (!activeResult) return;
 
 		const content = getContent(format);
 		const formatNames: Record<ExportFormat, string> = {
@@ -188,9 +214,9 @@
 	};
 
 	const copyColumn = async () => {
-		if (!contextCell || !db.state.activeQueryTab?.results) return;
+		if (!contextCell || !activeResult) return;
 		const col = contextCell.column;
-		const values = db.state.activeQueryTab.results.rows
+		const values = activeResult.rows
 			.map(row => row[col])
 			.map(v => v === null || v === undefined ? "" : String(v))
 			.join("\n");
@@ -217,30 +243,34 @@
             class="flex items-center justify-between p-2 border-b bg-muted/30 shrink-0"
         >
             <div class="flex items-center gap-3 text-xs text-muted-foreground">
-                {#if db.state.activeQueryTab.results}
+                <!-- Live statement count (always shown when > 1) -->
+                {#if liveStatementCount > 1}
                     <span class="flex items-center gap-1">
-                        {#if db.state.activeQueryTab.results.queryType && ['insert', 'update', 'delete'].includes(db.state.activeQueryTab.results.queryType)}
+                        <Badge variant="outline" class="text-xs"
+                            >{m.query_statements_count({ count: liveStatementCount })}</Badge
+                        >
+                    </span>
+                {/if}
+                <!-- Results stats (shown after execution) -->
+                {#if activeResult}
+                    {#if activeResult.isError}
+                        <span class="flex items-center gap-1 text-destructive">
+                            <XCircleIcon class="size-3" />
+                            {m.query_error()}
+                        </span>
+                    {:else if activeResult.queryType && ['insert', 'update', 'delete'].includes(activeResult.queryType)}
+                        <span class="flex items-center gap-1">
                             <Badge variant="secondary" class="text-xs"
-                                >{db.state.activeQueryTab.results.affectedRows ?? 0}</Badge
+                                >{activeResult.affectedRows ?? 0}</Badge
                             >
                             {m.query_rows_affected()}
-                            {#if db.state.activeQueryTab.results.lastInsertId}
+                            {#if activeResult.lastInsertId}
                                 <Badge variant="outline" class="text-xs ms-1"
-                                    >ID: {db.state.activeQueryTab.results.lastInsertId}</Badge
+                                    >ID: {activeResult.lastInsertId}</Badge
                                 >
                             {/if}
-                        {:else}
-                            <Badge variant="secondary" class="text-xs"
-                                >{db.state.activeQueryTab.results.totalRows.toLocaleString()}</Badge
-                            >
-                            {m.query_total_rows()}
-                        {/if}
-                    </span>
-                    <span class="flex items-center gap-1">
-                        <Badge variant="secondary" class="text-xs"
-                            >{db.state.activeQueryTab.results.executionTime}ms</Badge
-                        >
-                    </span>
+                        </span>
+                    {/if}
                 {/if}
             </div>
             <div class="flex items-center gap-2">
@@ -333,9 +363,11 @@
                     {#key db.state.activeQueryTabId}
                         <MonacoEditor
                             bind:value={db.state.activeQueryTab.query}
+                            bind:ref={monacoRef}
                             schema={db.state.activeSchema}
                             onExecute={handleExecute}
                             onChange={(newValue) => {
+                                currentQuery = newValue;
                                 if (db.state.activeQueryTabId) {
                                     db.queryTabs.updateContent(db.state.activeQueryTabId, newValue);
                                 }
@@ -350,175 +382,232 @@
             <!-- Results Pane -->
             <Resizable.Pane defaultSize={60} minSize={15}>
                 <div class="h-full flex flex-col overflow-hidden">
-                    {#if db.state.activeQueryTab.results}
-                        <div
-                            class="flex items-center justify-end p-2 border-b bg-muted/30 shrink-0"
-                        >
-                            <DropdownMenu.Root>
-                                <DropdownMenu.Trigger
-                                    class={buttonVariants({
-                                        variant: "outline",
-                                        size: "sm",
-                                    }) + " h-7 gap-1"}
-                                >
-                                    <DownloadIcon class="size-3" />
-                                    {m.query_export()}
-                                    <ChevronDownIcon class="size-3" />
-                                </DropdownMenu.Trigger>
-                                <DropdownMenu.Content align="end" class="w-48">
-                                    <DropdownMenu.Group>
-                                        <DropdownMenu.GroupHeading
-                                            >{m.query_download()}</DropdownMenu.GroupHeading
-                                        >
-                                        <DropdownMenu.Item
-                                            onclick={() => handleExport("csv")}
-                                        >
-                                            <DownloadIcon class="size-4 me-2" />
-                                            CSV
-                                        </DropdownMenu.Item>
-                                        <DropdownMenu.Item
-                                            onclick={() => handleExport("json")}
-                                        >
-                                            <DownloadIcon class="size-4 me-2" />
-                                            JSON
-                                        </DropdownMenu.Item>
-                                        <DropdownMenu.Item
-                                            onclick={() => handleExport("sql")}
-                                        >
-                                            <DownloadIcon class="size-4 me-2" />
-                                            SQL INSERT
-                                        </DropdownMenu.Item>
-                                        <DropdownMenu.Item
-                                            onclick={() =>
-                                                handleExport("markdown")}
-                                        >
-                                            <DownloadIcon class="size-4 me-2" />
-                                            Markdown
-                                        </DropdownMenu.Item>
-                                    </DropdownMenu.Group>
-                                    <DropdownMenu.Separator />
-                                    <DropdownMenu.Group>
-                                        <DropdownMenu.GroupHeading
-                                            >{m.query_copy_to_clipboard()}</DropdownMenu.GroupHeading
-                                        >
-                                        <DropdownMenu.Item
-                                            onclick={() => handleCopy("csv")}
-                                        >
-                                            <CopyIcon class="size-4 me-2" />
-                                            CSV
-                                        </DropdownMenu.Item>
-                                        <DropdownMenu.Item
-                                            onclick={() => handleCopy("json")}
-                                        >
-                                            <CopyIcon class="size-4 me-2" />
-                                            JSON
-                                        </DropdownMenu.Item>
-                                        <DropdownMenu.Item
-                                            onclick={() => handleCopy("sql")}
-                                        >
-                                            <CopyIcon class="size-4 me-2" />
-                                            SQL INSERT
-                                        </DropdownMenu.Item>
-                                        <DropdownMenu.Item
-                                            onclick={() =>
-                                                handleCopy("markdown")}
-                                        >
-                                            <CopyIcon class="size-4 me-2" />
-                                            Markdown
-                                        </DropdownMenu.Item>
-                                    </DropdownMenu.Group>
-                                </DropdownMenu.Content>
-                            </DropdownMenu.Root>
-                        </div>
+                    {#if allResults.length > 0}
+                        <!-- Result Tabs (only shown when multiple results) -->
+                        {#if hasMultipleResults}
+                            <div class="flex items-center gap-1 p-2 border-b bg-muted/20 overflow-x-auto shrink-0">
+                                {#each allResults as result, i}
+                                    <button
+                                        class={cn(
+                                            "px-3 py-1.5 text-xs rounded-md shrink-0 flex items-center gap-1.5 transition-colors",
+                                            activeResultIndex === i
+                                                ? "bg-primary text-primary-foreground"
+                                                : "bg-muted hover:bg-muted/80",
+                                            result.isError && activeResultIndex !== i && "text-destructive"
+                                        )}
+                                        onclick={() => db.queries.setActiveResult(db.state.activeQueryTabId!, i)}
+                                    >
+                                        {#if result.isError}
+                                            <XCircleIcon class="size-3" />
+                                        {:else if result.queryType === 'select'}
+                                            <TableIcon class="size-3" />
+                                        {:else}
+                                            <ZapIcon class="size-3" />
+                                        {/if}
+                                        {m.query_statement_n({ n: i + 1 })}
+                                        {#if result.isError}
+                                            <span class="opacity-70">{m.query_result_error()}</span>
+                                        {:else if result.queryType === 'select'}
+                                            <span class="opacity-70">{m.query_result_rows_time({ rows: result.totalRows, time: result.executionTime })}</span>
+                                        {:else if result.affectedRows !== undefined}
+                                            <span class="opacity-70">{m.query_result_affected_time({ affected: result.affectedRows, time: result.executionTime })}</span>
+                                        {:else}
+                                            <span class="opacity-70">{m.query_result_time({ time: result.executionTime })}</span>
+                                        {/if}
+                                    </button>
+                                {/each}
+                            </div>
+                        {/if}
 
-                        <VirtualResultsTable
-                            columns={db.state.activeQueryTab.results.columns}
-                            rows={db.state.activeQueryTab.results.rows}
-                            isEditable={!!isEditable}
-                            onCellSave={handleCellSave}
-                            onRowDelete={confirmDeleteRow}
-                            {deletingRowIndex}
-                            onCopyCell={copyCell}
-                            onCopyRow={copyRowAsJSON}
-                            onCopyColumn={copyColumn}
-                            onCellRightClick={handleCellRightClick}
-                        />
+                        <!-- Export toolbar -->
+                        {#if activeResult && !activeResult.isError}
+                            <div
+                                class="flex items-center justify-end p-2 border-b bg-muted/30 shrink-0"
+                            >
+                                <DropdownMenu.Root>
+                                    <DropdownMenu.Trigger
+                                        class={buttonVariants({
+                                            variant: "outline",
+                                            size: "sm",
+                                        }) + " h-7 gap-1"}
+                                    >
+                                        <DownloadIcon class="size-3" />
+                                        {m.query_export()}
+                                        <ChevronDownIcon class="size-3" />
+                                    </DropdownMenu.Trigger>
+                                    <DropdownMenu.Content align="end" class="w-48">
+                                        <DropdownMenu.Group>
+                                            <DropdownMenu.GroupHeading
+                                                >{m.query_download()}</DropdownMenu.GroupHeading
+                                            >
+                                            <DropdownMenu.Item
+                                                onclick={() => handleExport("csv")}
+                                            >
+                                                <DownloadIcon class="size-4 me-2" />
+                                                CSV
+                                            </DropdownMenu.Item>
+                                            <DropdownMenu.Item
+                                                onclick={() => handleExport("json")}
+                                            >
+                                                <DownloadIcon class="size-4 me-2" />
+                                                JSON
+                                            </DropdownMenu.Item>
+                                            <DropdownMenu.Item
+                                                onclick={() => handleExport("sql")}
+                                            >
+                                                <DownloadIcon class="size-4 me-2" />
+                                                SQL INSERT
+                                            </DropdownMenu.Item>
+                                            <DropdownMenu.Item
+                                                onclick={() =>
+                                                    handleExport("markdown")}
+                                            >
+                                                <DownloadIcon class="size-4 me-2" />
+                                                Markdown
+                                            </DropdownMenu.Item>
+                                        </DropdownMenu.Group>
+                                        <DropdownMenu.Separator />
+                                        <DropdownMenu.Group>
+                                            <DropdownMenu.GroupHeading
+                                                >{m.query_copy_to_clipboard()}</DropdownMenu.GroupHeading
+                                            >
+                                            <DropdownMenu.Item
+                                                onclick={() => handleCopy("csv")}
+                                            >
+                                                <CopyIcon class="size-4 me-2" />
+                                                CSV
+                                            </DropdownMenu.Item>
+                                            <DropdownMenu.Item
+                                                onclick={() => handleCopy("json")}
+                                            >
+                                                <CopyIcon class="size-4 me-2" />
+                                                JSON
+                                            </DropdownMenu.Item>
+                                            <DropdownMenu.Item
+                                                onclick={() => handleCopy("sql")}
+                                            >
+                                                <CopyIcon class="size-4 me-2" />
+                                                SQL INSERT
+                                            </DropdownMenu.Item>
+                                            <DropdownMenu.Item
+                                                onclick={() =>
+                                                    handleCopy("markdown")}
+                                            >
+                                                <CopyIcon class="size-4 me-2" />
+                                                Markdown
+                                            </DropdownMenu.Item>
+                                        </DropdownMenu.Group>
+                                    </DropdownMenu.Content>
+                                </DropdownMenu.Root>
+                            </div>
+                        {/if}
 
-                        <!-- Pagination Controls -->
-                        {#if db.state.activeQueryTab.results.totalPages > 1}
-                            {@const results = db.state.activeQueryTab.results}
-                            {@const start = (results.page - 1) * results.pageSize + 1}
-                            {@const end = Math.min(results.page * results.pageSize, results.totalRows)}
-                            <div class="flex items-center justify-between p-2 border-t bg-muted/30 shrink-0 text-xs">
-                                <div class="text-muted-foreground">
-                                    {m.query_showing_rows({ start, end, total: results.totalRows.toLocaleString() })}
-                                </div>
-                                <div class="flex items-center gap-2">
-                                    <DropdownMenu.Root>
-                                        <DropdownMenu.Trigger
-                                            class={buttonVariants({
-                                                variant: "outline",
-                                                size: "sm",
-                                            }) + " h-7 gap-1 text-xs"}
-                                        >
-                                            {db.state.activeQueryTab.results.pageSize} rows
-                                            <ChevronDownIcon class="size-3" />
-                                        </DropdownMenu.Trigger>
-                                        <DropdownMenu.Content align="end">
-                                            {#each [25, 50, 100, 250, 500, 1000] as size}
-                                                <DropdownMenu.Item
-                                                    onclick={() => db.queries.setPageSize(db.state.activeQueryTabId!, size)}
-                                                    class={db.state.activeQueryTab.results.pageSize === size ? "bg-accent" : ""}
-                                                >
-                                                    {m.query_rows_count({ count: size })}
-                                                </DropdownMenu.Item>
-                                            {/each}
-                                        </DropdownMenu.Content>
-                                    </DropdownMenu.Root>
-
-                                    <div class="flex items-center gap-1">
-                                        <Button
-                                            size="icon"
-                                            variant="outline"
-                                            class="size-7"
-                                            onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, 1)}
-                                            disabled={db.state.activeQueryTab.results.page === 1 || db.state.activeQueryTab.isExecuting}
-                                        >
-                                            <ChevronsLeftIcon class="size-3" />
-                                        </Button>
-                                        <Button
-                                            size="icon"
-                                            variant="outline"
-                                            class="size-7"
-                                            onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, db.state.activeQueryTab!.results!.page - 1)}
-                                            disabled={db.state.activeQueryTab.results.page === 1 || db.state.activeQueryTab.isExecuting}
-                                        >
-                                            <ChevronLeftIcon class="size-3" />
-                                        </Button>
-                                        <span class="px-2 text-muted-foreground">
-                                            {m.query_page_of({ page: db.state.activeQueryTab.results.page, total: db.state.activeQueryTab.results.totalPages })}
-                                        </span>
-                                        <Button
-                                            size="icon"
-                                            variant="outline"
-                                            class="size-7"
-                                            onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, db.state.activeQueryTab!.results!.page + 1)}
-                                            disabled={db.state.activeQueryTab.results.page === db.state.activeQueryTab.results.totalPages || db.state.activeQueryTab.isExecuting}
-                                        >
-                                            <ChevronRightIcon class="size-3" />
-                                        </Button>
-                                        <Button
-                                            size="icon"
-                                            variant="outline"
-                                            class="size-7"
-                                            onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, db.state.activeQueryTab!.results!.totalPages)}
-                                            disabled={db.state.activeQueryTab.results.page === db.state.activeQueryTab.results.totalPages || db.state.activeQueryTab.isExecuting}
-                                        >
-                                            <ChevronsRightIcon class="size-3" />
-                                        </Button>
+                        <!-- Error Display for failed statements -->
+                        {#if activeResult?.isError}
+                            <div class="flex-1 p-4 bg-destructive/10 overflow-auto">
+                                <div class="flex items-start gap-3">
+                                    <XCircleIcon class="size-5 text-destructive shrink-0 mt-0.5" />
+                                    <div class="space-y-3">
+                                        <div>
+                                            <h4 class="font-semibold text-destructive">{m.query_statement_failed({ n: activeResultIndex + 1 })}</h4>
+                                            <pre class="mt-2 text-sm whitespace-pre-wrap text-destructive/90 font-mono">{activeResult.error}</pre>
+                                        </div>
+                                        <details class="text-sm">
+                                            <summary class="cursor-pointer text-muted-foreground hover:text-foreground">{m.query_show_sql()}</summary>
+                                            <pre class="mt-2 text-xs bg-muted p-3 rounded-md overflow-x-auto font-mono">{activeResult.statementSql}</pre>
+                                        </details>
                                     </div>
                                 </div>
                             </div>
+                        {:else if activeResult}
+                            <VirtualResultsTable
+                                columns={activeResult.columns}
+                                rows={activeResult.rows}
+                                isEditable={!!isEditable}
+                                onCellSave={handleCellSave}
+                                onRowDelete={confirmDeleteRow}
+                                {deletingRowIndex}
+                                onCopyCell={copyCell}
+                                onCopyRow={copyRowAsJSON}
+                                onCopyColumn={copyColumn}
+                                onCellRightClick={handleCellRightClick}
+                            />
+
+                            <!-- Pagination Controls -->
+                            {#if activeResult.totalPages > 1}
+                                {@const start = (activeResult.page - 1) * activeResult.pageSize + 1}
+                                {@const end = Math.min(activeResult.page * activeResult.pageSize, activeResult.totalRows)}
+                                <div class="flex items-center justify-between p-2 border-t bg-muted/30 shrink-0 text-xs">
+                                    <div class="text-muted-foreground">
+                                        {m.query_showing_rows({ start, end, total: activeResult.totalRows.toLocaleString() })}
+                                    </div>
+                                    <div class="flex items-center gap-2">
+                                        <DropdownMenu.Root>
+                                            <DropdownMenu.Trigger
+                                                class={buttonVariants({
+                                                    variant: "outline",
+                                                    size: "sm",
+                                                }) + " h-7 gap-1 text-xs"}
+                                            >
+                                                {activeResult.pageSize} rows
+                                                <ChevronDownIcon class="size-3" />
+                                            </DropdownMenu.Trigger>
+                                            <DropdownMenu.Content align="end">
+                                                {#each [25, 50, 100, 250, 500, 1000] as size}
+                                                    <DropdownMenu.Item
+                                                        onclick={() => db.queries.setPageSize(db.state.activeQueryTabId!, size)}
+                                                        class={activeResult.pageSize === size ? "bg-accent" : ""}
+                                                    >
+                                                        {m.query_rows_count({ count: size })}
+                                                    </DropdownMenu.Item>
+                                                {/each}
+                                            </DropdownMenu.Content>
+                                        </DropdownMenu.Root>
+
+                                        <div class="flex items-center gap-1">
+                                            <Button
+                                                size="icon"
+                                                variant="outline"
+                                                class="size-7"
+                                                onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, 1)}
+                                                disabled={activeResult.page === 1 || db.state.activeQueryTab.isExecuting}
+                                            >
+                                                <ChevronsLeftIcon class="size-3" />
+                                            </Button>
+                                            <Button
+                                                size="icon"
+                                                variant="outline"
+                                                class="size-7"
+                                                onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, activeResult.page - 1)}
+                                                disabled={activeResult.page === 1 || db.state.activeQueryTab.isExecuting}
+                                            >
+                                                <ChevronLeftIcon class="size-3" />
+                                            </Button>
+                                            <span class="px-2 text-muted-foreground">
+                                                {m.query_page_of({ page: activeResult.page, total: activeResult.totalPages })}
+                                            </span>
+                                            <Button
+                                                size="icon"
+                                                variant="outline"
+                                                class="size-7"
+                                                onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, activeResult.page + 1)}
+                                                disabled={activeResult.page === activeResult.totalPages || db.state.activeQueryTab.isExecuting}
+                                            >
+                                                <ChevronRightIcon class="size-3" />
+                                            </Button>
+                                            <Button
+                                                size="icon"
+                                                variant="outline"
+                                                class="size-7"
+                                                onclick={() => db.queries.goToPage(db.state.activeQueryTabId!, activeResult.totalPages)}
+                                                disabled={activeResult.page === activeResult.totalPages || db.state.activeQueryTab.isExecuting}
+                                            >
+                                                <ChevronsRightIcon class="size-3" />
+                                            </Button>
+                                        </div>
+                                    </div>
+                                </div>
+                            {/if}
                         {/if}
                     {:else}
                         <div
@@ -581,10 +670,10 @@
 </Dialog.Root>
 
 <!-- Insert Row Dialog -->
-{#if db.state.activeQueryTab?.results?.sourceTable && sourceTableColumns.length > 0}
+{#if activeResult?.sourceTable && sourceTableColumns.length > 0}
     <InsertRowDialog
         bind:open={showInsertDialog}
-        sourceTable={db.state.activeQueryTab.results.sourceTable}
+        sourceTable={activeResult.sourceTable}
         columns={sourceTableColumns}
         onClose={() => showInsertDialog = false}
         onSuccess={() => db.state.activeQueryTabId && db.queries.execute(db.state.activeQueryTabId)}
diff --git a/src/lib/db/sql-parser.ts b/src/lib/db/sql-parser.ts
new file mode 100644
index 0000000..d5b7240
--- /dev/null
+++ b/src/lib/db/sql-parser.ts
@@ -0,0 +1,230 @@
+import type { DatabaseType } from '$lib/types';
+
+export interface ParsedStatement {
+	sql: string;
+	index: number;
+	startOffset: number; // Character position where statement starts (in original input)
+	endOffset: number; // Character position where statement ends (in original input)
+}
+
+type ParserState =
+	| 'normal'
+	| 'single_quote'
+	| 'double_quote'
+	| 'line_comment'
+	| 'block_comment'
+	| 'dollar_quote';
+
+/**
+ * Splits a SQL string containing multiple statements into individual statements.
+ * Uses a state machine to properly handle semicolons inside:
+ * - Single-quoted strings ('...')
+ * - Double-quoted identifiers ("...")
+ * - Line comments (-- ...)
+ * - Block comments (/* ... *\/)
+ * - Dollar-quoted strings ($$...$$ or $tag$...$tag$) for PostgreSQL
+ */
+export function splitSqlStatements(sql: string, _dbType: DatabaseType): ParsedStatement[] {
+	const statements: ParsedStatement[] = [];
+	let currentStatement = '';
+	let statementStartOffset = 0; // Track where current statement started
+	let state: ParserState = 'normal';
+	let dollarTag = ''; // For tracking PostgreSQL dollar-quoted strings
+	let i = 0;
+
+	while (i < sql.length) {
+		const char = sql[i];
+		const nextChar = sql[i + 1] ?? '';
+
+		switch (state) {
+			case 'normal':
+				if (char === "'" ) {
+					state = 'single_quote';
+					currentStatement += char;
+				} else if (char === '"') {
+					state = 'double_quote';
+					currentStatement += char;
+				} else if (char === '-' && nextChar === '-') {
+					state = 'line_comment';
+					currentStatement += char;
+				} else if (char === '/' && nextChar === '*') {
+					state = 'block_comment';
+					currentStatement += char;
+				} else if (char === '$') {
+					// Check for PostgreSQL dollar-quoted string
+					const dollarMatch = sql.slice(i).match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/);
+					if (dollarMatch) {
+						dollarTag = dollarMatch[0];
+						state = 'dollar_quote';
+						currentStatement += dollarTag;
+						i += dollarTag.length - 1; // -1 because loop will increment
+					} else {
+						currentStatement += char;
+					}
+				} else if (char === ';') {
+					// End of statement
+					const trimmed = currentStatement.trim();
+					if (trimmed) {
+						statements.push({
+							sql: trimmed,
+							index: statements.length,
+							startOffset: statementStartOffset,
+							endOffset: i // The semicolon position
+						});
+					}
+					currentStatement = '';
+					statementStartOffset = i + 1; // Next statement starts after the semicolon
+				} else {
+					currentStatement += char;
+				}
+				break;
+
+			case 'single_quote':
+				currentStatement += char;
+				if (char === "'" && nextChar === "'") {
+					// Escaped single quote
+					currentStatement += nextChar;
+					i++;
+				} else if (char === "'") {
+					state = 'normal';
+				}
+				break;
+
+			case 'double_quote':
+				currentStatement += char;
+				if (char === '"' && nextChar === '"') {
+					// Escaped double quote
+					currentStatement += nextChar;
+					i++;
+				} else if (char === '"') {
+					state = 'normal';
+				}
+				break;
+
+			case 'line_comment':
+				currentStatement += char;
+				if (char === '\n') {
+					state = 'normal';
+				}
+				break;
+
+			case 'block_comment':
+				currentStatement += char;
+				if (char === '*' && nextChar === '/') {
+					currentStatement += nextChar;
+					i++;
+					state = 'normal';
+				}
+				break;
+
+			case 'dollar_quote':
+				currentStatement += char;
+				// Check if we've reached the closing dollar tag
+				if (char === '$' && sql.slice(i, i + dollarTag.length) === dollarTag) {
+					currentStatement += sql.slice(i + 1, i + dollarTag.length);
+					i += dollarTag.length - 1;
+					state = 'normal';
+					dollarTag = '';
+				}
+				break;
+		}
+
+		i++;
+	}
+
+	// Add final statement if there's content
+	const trimmed = currentStatement.trim();
+	if (trimmed) {
+		statements.push({
+			sql: trimmed,
+			index: statements.length,
+			startOffset: statementStartOffset,
+			endOffset: sql.length - 1 // End of input
+		});
+	}
+
+	// Filter out statements that are only comments/whitespace
+	const nonEmptyStatements = statements.filter((stmt) => !isOnlyComments(stmt.sql));
+
+	// Re-index after filtering (preserve offsets)
+	const reindexed = nonEmptyStatements.map((stmt, idx) => ({
+		sql: stmt.sql,
+		index: idx,
+		startOffset: stmt.startOffset,
+		endOffset: stmt.endOffset
+	}));
+
+	// If no statements found, return empty array
+	if (reindexed.length === 0) {
+		return [];
+	}
+
+	return reindexed;
+}
+
+/**
+ * Finds the statement at a given cursor offset position.
+ * Returns the first statement if cursor is between statements or at the start.
+ */
+export function getStatementAtOffset(
+	sql: string,
+	offset: number,
+	dbType: DatabaseType
+): ParsedStatement | null {
+	const statements = splitSqlStatements(sql, dbType);
+	if (statements.length === 0) return null;
+
+	// Find statement containing the offset
+	const found = statements.find(
+		(s) => offset >= s.startOffset && offset <= s.endOffset
+	);
+
+	// If cursor is between statements or at the start, return first statement
+	return found ?? statements[0];
+}
+
+/**
+ * Checks if a SQL string contains only comments and whitespace (no actual SQL code).
+ */
+function isOnlyComments(sql: string): boolean {
+	let i = 0;
+	const len = sql.length;
+
+	while (i < len) {
+		const char = sql[i];
+		const nextChar = sql[i + 1] ?? '';
+
+		// Skip whitespace
+		if (/\s/.test(char)) {
+			i++;
+			continue;
+		}
+
+		// Skip line comments
+		if (char === '-' && nextChar === '-') {
+			// Find end of line
+			while (i < len && sql[i] !== '\n') {
+				i++;
+			}
+			continue;
+		}
+
+		// Skip block comments
+		if (char === '/' && nextChar === '*') {
+			i += 2;
+			while (i < len - 1) {
+				if (sql[i] === '*' && sql[i + 1] === '/') {
+					i += 2;
+					break;
+				}
+				i++;
+			}
+			continue;
+		}
+
+		// Found a non-comment, non-whitespace character
+		return false;
+	}
+
+	return true;
+}
diff --git a/src/lib/hooks/database/explain-tabs.svelte.ts b/src/lib/hooks/database/explain-tabs.svelte.ts
index 9bda378..98573d4 100644
--- a/src/lib/hooks/database/explain-tabs.svelte.ts
+++ b/src/lib/hooks/database/explain-tabs.svelte.ts
@@ -4,6 +4,7 @@ import type { DatabaseState } from "./state.svelte.js";
 import type { TabOrderingManager } from "./tab-ordering.svelte.js";
 import { getAdapter, type ExplainNode } from "$lib/db";
 import { setMapValue } from "./map-utils.js";
+import { getStatementAtOffset } from "$lib/db/sql-parser";
 
 /**
  * Manages EXPLAIN/ANALYZE tabs: execute, remove, set active.
@@ -58,22 +59,36 @@ export class ExplainTabManager {
 
   /**
    * Execute EXPLAIN or EXPLAIN ANALYZE on a query tab.
+   * If cursorOffset is provided, explains only the statement at that cursor position.
    */
-  async execute(tabId: string, analyze: boolean = false): Promise<void> {
+  async execute(tabId: string, analyze: boolean = false, cursorOffset?: number): Promise<void> {
     if (!this.state.activeConnectionId || !this.state.activeConnection) return;
 
     const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId) || [];
     const tab = tabs.find((t) => t.id === tabId);
     if (!tab || !tab.query.trim()) return;
 
+    // Get the statement to explain based on cursor position
+    const dbType = this.state.activeConnection.type;
+    let queryToExplain = tab.query;
+
+    if (cursorOffset !== undefined) {
+      const statement = getStatementAtOffset(tab.query, cursorOffset, dbType);
+      if (statement) {
+        queryToExplain = statement.sql;
+      }
+    }
+
+    if (!queryToExplain.trim()) return;
+
     // Create a new explain tab
     const explainTabs = this.state.explainTabsByConnection.get(this.state.activeConnectionId) || [];
     const explainTabId = `explain-${Date.now()}`;
-    const queryPreview = tab.query.substring(0, 30).replace(/\s+/g, " ").trim();
+    const queryPreview = queryToExplain.substring(0, 30).replace(/\s+/g, " ").trim();
     const newExplainTab: ExplainTab = $state({
       id: explainTabId,
       name: analyze ? `Analyze: ${queryPreview}...` : `Explain: ${queryPreview}...`,
-      sourceQuery: tab.query,
+      sourceQuery: queryToExplain,
       result: undefined,
       isExecuting: true,
     });
@@ -93,7 +108,7 @@ export class ExplainTabManager {
 
     try {
       const adapter = getAdapter(this.state.activeConnection.type);
-      const explainQuery = adapter.getExplainQuery(tab.query, analyze);
+      const explainQuery = adapter.getExplainQuery(queryToExplain, analyze);
       const result = (await this.state.activeConnection.database!.select(explainQuery)) as unknown[];
 
       // Use adapter to parse the results into common format
diff --git a/src/lib/hooks/database/query-execution.svelte.ts b/src/lib/hooks/database/query-execution.svelte.ts
index baf83f8..d273798 100644
--- a/src/lib/hooks/database/query-execution.svelte.ts
+++ b/src/lib/hooks/database/query-execution.svelte.ts
@@ -1,10 +1,11 @@
 import { toast } from "svelte-sonner";
-import type { QueryResult } from "$lib/types";
+import type { QueryResult, StatementResult } from "$lib/types";
 import type { DatabaseState } from "./state.svelte.js";
 import type { QueryHistoryManager } from "./query-history.svelte.js";
-import { getAdapter } from "$lib/db";
 import { detectQueryType, isWriteQuery, extractTableFromSelect } from "$lib/db/query-utils";
+import { splitSqlStatements } from "$lib/db/sql-parser";
 import { updateMapArrayItem } from "./map-utils.js";
+import { m } from "$lib/paraglide/messages.js";
 
 /**
  * Manages query execution, pagination, and CRUD operations.
@@ -30,7 +31,10 @@ export class QueryExecutionManager {
   /**
    * Update a query tab's state with proper Svelte 5 reactivity.
    */
-  private updateQueryTabState(tabId: string, updates: Partial<{ results: QueryResult; isExecuting: boolean }>): void {
+  private updateQueryTabState(
+    tabId: string,
+    updates: Partial<{ results: StatementResult[]; activeResultIndex: number; isExecuting: boolean }>
+  ): void {
     if (!this.state.activeConnectionId) return;
     updateMapArrayItem(
       () => this.state.queryTabsByConnection,
@@ -53,12 +57,115 @@ export class QueryExecutionManager {
   }
 
   /**
-   * Execute a query in the specified tab.
+   * Execute a single SQL statement and return the result.
+   */
+  private async executeStatement(
+    sql: string,
+    page: number,
+    pageSize: number,
+    database: NonNullable<typeof this.state.activeConnection>["database"]
+  ): Promise<QueryResult> {
+    const start = performance.now();
+    const baseQuery = sql.replace(/;$/, "").trim();
+    const queryType = detectQueryType(baseQuery);
+
+    // Handle write queries (INSERT/UPDATE/DELETE)
+    if (isWriteQuery(baseQuery)) {
+      const executeResult = await database!.execute(baseQuery);
+      const totalMs = performance.now() - start;
+
+      return {
+        columns: ["Result"],
+        rows: [{ Result: `${executeResult?.rowsAffected ?? 0} row(s) affected` }],
+        rowCount: 1,
+        totalRows: 1,
+        executionTime: Math.round(totalMs * 100) / 100,
+        affectedRows: executeResult?.rowsAffected ?? 0,
+        lastInsertId: executeResult?.lastInsertId,
+        queryType,
+        page: 1,
+        pageSize: 1,
+        totalPages: 1,
+      };
+    }
+
+    // Handle SELECT queries
+    // Check if query already has LIMIT clause - if so, skip pagination
+    const hasLimit = /\bLIMIT\b/i.test(baseQuery);
+
+    let totalRows = 0;
+    let paginatedQuery = baseQuery;
+
+    if (!hasLimit) {
+      // Get total count first by wrapping in a subquery
+      const countQuery = `SELECT COUNT(*) as total FROM (${baseQuery}) AS count_query`;
+      try {
+        const countResult = (await database!.select(countQuery)) as { total: string | number }[];
+        totalRows = parseInt(String(countResult[0]?.total ?? "0"), 10);
+      } catch {
+        // If count fails, just run the query without pagination
+        totalRows = -1;
+      }
+
+      // Add LIMIT/OFFSET if we successfully got a count (it's a SELECT)
+      if (totalRows >= 0) {
+        const offset = (page - 1) * pageSize;
+        paginatedQuery = `${baseQuery} LIMIT ${pageSize} OFFSET ${offset}`;
+      }
+    } else {
+      // Query has its own LIMIT, don't paginate
+      totalRows = -1;
+    }
+
+    const dbResult = (await database!.select(paginatedQuery)) as Record<string, unknown>[];
+    const totalMs = performance.now() - start;
+
+    // If count failed or query had LIMIT, use result length as total
+    if (totalRows < 0) {
+      totalRows = dbResult?.length ?? 0;
+    }
+
+    const totalPages = hasLimit ? 1 : Math.max(1, Math.ceil(totalRows / pageSize));
+
+    // Try to extract source table info for CRUD operations
+    const tableInfo = extractTableFromSelect(baseQuery);
+    let sourceTable: QueryResult["sourceTable"] | undefined;
+
+    if (tableInfo) {
+      const schema = tableInfo.schema || "public";
+      const primaryKeys = this.getPrimaryKeysForTable(schema, tableInfo.table);
+      if (primaryKeys.length > 0) {
+        sourceTable = {
+          schema,
+          name: tableInfo.table,
+          primaryKeys,
+        };
+      }
+    }
+
+    // Generate results
+    return {
+      columns: (dbResult?.length ?? 0) > 0 ? Object.keys(dbResult[0]) : [],
+      rows: dbResult || [],
+      rowCount: dbResult?.length ?? 0,
+      totalRows,
+      executionTime: Math.round(totalMs * 100) / 100,
+      queryType,
+      sourceTable,
+      page,
+      pageSize,
+      totalPages,
+    };
+  }
+
+  /**
+   * Execute all statements in a query tab.
    */
   async execute(tabId: string, page: number = 1, pageSize?: number): Promise<void> {
     if (!this.state.activeConnectionId) return;
 
-    const database = this.state.activeConnection?.database;
+    const connection = this.state.activeConnection;
+    const database = connection?.database;
     if (!database) {
       toast.error("Not connected to database. Please reconnect.");
       return;
@@ -70,138 +177,159 @@ export class QueryExecutionManager {
 
     // Mark as executing with proper reactivity
     this.updateQueryTabState(tabId, { isExecuting: true });
-    const effectivePageSize = pageSize ?? tab.results?.pageSize ?? this.DEFAULT_PAGE_SIZE;
 
-    try {
-      const start = performance.now();
-      const baseQuery = tab.query.replace(/;$/, "");
-      const queryType = detectQueryType(baseQuery);
-
-      // Handle write queries (INSERT/UPDATE/DELETE)
-      if (isWriteQuery(baseQuery)) {
-        const executeResult = await database.execute(baseQuery);
-        const totalMs = performance.now() - start;
-
-        const results: QueryResult = {
-          columns: ["Result"],
-          rows: [{ Result: `${executeResult?.rowsAffected ?? 0} row(s) affected` }],
+    // Get effective page size from the first result or use default
+    const effectivePageSize = pageSize ?? tab.results?.[0]?.pageSize ?? this.DEFAULT_PAGE_SIZE;
+
+    // Get database type for parsing
+    const dbType = connection?.type ?? "postgres";
+
+    // Parse SQL into individual statements
+    const statements = splitSqlStatements(tab.query, dbType);
+
+    // Handle case where all statements are comments
+    if (statements.length === 0) {
+      this.updateQueryTabState(tabId, {
+        results: [],
+        activeResultIndex: 0,
+        isExecuting: false,
+      });
+      toast.info(m.query_no_executable_statements());
+      return;
+    }
+
+    const results: StatementResult[] = [];
+
+    // Execute each statement
+    for (let i = 0; i < statements.length; i++) {
+      const stmt = statements[i];
+      try {
+        const result = await this.executeStatement(stmt.sql, page, effectivePageSize, database);
+        results.push({
+          ...result,
+          statementIndex: i,
+          statementSql: stmt.sql,
+          isError: false,
+        });
+      } catch (error) {
+        // Continue on error - add error result
+        results.push({
+          columns: ["Error"],
+          rows: [{ Error: this.formatError(error) }],
           rowCount: 1,
           totalRows: 1,
-          executionTime: Math.round(totalMs * 100) / 100,
-          affectedRows: executeResult?.rowsAffected ?? 0,
-          lastInsertId: executeResult?.lastInsertId,
-          queryType,
+          executionTime: 0,
           page: 1,
           pageSize: 1,
           totalPages: 1,
-        };
+          statementIndex: i,
+          statementSql: stmt.sql,
+          error: this.formatError(error),
+          isError: true,
+        });
+      }
+    }
 
-        // Update tab with results using proper reactivity
-        this.updateQueryTabState(tabId, { results, isExecuting: false });
+    // Update tab with all results
+    this.updateQueryTabState(tabId, {
+      results,
+      activeResultIndex: 0,
+      isExecuting: false,
+    });
 
-        // Add to history
-        this.queryHistory.addToHistory(tab.query, results);
-        return;
-      }
+    // Add to history (only on first page to avoid duplicates, use first result's timing)
+    if (page === 1 && results.length > 0) {
+      this.queryHistory.addToHistory(tab.query, results[0]);
+    }
+  }
 
-      // Handle SELECT queries
-      // Check if query already has LIMIT clause - if so, skip pagination
-      const hasLimit = /\bLIMIT\b/i.test(baseQuery);
-
-      let totalRows = 0;
-      let paginatedQuery = baseQuery;
-
-      if (!hasLimit) {
-        // Get total count first by wrapping in a subquery
-        const countQuery = `SELECT COUNT(*) as total FROM (${baseQuery}) AS count_query`;
-        try {
-          const countResult = (await database.select(countQuery)) as { total: string | number }[];
-          totalRows = parseInt(String(countResult[0]?.total ?? "0"), 10);
-        } catch {
-          // If count fails, just run the query without pagination
-          totalRows = -1;
-        }
-
-        // Add LIMIT/OFFSET if we successfully got a count (it's a SELECT)
-        if (totalRows >= 0) {
-          const offset = (page - 1) * effectivePageSize;
-          paginatedQuery = `${baseQuery} LIMIT ${effectivePageSize} OFFSET ${offset}`;
-        }
-      } else {
-        // Query has its own LIMIT, don't paginate
-        totalRows = -1;
-      }
+  /**
+   * Set the active result tab index.
+   */
+  setActiveResult(tabId: string, resultIndex: number): void {
+    if (!this.state.activeConnectionId) return;
 
-      const dbResult = (await database.select(paginatedQuery)) as Record<string, unknown>[];
-      const totalMs = performance.now() - start;
+    const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId) || [];
+    const tab = tabs.find((t) => t.id === tabId);
+    if (!tab?.results || resultIndex < 0 || resultIndex >= tab.results.length) return;
 
-      // If count failed or query had LIMIT, use result length as total
-      if (totalRows < 0) {
-        totalRows = dbResult?.length ?? 0;
-      }
+    this.updateQueryTabState(tabId, { activeResultIndex: resultIndex });
+  }
 
-      const totalPages = hasLimit ? 1 : Math.max(1, Math.ceil(totalRows / effectivePageSize));
-
-      // Try to extract source table info for CRUD operations
-      const tableInfo = extractTableFromSelect(baseQuery);
-      let sourceTable: QueryResult["sourceTable"] | undefined;
-
-      if (tableInfo) {
-        const schema = tableInfo.schema || "public";
-        const primaryKeys = this.getPrimaryKeysForTable(schema, tableInfo.table);
-        if (primaryKeys.length > 0) {
-          sourceTable = {
-            schema,
-            name: tableInfo.table,
-            primaryKeys,
-          };
-        }
-      }
+  /**
+   * Navigate to a specific page for a specific result.
+   */
+  async goToPage(tabId: string, page: number, resultIndex?: number): Promise<void> {
+    const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId!) || [];
+    const tab = tabs.find((t) => t.id === tabId);
+    if (!tab?.results) return;
 
-      // Generate results
-      const results: QueryResult = {
-        columns: (dbResult?.length ?? 0) > 0 ? Object.keys(dbResult[0]) : [],
-        rows: dbResult || [],
-        rowCount: dbResult?.length ?? 0,
-        totalRows,
-        executionTime: Math.round(totalMs * 100) / 100,
-        queryType,
-        sourceTable,
-        page,
-        pageSize: effectivePageSize,
-        totalPages,
-      };
+    const activeIndex = resultIndex ?? tab.activeResultIndex ?? 0;
+    const result = tab.results[activeIndex];
+    if (!result) return;
 
-      // Update tab with results using proper reactivity
-      this.updateQueryTabState(tabId, { results, isExecuting: false });
+    const targetPage = Math.max(1, Math.min(page, result.totalPages));
 
-      // Add to history (only on first page to avoid duplicates)
-      if (page === 1) {
-        this.queryHistory.addToHistory(tab.query, results);
-      }
-    } catch (error) {
-      this.updateQueryTabState(tabId, { isExecuting: false });
-      toast.error(`Query failed: ${error}`);
-    }
+    // Re-execute the specific statement with new page
+    await this.executeStatementAtIndex(tabId, activeIndex, targetPage, result.pageSize);
   }
 
   /**
-   * Navigate to a specific page.
+   * Re-execute a specific statement at a given index with pagination.
    */
-  async goToPage(tabId: string, page: number): Promise<void> {
-    const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId!) || [];
+  private async executeStatementAtIndex(
+    tabId: string,
+    resultIndex: number,
+    page: number,
+    pageSize: number
+  ): Promise<void> {
+    if (!this.state.activeConnectionId) return;
+
+    const connection = this.state.activeConnection;
+    const database = connection?.database;
+    if (!database) return;
+
+    const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId) || [];
     const tab = tabs.find((t) => t.id === tabId);
-    if (!tab?.results) return;
+    if (!tab?.results || resultIndex >= tab.results.length) return;
+
+    const existingResult = tab.results[resultIndex];
+
+    try {
+      const result = await this.executeStatement(existingResult.statementSql, page, pageSize, database);
+
+      // Update only this specific result in the array
+      const newResults = [...tab.results];
+      newResults[resultIndex] = {
+        ...result,
+        statementIndex: resultIndex,
+        statementSql: existingResult.statementSql,
+        isError: false,
+      };
 
-    const targetPage = Math.max(1, Math.min(page, tab.results.totalPages));
-    await this.execute(tabId, targetPage, tab.results.pageSize);
+      this.updateQueryTabState(tabId, { results: newResults });
+    } catch (error) {
+      // Update with error
+      const newResults = [...tab.results];
+      newResults[resultIndex] = {
+        ...existingResult,
+        error: this.formatError(error),
+        isError: true,
+      };
+      this.updateQueryTabState(tabId, { results: newResults });
+    }
   }
 
   /**
    * Set page size and re-execute query.
    */
-  async setPageSize(tabId: string, pageSize: number): Promise<void> {
-    await this.execute(tabId, 1, pageSize);
+  async setPageSize(tabId: string, pageSize: number, resultIndex?: number): Promise<void> {
+    const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId!) || [];
+    const tab = tabs.find((t) => t.id === tabId);
+    if (!tab?.results) return;
+
+    const activeIndex = resultIndex ?? tab.activeResultIndex ?? 0;
+    await this.executeStatementAtIndex(tabId, activeIndex, 1, pageSize);
   }
 
   /**
@@ -209,6 +337,7 @@ export class QueryExecutionManager {
    */
   async updateCell(
     tabId: string,
+    resultIndex: number,
     rowIndex: number,
     column: string,
     newValue: unknown,
@@ -216,9 +345,12 @@ export class QueryExecutionManager {
   ): Promise<{ success: boolean; error?: string }> {
     const tabs = this.state.queryTabsByConnection.get(this.state.activeConnectionId!) || [];
     const tab = tabs.find((t) => t.id === tabId);
-    if (!tab?.results) return { success: false, error: "No results" };
+    if (!tab?.results || resultIndex >= tab.results.length) {
+      return { success: false, error: "No results" };
+    }
 
-    const row = tab.results.rows[rowIndex];
+    const result = tab.results[resultIndex];
+    const row = result.rows[rowIndex];
     if (!row) return { success: false, error: "Row not found" };
 
     if (sourceTable.primaryKeys.length === 0) {
diff --git a/src/lib/hooks/database/state.svelte.ts b/src/lib/hooks/database/state.svelte.ts
index c07e3a5..570e9ef 100644
--- a/src/lib/hooks/database/state.svelte.ts
+++ b/src/lib/hooks/database/state.svelte.ts
@@ -75,6 +75,11 @@ export class DatabaseState {
     this.queryTabs.find((t) => t.id === this.activeQueryTabId) || null,
   );
 
+  // Derived: active query result (for multi-statement support)
+  activeQueryResult = $derived(
+    this.activeQueryTab?.results?.[this.activeQueryTab.activeResultIndex ?? 0] || null,
+  );
+
   // Derived: schema tabs for active connection
   schemaTabs = $derived(
     this.activeConnectionId
diff --git a/src/lib/types.ts b/src/lib/types.ts
index 8d29582..27e7a49 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -66,7 +66,8 @@ export interface QueryTab {
 	id: string;
 	name: string;
 	query: string;
-	results?: QueryResult;
+	results?: StatementResult[];
+	activeResultIndex?: number;
 	isExecuting: boolean;
 	savedQueryId?: string;
 }
@@ -95,6 +96,13 @@ export interface QueryResult {
 	totalPages: number;
 }
 
+export interface StatementResult extends QueryResult {
+	statementIndex: number;
+	statementSql: string;
+	error?: string;
+	isError: boolean;
+}
+
 export interface QueryHistoryItem {
 	id: string;
 	query: string;