From 8e4c3b9b325920b06e207c343ea77d88b7bb765f Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 11:31:14 +0100
Subject: [PATCH 01/21] fix(ui): prevent text overflow for long paths in
 DataLake components

- Added `wordBreak: 'break-all'` and `overflowWrap: 'anywhere'` to Typography components displaying file paths and connection strings.
- Fixed layout issues caused by long text in:
    - DataLakeInstanceDetails (Data Path, Metadata Path, Host, Temp Directory)
    - DataLakeTableDetails (Table Path, Data File Paths)
    - DataLakeInstances (Data Path column in the list view)
    - DataLakeConnectionWizard (Location in the review step)
---
 .../dataLake/DataLakeConnectionWizard.tsx     |  6 +++
 .../dataLake/DataLakeInstanceDetails.tsx      | 40 ++++++++++++++++---
 .../components/dataLake/DataLakeInstances.tsx |  4 +-
 .../dataLake/DataLakeTableDetails.tsx         | 29 ++++++++++++--
 4 files changed, 69 insertions(+), 10 deletions(-)

diff --git a/src/renderer/components/dataLake/DataLakeConnectionWizard.tsx b/src/renderer/components/dataLake/DataLakeConnectionWizard.tsx
index 267152b..d685f6d 100644
--- a/src/renderer/components/dataLake/DataLakeConnectionWizard.tsx
+++ b/src/renderer/components/dataLake/DataLakeConnectionWizard.tsx
@@ -1811,6 +1811,12 @@ export const DataLakeConnectionWizard: React.FC<
                       <ListItemText
                         primary="Location"
                         secondary={getStorageLocation()}
+                        secondaryTypographyProps={{
+                          sx: {
+                            wordBreak: 'break-all',
+                            overflowWrap: 'anywhere',
+                          },
+                        }}
                       />
                     </ListItem>
                     {wizardData.basics?.description && (
diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index c90e5d3..4c0bb9e 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -409,7 +409,11 @@ export const DataLakeInstanceDetails: React.FC<
                       primary="Storage Path"
                       secondary={healthQuery.data.storageLocation}
                       secondaryTypographyProps={{
-                        sx: { fontFamily: 'monospace' },
+                        sx: {
+                          fontFamily: 'monospace',
+                          wordBreak: 'break-all',
+                          overflowWrap: 'anywhere',
+                        },
                       }}
                     />
                   </ListItem>
@@ -525,7 +529,12 @@ export const DataLakeInstanceDetails: React.FC<
                 primary="Data Path"
                 secondary={instance.dataPath}
                 secondaryTypographyProps={{
-                  sx: { fontFamily: 'monospace', fontSize: '0.875rem' },
+                  sx: {
+                    fontFamily: 'monospace',
+                    fontSize: '0.875rem',
+                    wordBreak: 'break-all',
+                    overflowWrap: 'anywhere',
+                  },
                 }}
               />
             </ListItem>
@@ -582,7 +591,12 @@ export const DataLakeInstanceDetails: React.FC<
                   primary="Metadata Path"
                   secondary={instance.catalog.duckdb.metadataPath}
                   secondaryTypographyProps={{
-                    sx: { fontFamily: 'monospace', fontSize: '0.875rem' },
+                    sx: {
+                      fontFamily: 'monospace',
+                      fontSize: '0.875rem',
+                      wordBreak: 'break-all',
+                      overflowWrap: 'anywhere',
+                    },
                   }}
                 />
               </ListItem>
@@ -593,7 +607,12 @@ export const DataLakeInstanceDetails: React.FC<
                   primary="Metadata Path"
                   secondary={instance.catalog.sqlite.metadataPath}
                   secondaryTypographyProps={{
-                    sx: { fontFamily: 'monospace', fontSize: '0.875rem' },
+                    sx: {
+                      fontFamily: 'monospace',
+                      fontSize: '0.875rem',
+                      wordBreak: 'break-all',
+                      overflowWrap: 'anywhere',
+                    },
                   }}
                 />
               </ListItem>
@@ -605,6 +624,12 @@ export const DataLakeInstanceDetails: React.FC<
                     <ListItemText
                       primary="Host"
                       secondary={`${instance.catalog.postgresql.host}:${instance.catalog.postgresql.port}`}
+                      secondaryTypographyProps={{
+                        sx: {
+                          wordBreak: 'break-all',
+                          overflowWrap: 'anywhere',
+                        },
+                      }}
                     />
                   </ListItem>
                   <ListItem>
@@ -698,7 +723,12 @@ export const DataLakeInstanceDetails: React.FC<
                       </Typography>
                       <Typography
                         variant="body1"
-                        sx={{ fontFamily: 'monospace', fontSize: '0.875rem' }}
+                        sx={{
+                          fontFamily: 'monospace',
+                          fontSize: '0.875rem',
+                          wordBreak: 'break-all',
+                          overflowWrap: 'anywhere',
+                        }}
                       >
                         {instance.runtime.tempDirectory || 'Default'}
                       </Typography>
diff --git a/src/renderer/components/dataLake/DataLakeInstances.tsx b/src/renderer/components/dataLake/DataLakeInstances.tsx
index 8da5f5b..4536cd5 100644
--- a/src/renderer/components/dataLake/DataLakeInstances.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstances.tsx
@@ -212,7 +212,9 @@ export const DataLakeInstances: React.FC<DuckLakeInstancesProps> = ({
                       variant="outlined"
                     />
                   </TableCell>
-                  <TableCell>
+                  <TableCell
+                    sx={{ wordBreak: 'break-all', overflowWrap: 'anywhere' }}
+                  >
                     <Typography
                       variant="body2"
                       sx={{ fontFamily: 'monospace' }}
diff --git a/src/renderer/components/dataLake/DataLakeTableDetails.tsx b/src/renderer/components/dataLake/DataLakeTableDetails.tsx
index 4667923..993acf6 100644
--- a/src/renderer/components/dataLake/DataLakeTableDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeTableDetails.tsx
@@ -251,9 +251,26 @@ export const DataLakeTableDetails: React.FC = () => {
                         <TableCell>
                           <strong>Path</strong>
                         </TableCell>
-                        <TableCell>
-                          {tableDetails.path}
-                          {tableDetails.pathIsRelative && ' (relative)'}
+                        <TableCell
+                          sx={{
+                            wordBreak: 'break-all',
+                            overflowWrap: 'anywhere',
+                          }}
+                        >
+                          <Typography
+                            variant="body2"
+                            sx={{ fontFamily: 'monospace' }}
+                          >
+                            {tableDetails.path}
+                          </Typography>
+                          {tableDetails.pathIsRelative && (
+                            <Typography
+                              variant="caption"
+                              color="text.secondary"
+                            >
+                              (relative)
+                            </Typography>
+                          )}
                         </TableCell>
                       </TableRow>
                     )}
@@ -458,7 +475,11 @@ export const DataLakeTableDetails: React.FC = () => {
                           <TableCell>
                             <Typography
                               variant="body2"
-                              sx={{ fontFamily: 'monospace' }}
+                              sx={{
+                                fontFamily: 'monospace',
+                                wordBreak: 'break-all',
+                                overflowWrap: 'anywhere',
+                              }}
                             >
                               {file.path}
                             </Typography>

From 16d7136bade259132d6ec583791487fa29318e02 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 12:10:23 +0100
Subject: [PATCH 02/21] refactor(datalake): implement "Refresh" functionality
 in DataLake and consolidate instance types

- Implement "Refresh" functionality in DataLake details to manually invalidate cache for tables and health status.
- Centralize [DuckLakeInstance] interface in [src/types/duckLake.ts] and merge hydrated UI properties (health, stats).
- Refactor [DataLakeInstanceDetails] and [DataLakeSidebar] to use the shared central interface.
- Standardize runtime configuration access to handle both `runtime` and `runtimeOptions` properties.
---
 .../dataLake/DataLakeInstanceDetails.tsx      | 82 ++++++++-----------
 .../components/dataLake/DataLakeSidebar.tsx   |  8 +-
 .../components/dataLake/DataLakeTables.tsx    |  2 +-
 src/types/duckLake.ts                         | 14 +++-
 4 files changed, 48 insertions(+), 58 deletions(-)

diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index 4c0bb9e..9aa3492 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -1,4 +1,5 @@
 import React, { useState } from 'react';
+import { useQueryClient } from 'react-query';
 import {
   Box,
   Typography,
@@ -36,6 +37,7 @@ import {
   Security,
   Speed,
   Memory,
+  Refresh,
 } from '@mui/icons-material';
 import { useNavigate } from 'react-router-dom';
 import moment from 'moment';
@@ -47,50 +49,9 @@ import {
 import {
   useRefreshDuckLakeInstanceHealth,
   useDuckLakeInstanceHealth,
+  duckLakeKeys,
 } from '../../controllers/duckLake.controller';
-import { DuckLakeStorageConfig } from '../../../types/duckLake';
-
-interface DuckLakeInstance {
-  id: string;
-  name: string;
-  status: 'active' | 'inactive' | 'error';
-  dataPath: string;
-  storage?: DuckLakeStorageConfig;
-  catalog: {
-    type: 'duckdb' | 'sqlite' | 'postgresql';
-    duckdb?: { metadataPath: string };
-    sqlite?: { metadataPath: string };
-    postgresql?: {
-      host: string;
-      port: number;
-      database: string;
-      username: string;
-      ssl: boolean;
-    };
-  };
-  runtime?: {
-    maxMemory?: string;
-    threads?: number;
-    enableOptimizer?: boolean;
-    tempDirectory?: string;
-  };
-  createdAt: string;
-  updatedAt: string;
-  description?: string;
-  health?: {
-    catalogConnected: boolean;
-    dataPathAccessible: boolean;
-    extensionLoaded: boolean;
-    lastChecked: string;
-    error?: string;
-  };
-  stats?: {
-    tableCount: number;
-    totalSize: number;
-    lastQuery: string;
-    queryCount: number;
-  };
-}
+import { DuckLakeInstance } from '../../../types/duckLake';
 
 interface DuckLakeInstanceDetailsProps {
   instance: DuckLakeInstance;
@@ -103,6 +64,7 @@ export const DataLakeInstanceDetails: React.FC<
   DuckLakeInstanceDetailsProps
 > = ({ instance, onEdit, onDelete, isLoading = false }) => {
   const navigate = useNavigate();
+  const queryClient = useQueryClient();
   const [currentTab, setCurrentTab] = useState(0);
   const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
 
@@ -155,6 +117,13 @@ export const DataLakeInstanceDetails: React.FC<
     testConnectionMutation.mutate(instance.id);
   };
 
+  const handleRefresh = () => {
+    // Invalidate tables and health status for this instance
+    queryClient.invalidateQueries(duckLakeKeys.tables(instance.id));
+    queryClient.invalidateQueries(duckLakeKeys.instanceHealth(instance.id));
+    queryClient.invalidateQueries(duckLakeKeys.instance(instance.id));
+  };
+
   const isStorageHealthy = (value?: boolean) =>
     typeof value !== 'boolean' || value;
 
@@ -661,7 +630,7 @@ export const DataLakeInstanceDetails: React.FC<
         </Grid>
 
         {/* Runtime Configuration */}
-        {instance.runtime && (
+        {(instance.runtime || instance.runtimeOptions) && (
           <Grid item xs={12}>
             <Paper sx={{ p: 2 }}>
               <Typography
@@ -681,7 +650,9 @@ export const DataLakeInstanceDetails: React.FC<
                         Max Memory
                       </Typography>
                       <Typography variant="body1">
-                        {instance.runtime.maxMemory || 'Default'}
+                        {instance.runtime?.maxMemory ||
+                          instance.runtimeOptions?.maxMemory ||
+                          'Default'}
                       </Typography>
                     </Box>
                   </Box>
@@ -694,7 +665,9 @@ export const DataLakeInstanceDetails: React.FC<
                         Threads
                       </Typography>
                       <Typography variant="body1">
-                        {instance.runtime.threads || 'Auto'}
+                        {instance.runtime?.threads ||
+                          instance.runtimeOptions?.threads ||
+                          'Auto'}
                       </Typography>
                     </Box>
                   </Box>
@@ -707,7 +680,8 @@ export const DataLakeInstanceDetails: React.FC<
                         Optimizer
                       </Typography>
                       <Typography variant="body1">
-                        {instance.runtime.enableOptimizer
+                        {instance.runtime?.enableOptimizer ||
+                        instance.runtimeOptions?.enableOptimizer
                           ? 'Enabled'
                           : 'Disabled'}
                       </Typography>
@@ -730,7 +704,9 @@ export const DataLakeInstanceDetails: React.FC<
                           overflowWrap: 'anywhere',
                         }}
                       >
-                        {instance.runtime.tempDirectory || 'Default'}
+                        {instance.runtime?.tempDirectory ||
+                          instance.runtimeOptions?.tempDirectory ||
+                          'Default'}
                       </Typography>
                     </Box>
                   </Box>
@@ -769,11 +745,19 @@ export const DataLakeInstanceDetails: React.FC<
             {instance.name}
           </Typography>
           <Typography variant="body2" color="text.secondary">
-            DuckLake Instance • {instance.catalog.type.toUpperCase()} Catalog
+            DataLake Instance • {instance.catalog.type.toUpperCase()} Catalog
           </Typography>
         </Box>
 
         <Box sx={{ display: 'flex', gap: 1 }}>
+          <Button
+            variant="outlined"
+            startIcon={<Refresh />}
+            onClick={handleRefresh}
+            disabled={isLoading}
+          >
+            Refresh
+          </Button>
           <Button
             variant="outlined"
             startIcon={<Edit />}
diff --git a/src/renderer/components/dataLake/DataLakeSidebar.tsx b/src/renderer/components/dataLake/DataLakeSidebar.tsx
index 37a7b6e..203aa16 100644
--- a/src/renderer/components/dataLake/DataLakeSidebar.tsx
+++ b/src/renderer/components/dataLake/DataLakeSidebar.tsx
@@ -14,7 +14,7 @@ import { Dashboard, History, Add } from '@mui/icons-material';
 import { NavLink, useLocation, useNavigate } from 'react-router-dom';
 import { SettingsSidebarElement } from '../../screens/settings/settingsElements';
 import { icons } from '../../../../assets';
-import type { DuckLakeInstanceStatus } from '../../../types/duckLake';
+import type { DuckLakeInstance } from '../../../types/duckLake';
 import { DataLakeSVG } from '../sidebar/icons';
 
 export const DataLakeIcon: React.FC<{
@@ -73,11 +73,7 @@ export const dataLakeSidebarElements: SettingsSidebarElement[] = [
 ];
 
 interface DataLakeSidebarProps {
-  instances?: Array<{
-    id: string;
-    name: string;
-    status: DuckLakeInstanceStatus;
-  }>;
+  instances?: DuckLakeInstance[];
 }
 
 export const DataLakeSidebar: React.FC<DataLakeSidebarProps> = ({
diff --git a/src/renderer/components/dataLake/DataLakeTables.tsx b/src/renderer/components/dataLake/DataLakeTables.tsx
index c58f7d5..0025f8d 100644
--- a/src/renderer/components/dataLake/DataLakeTables.tsx
+++ b/src/renderer/components/dataLake/DataLakeTables.tsx
@@ -105,7 +105,7 @@ export const DataLakeTables: React.FC<DuckLakeTablesProps> = ({
         </Box>
         {selectedInstanceId && (
           <Chip
-            label={`ducklakes: ${tables.find((t) => t.instanceId === selectedInstanceId)?.instanceName || selectedInstanceId}`}
+            label={`${tables.find((t) => t.instanceId === selectedInstanceId)?.instanceName || selectedInstanceId}`}
             variant="outlined"
             color="primary"
           />
diff --git a/src/types/duckLake.ts b/src/types/duckLake.ts
index b2f1b28..9f9e9c2 100644
--- a/src/types/duckLake.ts
+++ b/src/types/duckLake.ts
@@ -241,8 +241,8 @@ export interface DuckLakeInstance {
   dataPath: string;
   storage?: DuckLakeStorageConfig;
   catalog: DuckLakeCatalogConfig;
-  createdAt: Date;
-  updatedAt: Date;
+  createdAt: Date | string;
+  updatedAt: Date | string;
   /**
    * Operational status of the instance configuration
    *
@@ -264,6 +264,16 @@ export interface DuckLakeInstance {
   status: DuckLakeInstanceStatus;
   tags?: string[];
   runtimeOptions?: DuckLakeRuntimeOptions;
+  runtime?: DuckLakeRuntimeOptions; // Alias for UI components
+
+  // Hydrated data for UI
+  health?: DuckLakeInstanceHealth;
+  stats?: {
+    tableCount: number;
+    totalSize: number;
+    lastQuery: string;
+    queryCount: number;
+  };
 }
 
 // Snapshot and Time Travel Types

From da1c7d8520c33d4aa80dd52f376b0f2dbf85ff61 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 12:12:20 +0100
Subject: [PATCH 03/21] fix: eslint warning

---
 src/types/duckLake.ts | 46 +++++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/types/duckLake.ts b/src/types/duckLake.ts
index 9f9e9c2..46632bf 100644
--- a/src/types/duckLake.ts
+++ b/src/types/duckLake.ts
@@ -227,6 +227,29 @@ export type DuckLakeInstanceStatus =
   | 'error'
   | 'connecting';
 
+// Health and Status Types
+export interface DuckLakeInstanceMetrics {
+  tableCount: number;
+  totalRows: number;
+  totalSize: number;
+  snapshotCount: number;
+  lastActivity?: Date;
+}
+
+export interface DuckLakeInstanceHealth {
+  instanceId: string;
+  status: DuckLakeInstanceStatus;
+  lastChecked: Date | string;
+  catalogConnected: boolean;
+  extensionLoaded: boolean;
+  dataPathAccessible: boolean;
+  storageConnected?: boolean;
+  storageLocation?: string;
+  errors?: string[];
+  warnings?: string[];
+  metrics?: DuckLakeInstanceMetrics;
+}
+
 export interface DuckLakeRuntimeOptions {
   maxMemory?: string;
   threads?: number;
@@ -386,29 +409,6 @@ export interface DuckLakeQueryResult {
   snapshotId?: string;
 }
 
-// Health and Status Types
-export interface DuckLakeInstanceMetrics {
-  tableCount: number;
-  totalRows: number;
-  totalSize: number;
-  snapshotCount: number;
-  lastActivity?: Date;
-}
-
-export interface DuckLakeInstanceHealth {
-  instanceId: string;
-  status: DuckLakeInstanceStatus;
-  lastChecked: Date;
-  catalogConnected: boolean;
-  extensionLoaded: boolean;
-  dataPathAccessible: boolean;
-  storageConnected?: boolean;
-  storageLocation?: string;
-  errors?: string[];
-  warnings?: string[];
-  metrics?: DuckLakeInstanceMetrics;
-}
-
 // Configuration and Settings Types
 export interface DuckLakeMaintenanceSchedule {
   enabled: boolean;

From 6a42cf5f4d14ee7a038d2c4aa7e533c6ab1095f7 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 13:56:17 +0100
Subject: [PATCH 04/21] feat(datalake): implement snapshot pagination, robust
 csv import, and table sorting

- Implement server-side pagination and filtering for instance snapshot history across DuckDB, SQLite, and PostgreSQL adapters
- Add search functionality and MUI TablePagination to the Instance History tab for efficient browsing of large snapshot sets
- Enhance CSV import robustness in DataLakeTableImportWizard by using `read_csv_auto` with `ignore_errors=true` and `null_padding=true`
- Implement frontend sorting for DataLake tables to display the most recently created tables at the top
- Update DuckDB adapter to fetch actual table creation timestamps by joining with snapshot metadata
- Populate "Last Accessed" column in table lists using the `updatedAt` timestamp
- Refine History tab UI with a minimal search bar design and fixed placeholder truncation
---
 src/main/ipcHandlers/duckLake.ipcHandlers.ts  |  14 ++
 src/main/services/duckLake.service.ts         |  21 ++
 .../duckLake/adapters/base.adapter.ts         |  11 +
 .../duckLake/adapters/duckdb.adapter.ts       | 192 +++++++++++++++++-
 .../duckLake/adapters/postgresql.adapter.ts   | 165 ++++++++++++++-
 .../duckLake/adapters/sqlite.adapter.ts       | 167 ++++++++++++++-
 .../dataLake/DataLakeInstanceDetails.tsx      | 158 +++++++++++++-
 .../dataLake/DataLakeTableDetails.tsx         |   4 -
 .../dataLake/DataLakeTableImportWizard.tsx    |  21 +-
 .../components/dataLake/DataLakeTables.tsx    |  17 +-
 .../dataLake/DataLakeTablesView.tsx           |   1 +
 .../controllers/duckLake.controller.ts        |  16 ++
 src/renderer/services/duckLake.service.ts     |  14 ++
 src/types/duckLake.ts                         |  26 ++-
 src/types/ipc.ts                              |   1 +
 15 files changed, 792 insertions(+), 36 deletions(-)

diff --git a/src/main/ipcHandlers/duckLake.ipcHandlers.ts b/src/main/ipcHandlers/duckLake.ipcHandlers.ts
index a1e1524..57defb9 100644
--- a/src/main/ipcHandlers/duckLake.ipcHandlers.ts
+++ b/src/main/ipcHandlers/duckLake.ipcHandlers.ts
@@ -104,6 +104,20 @@ const registerDuckLakeHandlers = () => {
     },
   );
 
+  ipcMain.handle(
+    'ducklake:instance:listSnapshots',
+    async (_event, instanceId: string, params: any) => {
+      console.log(
+        '[DuckLake IPC] Handling ducklake:instance:listSnapshots for:',
+        instanceId,
+        params,
+      );
+      // Ensure params has defaults if missing (though Service also defaults)
+      const listParams = params || { page: 1, pageSize: 100 };
+      return DuckLakeService.listInstanceSnapshots(instanceId, listParams);
+    },
+  );
+
   ipcMain.handle(
     'ducklake:snapshot:restore',
     async (
diff --git a/src/main/services/duckLake.service.ts b/src/main/services/duckLake.service.ts
index 65a7eb0..26a0c81 100644
--- a/src/main/services/duckLake.service.ts
+++ b/src/main/services/duckLake.service.ts
@@ -17,12 +17,15 @@ import {
   DuckLakeInstanceHealth,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryRequest,
   DuckLakeQueryResult,
   DuckLakeMaintenanceTask,
   DuckLakeCatalogConfig,
   DuckLakeMaintenanceType,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../types/duckLake';
 import { DuckLakeError } from '../../types/duckLakeErrors';
 
@@ -563,6 +566,24 @@ export default class DuckLakeService {
     }
   }
 
+  static async listInstanceSnapshots(
+    instanceId: string,
+    params: DuckLakeSnapshotParams = { page: 1, pageSize: 100 },
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>> {
+    try {
+      await this.ensureConnected(instanceId);
+      const adapter = await this.getAdapter(instanceId);
+      return await adapter.listInstanceSnapshots(params);
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `[DuckLakeService] Failed to list instance snapshots for ${instanceId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
   static async restoreSnapshot(
     instanceId: string,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
diff --git a/src/main/services/duckLake/adapters/base.adapter.ts b/src/main/services/duckLake/adapters/base.adapter.ts
index 06268c0..cee4b6d 100644
--- a/src/main/services/duckLake/adapters/base.adapter.ts
+++ b/src/main/services/duckLake/adapters/base.adapter.ts
@@ -9,9 +9,12 @@ import {
   DuckLakeInstance,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryResult,
   DuckLakeQueryRequest,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../../../types/duckLake';
 import { generateGCSBearerToken } from '../../../helpers/cloudAuth.helper';
 
@@ -96,6 +99,14 @@ export abstract class CatalogAdapter {
    */
   abstract listSnapshots(tableName: string): Promise<DuckLakeSnapshotInfo[]>;
 
+  /**
+   * Get all snapshots for the entire instance (not table-specific)
+   * Used for instance-wide history view with pagination
+   */
+  abstract listInstanceSnapshots(
+    params: DuckLakeSnapshotParams,
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>>;
+
   /**
    * Get comprehensive table details from DuckLake metadata catalog (Phase 8b)
    * Queries multiple metadata tables to provide complete table information
diff --git a/src/main/services/duckLake/adapters/duckdb.adapter.ts b/src/main/services/duckLake/adapters/duckdb.adapter.ts
index 6a049b9..ee21b56 100644
--- a/src/main/services/duckLake/adapters/duckdb.adapter.ts
+++ b/src/main/services/duckLake/adapters/duckdb.adapter.ts
@@ -16,9 +16,12 @@ import {
   DuckLakeInstance,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryResult,
   DuckLakeQueryRequest,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../../../types/duckLake';
 import { DuckLakeError } from '../../../../types/duckLakeErrors';
 import { normalizeNumericValue } from '../../../../renderer/utils/fileUtils';
@@ -287,10 +290,12 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
           t.table_uuid,
           cs.snapshot_id as current_snapshot,
           ts.record_count,
-          ts.file_size_bytes
+          ts.file_size_bytes,
+          snap.snapshot_time
         FROM ${quotedMetadataDatabase}.main.ducklake_table t
         JOIN ${quotedMetadataDatabase}.main.ducklake_schema s ON t.schema_id = s.schema_id
         LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_table_stats ts ON ts.table_id = t.table_id
+        LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot snap ON snap.snapshot_id = t.begin_snapshot
         CROSS JOIN current_snapshot cs
         WHERE cs.snapshot_id >= t.begin_snapshot
           AND (cs.snapshot_id < t.end_snapshot OR t.end_snapshot IS NULL)
@@ -304,15 +309,24 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
 
       const tables: DuckLakeTableInfo[] = rows.map((row: any) => {
         if (Array.isArray(row)) {
-          const [, tableName, schemaName, , , recordCount, fileSizeBytes] = row;
+          const [
+            ,
+            tableName,
+            schemaName,
+            ,
+            ,
+            recordCount,
+            fileSizeBytes,
+            snapshotTime,
+          ] = row;
           return {
             name: tableName,
             schema: schemaName || 'main',
             instanceId: '',
             columns: [],
             snapshots: [],
-            createdAt: new Date(),
-            updatedAt: new Date(),
+            createdAt: snapshotTime ? new Date(snapshotTime) : new Date(),
+            updatedAt: snapshotTime ? new Date(snapshotTime) : new Date(),
             rowCount: normalizeNumericValue(recordCount),
             sizeBytes: normalizeNumericValue(fileSizeBytes),
           };
@@ -324,8 +338,12 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
           instanceId: '',
           columns: [],
           snapshots: [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
+          createdAt: row.snapshot_time
+            ? new Date(row.snapshot_time)
+            : new Date(),
+          updatedAt: row.snapshot_time
+            ? new Date(row.snapshot_time)
+            : new Date(),
           rowCount: normalizeNumericValue(row.record_count),
           sizeBytes: normalizeNumericValue(row.file_size_bytes),
         };
@@ -548,6 +566,123 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
     }
   }
 
+  async listInstanceSnapshots(
+    params: DuckLakeSnapshotParams,
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>> {
+    try {
+      if (!this.connectionInfo) {
+        throw new Error('No active connection');
+      }
+
+      const { page, pageSize, filter } = params;
+      const offset = (page - 1) * pageSize;
+
+      // Find the DuckLake metadata database
+      const databasesQuery = `
+        SELECT database_name
+        FROM duckdb_databases()
+        WHERE database_name LIKE '__ducklake_metadata_%'
+        LIMIT 1
+      `;
+
+      const databasesResult =
+        await this.connectionInfo.connection.run(databasesQuery);
+      const databaseRows = await databasesResult.getRows();
+
+      if (databaseRows.length === 0) {
+        throw new Error('DuckLake metadata database not found');
+      }
+
+      const metadataDatabase = Array.isArray(databaseRows[0])
+        ? databaseRows[0][0]
+        : (databaseRows[0] as any).database_name;
+
+      // Quote the database name to handle special characters (hyphens, etc.)
+      const quotedMetadataDatabase = `"${metadataDatabase}"`;
+
+      // Build WHERE clause
+      let whereClause = '';
+      if (filter) {
+        // Sanitize filter for simple SQL injection prevention
+        const safeFilter = filter.replace(/'/g, "''");
+        whereClause = `
+          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%'
+             OR sc.changes_made LIKE '%${safeFilter}%'
+        `;
+      }
+
+      // 1. Get Total Count
+      const countQuery = `
+        SELECT COUNT(*) as total
+        FROM ${quotedMetadataDatabase}.main.ducklake_snapshot s
+        LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot_changes sc
+          ON s.snapshot_id = sc.snapshot_id
+        ${whereClause}
+      `;
+
+      const countResult = await this.connectionInfo.connection.run(countQuery);
+      const countRows = await countResult.getRows();
+
+      const totalRaw = Array.isArray(countRows[0])
+        ? countRows[0][0]
+        : countRows[0].total;
+      const total = Number(String(totalRaw));
+
+      // 2. Get Data with Pagination
+      const snapshotsQuery = `
+        SELECT
+          s.snapshot_id,
+          s.snapshot_time,
+          s.schema_version,
+          s.next_catalog_id,
+          s.next_file_id,
+          sc.changes_made
+        FROM ${quotedMetadataDatabase}.main.ducklake_snapshot s
+        LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot_changes sc
+          ON s.snapshot_id = sc.snapshot_id
+        ${whereClause}
+        ORDER BY s.snapshot_id DESC
+        LIMIT ${pageSize} OFFSET ${offset}
+      `;
+
+      const snapshotsResult =
+        await this.connectionInfo.connection.run(snapshotsQuery);
+      const rows = await snapshotsResult.getRows();
+
+      const data = rows.map((row: any) => {
+        if (Array.isArray(row)) {
+          return {
+            snapshotId: row[0],
+            snapshotTime: new Date(row[1]),
+            schemaVersion: row[2],
+            nextCatalogId: row[3],
+            nextFileId: row[4],
+            changesMade: row[5],
+          };
+        }
+        return {
+          snapshotId: row.snapshot_id,
+          snapshotTime: new Date(row.snapshot_time),
+          schemaVersion: row.schema_version,
+          nextCatalogId: row.next_catalog_id,
+          nextFileId: row.next_file_id,
+          changesMade: row.changes_made,
+        };
+      });
+
+      return {
+        data,
+        total,
+        page,
+        pageSize,
+      };
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to list instance snapshots:', error);
+      throw error;
+    }
+  }
+
   /**
    * Get comprehensive table details from DuckLake metadata catalog (Phase 8b)
    * Queries multiple metadata tables to provide complete table information
@@ -952,8 +1087,49 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
         console.debug('No partition info found for table:', tableName);
       }
 
-      // 7. Get snapshots
+      // 7. Get table-specific snapshots using CTE
       const snapshotsQuery = `
+        WITH table_snapshots AS (
+          -- Snapshot when table was created
+          SELECT t.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_table t
+          WHERE t.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshot when table was deleted (if applicable)
+          SELECT t.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_table t
+          WHERE t.table_id = ${tableId} AND t.end_snapshot IS NOT NULL
+          
+          UNION
+          
+          -- Snapshots when columns were added/modified
+          SELECT c.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_column c
+          WHERE c.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshots when columns were dropped
+          SELECT c.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_column c
+          WHERE c.table_id = ${tableId} AND c.end_snapshot IS NOT NULL
+          
+          UNION
+          
+          -- Snapshots when data files were added
+          SELECT df.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_data_file df
+          WHERE df.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshots when data files were deleted
+          SELECT df.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_data_file df
+          WHERE df.table_id = ${tableId} AND df.end_snapshot IS NOT NULL
+        )
         SELECT
           s.snapshot_id,
           s.snapshot_time,
@@ -962,10 +1138,10 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
           s.next_file_id,
           sc.changes_made
         FROM ${quotedMetadataDatabase}.main.ducklake_snapshot s
+        INNER JOIN table_snapshots ts ON s.snapshot_id = ts.snapshot_id
         LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot_changes sc
           ON s.snapshot_id = sc.snapshot_id
         ORDER BY s.snapshot_id DESC
-        LIMIT 50
       `;
 
       const snapshotsResult =
diff --git a/src/main/services/duckLake/adapters/postgresql.adapter.ts b/src/main/services/duckLake/adapters/postgresql.adapter.ts
index 8382b35..95e1ac8 100644
--- a/src/main/services/duckLake/adapters/postgresql.adapter.ts
+++ b/src/main/services/duckLake/adapters/postgresql.adapter.ts
@@ -14,9 +14,12 @@ import {
   DuckLakeInstance,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryResult,
   DuckLakeQueryRequest,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../../../types/duckLake';
 import { DuckLakeError } from '../../../../types/duckLakeErrors';
 import { normalizeNumericValue } from '../../../../renderer/utils/fileUtils';
@@ -533,6 +536,121 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
     }
   }
 
+  async listInstanceSnapshots(
+    params: DuckLakeSnapshotParams,
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>> {
+    try {
+      if (!this.connectionInfo) {
+        throw new Error('No active connection');
+      }
+
+      const { page, pageSize, filter } = params;
+      const offset = (page - 1) * pageSize;
+
+      // Find the DuckLake metadata database
+      const databasesQuery = `
+        SELECT database_name
+        FROM duckdb_databases()
+        WHERE database_name LIKE '__ducklake_metadata_%'
+        LIMIT 1
+      `;
+
+      const databasesResult =
+        await this.connectionInfo.connection.run(databasesQuery);
+      const databaseRows = await databasesResult.getRows();
+
+      if (databaseRows.length === 0) {
+        throw new Error('DuckLake metadata database not found');
+      }
+
+      const metadataDatabase = Array.isArray(databaseRows[0])
+        ? databaseRows[0][0]
+        : (databaseRows[0] as any).database_name;
+
+      const quotedMetadataDatabase = `"${metadataDatabase}"`;
+
+      // Build WHERE clause
+      let whereClause = '';
+      if (filter) {
+        const safeFilter = filter.replace(/'/g, "''");
+        whereClause = `
+          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%'
+             OR sc.changes_made LIKE '%${safeFilter}%'
+        `;
+      }
+
+      // 1. Get Total Count
+      const countQuery = `
+        SELECT COUNT(*) as total
+        FROM ${quotedMetadataDatabase}.ducklake_snapshot s
+        LEFT JOIN ${quotedMetadataDatabase}.ducklake_snapshot_changes sc
+          ON s.snapshot_id = sc.snapshot_id
+        ${whereClause}
+      `;
+
+      const countResult = await this.connectionInfo.connection.run(countQuery);
+      const countRows = await countResult.getRows();
+
+      const totalRaw = Array.isArray(countRows[0])
+        ? countRows[0][0]
+        : countRows[0].total;
+      const total = Number(String(totalRaw));
+
+      // 2. Get Data with Pagination
+      const snapshotsQuery = `
+        SELECT
+          s.snapshot_id,
+          s.snapshot_time,
+          s.schema_version,
+          s.next_catalog_id,
+          s.next_file_id,
+          sc.changes_made
+        FROM ${quotedMetadataDatabase}.ducklake_snapshot s
+        LEFT JOIN ${quotedMetadataDatabase}.ducklake_snapshot_changes sc
+          ON s.snapshot_id = sc.snapshot_id
+        ${whereClause}
+        ORDER BY s.snapshot_id DESC
+        LIMIT ${pageSize} OFFSET ${offset}
+      `;
+
+      const snapshotsResult =
+        await this.connectionInfo.connection.run(snapshotsQuery);
+      const rows = await snapshotsResult.getRows();
+
+      const data = rows.map((row: any) => {
+        if (Array.isArray(row)) {
+          return {
+            snapshotId: row[0],
+            snapshotTime: new Date(row[1]),
+            schemaVersion: row[2],
+            nextCatalogId: row[3],
+            nextFileId: row[4],
+            changesMade: row[5],
+          };
+        }
+        return {
+          snapshotId: row.snapshot_id,
+          snapshotTime: new Date(row.snapshot_time),
+          schemaVersion: row.schema_version,
+          nextCatalogId: row.next_catalog_id,
+          nextFileId: row.next_file_id,
+          changesMade: row.changes_made,
+        };
+      });
+
+      return {
+        data,
+        total,
+        page,
+        pageSize,
+      };
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to list instance snapshots:', error);
+      throw error;
+    }
+  }
+
   /**
    * Get comprehensive table details from DuckLake metadata catalog (Phase 8b)
    * Queries multiple metadata tables to provide complete table information
@@ -937,20 +1055,61 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
         console.debug('No partition info found for table:', tableName);
       }
 
-      // 7. Get snapshots
+      // 7. Get table-specific snapshots using CTE
       const snapshotsQuery = `
+        WITH table_snapshots AS (
+          -- Snapshot when table was created
+          SELECT t.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.ducklake_table t
+          WHERE t.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshot when table was deleted (if applicable)
+          SELECT t.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.ducklake_table t
+          WHERE t.table_id = ${tableId} AND t.end_snapshot IS NOT NULL
+          
+          UNION
+          
+          -- Snapshots when columns were added/modified
+          SELECT c.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.ducklake_column c
+          WHERE c.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshots when columns were dropped
+          SELECT c.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.ducklake_column c
+          WHERE c.table_id = ${tableId} AND c.end_snapshot IS NOT NULL
+          
+          UNION
+          
+          -- Snapshots when data files were added
+          SELECT df.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.ducklake_data_file df
+          WHERE df.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshots when data files were deleted
+          SELECT df.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.ducklake_data_file df
+          WHERE df.table_id = ${tableId} AND df.end_snapshot IS NOT NULL
+        )
         SELECT
           s.snapshot_id,
           s.snapshot_time,
           s.schema_version,
           s.next_catalog_id,
           s.next_file_id,
-          sc.changes_made,
+          sc.changes_made
         FROM ${quotedMetadataDatabase}.ducklake_snapshot s
+        INNER JOIN table_snapshots ts ON s.snapshot_id = ts.snapshot_id
         LEFT JOIN ${quotedMetadataDatabase}.ducklake_snapshot_changes sc
           ON s.snapshot_id = sc.snapshot_id
         ORDER BY s.snapshot_id DESC
-        LIMIT 50
       `;
 
       const snapshotsResult =
diff --git a/src/main/services/duckLake/adapters/sqlite.adapter.ts b/src/main/services/duckLake/adapters/sqlite.adapter.ts
index bfbf978..818906d 100644
--- a/src/main/services/duckLake/adapters/sqlite.adapter.ts
+++ b/src/main/services/duckLake/adapters/sqlite.adapter.ts
@@ -16,9 +16,12 @@ import {
   DuckLakeInstance,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryResult,
   DuckLakeQueryRequest,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../../../types/duckLake';
 import { DuckLakeError } from '../../../../types/duckLakeErrors';
 import { normalizeNumericValue } from '../../../../renderer/utils/fileUtils';
@@ -512,6 +515,125 @@ export class SQLiteCatalogAdapter extends CatalogAdapter {
     }
   }
 
+  async listInstanceSnapshots(
+    params: DuckLakeSnapshotParams,
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>> {
+    try {
+      if (!this.connectionInfo) {
+        throw new Error('No active connection');
+      }
+
+      const { page, pageSize, filter } = params;
+      const offset = (page - 1) * pageSize;
+
+      // Find the DuckLake metadata database
+      const databasesQuery = `
+        SELECT database_name
+        FROM duckdb_databases()
+        WHERE database_name LIKE '__ducklake_metadata_%'
+        LIMIT 1
+      `;
+
+      const databasesResult =
+        await this.connectionInfo.connection.run(databasesQuery);
+      const databaseRows = await databasesResult.getRows();
+
+      if (databaseRows.length === 0) {
+        throw new Error('DuckLake metadata database not found');
+      }
+
+      const metadataDatabase = Array.isArray(databaseRows[0])
+        ? databaseRows[0][0]
+        : (databaseRows[0] as any).database_name;
+
+      // Quote the database name
+      const quotedMetadataDatabase = `"${metadataDatabase}"`;
+
+      // Build WHERE clause
+      let whereClause = '';
+      if (filter) {
+        // Sanitize filter for simple SQL injection prevention (basic)
+        // In real implementations, use bound parameters if possible, but DuckDB Node bindings might differ
+        // For text search in snapshots
+        const safeFilter = filter.replace(/'/g, "''");
+        whereClause = `
+          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%'
+             OR sc.changes_made LIKE '%${safeFilter}%'
+        `;
+      }
+
+      // 1. Get Total Count
+      const countQuery = `
+        SELECT COUNT(*) as total
+        FROM ${quotedMetadataDatabase}.main.ducklake_snapshot s
+        LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot_changes sc
+          ON s.snapshot_id = sc.snapshot_id
+        ${whereClause}
+      `;
+
+      const countResult = await this.connectionInfo.connection.run(countQuery);
+      const countRows = await countResult.getRows();
+      // Handle count result safely for BigInt/Number
+      const totalRaw = Array.isArray(countRows[0])
+        ? countRows[0][0]
+        : countRows[0].total;
+      const total = Number(String(totalRaw));
+
+      // 2. Get Data with Pagination
+      const snapshotsQuery = `
+        SELECT
+          s.snapshot_id,
+          s.snapshot_time,
+          s.schema_version,
+          s.next_catalog_id,
+          s.next_file_id,
+          sc.changes_made
+        FROM ${quotedMetadataDatabase}.main.ducklake_snapshot s
+        LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot_changes sc
+          ON s.snapshot_id = sc.snapshot_id
+        ${whereClause}
+        ORDER BY s.snapshot_id DESC
+        LIMIT ${pageSize} OFFSET ${offset}
+      `;
+
+      const snapshotsResult =
+        await this.connectionInfo.connection.run(snapshotsQuery);
+      const rows = await snapshotsResult.getRows();
+
+      const data = rows.map((row: any) => {
+        if (Array.isArray(row)) {
+          return {
+            snapshotId: row[0],
+            snapshotTime: new Date(row[1]),
+            schemaVersion: row[2],
+            nextCatalogId: row[3],
+            nextFileId: row[4],
+            changesMade: row[5],
+          };
+        }
+        return {
+          snapshotId: row.snapshot_id,
+          snapshotTime: new Date(row.snapshot_time),
+          schemaVersion: row.schema_version,
+          nextCatalogId: row.next_catalog_id,
+          nextFileId: row.next_file_id,
+          changesMade: row.changes_made,
+        };
+      });
+
+      return {
+        data,
+        total,
+        page,
+        pageSize,
+      };
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to list instance snapshots:', error);
+      throw error;
+    }
+  }
+
   /**
    * Get comprehensive table details from DuckLake metadata catalog (Phase 8b)
    * Queries multiple metadata tables to provide complete table information
@@ -916,8 +1038,49 @@ export class SQLiteCatalogAdapter extends CatalogAdapter {
         console.debug('No partition info found for table:', tableName);
       }
 
-      // 7. Get snapshots
+      // 7. Get table-specific snapshots using CTE
       const snapshotsQuery = `
+        WITH table_snapshots AS (
+          -- Snapshot when table was created
+          SELECT t.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_table t
+          WHERE t.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshot when table was deleted (if applicable)
+          SELECT t.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_table t
+          WHERE t.table_id = ${tableId} AND t.end_snapshot IS NOT NULL
+          
+          UNION
+          
+          -- Snapshots when columns were added/modified
+          SELECT c.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_column c
+          WHERE c.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshots when columns were dropped
+          SELECT c.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_column c
+          WHERE c.table_id = ${tableId} AND c.end_snapshot IS NOT NULL
+          
+          UNION
+          
+          -- Snapshots when data files were added
+          SELECT df.begin_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_data_file df
+          WHERE df.table_id = ${tableId}
+          
+          UNION
+          
+          -- Snapshots when data files were deleted
+          SELECT df.end_snapshot as snapshot_id
+          FROM ${quotedMetadataDatabase}.main.ducklake_data_file df
+          WHERE df.table_id = ${tableId} AND df.end_snapshot IS NOT NULL
+        )
         SELECT
           s.snapshot_id,
           s.snapshot_time,
@@ -926,10 +1089,10 @@ export class SQLiteCatalogAdapter extends CatalogAdapter {
           s.next_file_id,
           sc.changes_made
         FROM ${quotedMetadataDatabase}.main.ducklake_snapshot s
+        INNER JOIN table_snapshots ts ON s.snapshot_id = ts.snapshot_id
         LEFT JOIN ${quotedMetadataDatabase}.main.ducklake_snapshot_changes sc
           ON s.snapshot_id = sc.snapshot_id
         ORDER BY s.snapshot_id DESC
-        LIMIT 50
       `;
 
       const snapshotsResult =
diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index 9aa3492..7ec5a25 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -21,6 +21,15 @@ import {
   Card,
   CardContent,
   LinearProgress,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableRow,
+  TablePagination,
+  TextField,
+  InputAdornment,
 } from '@mui/material';
 import {
   Dataset as Database,
@@ -38,6 +47,7 @@ import {
   Speed,
   Memory,
   Refresh,
+  Search,
 } from '@mui/icons-material';
 import { useNavigate } from 'react-router-dom';
 import moment from 'moment';
@@ -50,8 +60,12 @@ import {
   useRefreshDuckLakeInstanceHealth,
   useDuckLakeInstanceHealth,
   duckLakeKeys,
+  useDuckLakeInstanceSnapshots,
 } from '../../controllers/duckLake.controller';
-import { DuckLakeInstance } from '../../../types/duckLake';
+import {
+  DuckLakeInstance,
+  DuckLakeSnapshotDetail,
+} from '../../../types/duckLake';
 
 interface DuckLakeInstanceDetailsProps {
   instance: DuckLakeInstance;
@@ -71,8 +85,29 @@ export const DataLakeInstanceDetails: React.FC<
   // Use the health check mutation for test connection
   const testConnectionMutation = useRefreshDuckLakeInstanceHealth();
 
+  // Snapshot Pagination State
+  const [snapshotPage, setSnapshotPage] = useState(0);
+  const [snapshotRowsPerPage, setSnapshotRowsPerPage] = useState(10);
+  const [snapshotFilter, setSnapshotFilter] = useState('');
+
   // Fetch health data for this instance
   const healthQuery = useDuckLakeInstanceHealth(instance.id);
+  const snapshotsQuery = useDuckLakeInstanceSnapshots(instance.id, {
+    page: snapshotPage + 1,
+    pageSize: snapshotRowsPerPage,
+    filter: snapshotFilter,
+  });
+
+  const handleChangePage = (_event: unknown, newPage: number) => {
+    setSnapshotPage(newPage);
+  };
+
+  const handleChangeRowsPerPage = (
+    event: React.ChangeEvent<HTMLInputElement>,
+  ) => {
+    setSnapshotRowsPerPage(parseInt(event.target.value, 10));
+    setSnapshotPage(0);
+  };
 
   const getStatusIcon = (status: string) => {
     switch (status) {
@@ -719,6 +754,25 @@ export const DataLakeInstanceDetails: React.FC<
     </Box>
   );
 
+  /**
+   * Safely convert any value to string for React rendering
+   * Handles DuckDB hugeint objects and other non-primitive types
+   */
+  const safeToString = (value: any): string => {
+    if (value === null || value === undefined) {
+      return '-';
+    }
+    if (typeof value === 'object') {
+      // Handle DuckDB hugeint objects
+      if (value.hugeint !== undefined) {
+        return String(value.hugeint);
+      }
+      // Handle other objects
+      return JSON.stringify(value);
+    }
+    return String(value);
+  };
+
   return (
     <Box sx={{ p: 2 }}>
       {/* Header */}
@@ -789,6 +843,7 @@ export const DataLakeInstanceDetails: React.FC<
           >
             <Tab label="Tables" />
             <Tab label="Overview" />
+            <Tab label="History" />
             <Tab label="Activity" />
           </Tabs>
         </Box>
@@ -796,9 +851,108 @@ export const DataLakeInstanceDetails: React.FC<
           {currentTab === 0 && <DataLakeTablesView instanceId={instance.id} />}
           {currentTab === 1 && renderOverviewTab()}
           {currentTab === 2 && (
+            <Box sx={{ mt: 1 }}>
+              <Box sx={{ display: 'flex', justifyContent: 'flex-end', mb: 1 }}>
+                <TextField
+                  size="small"
+                  placeholder="Search snapshots (ID or changes)..."
+                  value={snapshotFilter}
+                  onChange={(e) => setSnapshotFilter(e.target.value)}
+                  InputProps={{
+                    startAdornment: (
+                      <InputAdornment position="start">
+                        <Search fontSize="small" />
+                      </InputAdornment>
+                    ),
+                    sx: { fontSize: '0.8125rem', height: '32px' },
+                  }}
+                  sx={{
+                    width: 300,
+                    '& .MuiInputBase-input': {
+                      paddingTop: '2px', // Very small padding for minimal height
+                      paddingBottom: '2px',
+                    },
+                    '& .MuiOutlinedInput-root': {
+                      minHeight: '32px', // Force minimal height
+                    },
+                  }}
+                />
+              </Box>
+
+              {snapshotsQuery.isLoading && <LinearProgress />}
+
+              {!snapshotsQuery.isLoading &&
+                snapshotsQuery.data &&
+                snapshotsQuery.data.data.length > 0 && (
+                  <>
+                    <TableContainer>
+                      <Table size="small">
+                        <TableHead>
+                          <TableRow>
+                            <TableCell>Snapshot ID</TableCell>
+                            <TableCell>Time</TableCell>
+                            <TableCell>Schema Version</TableCell>
+                            <TableCell>Changes</TableCell>
+                          </TableRow>
+                        </TableHead>
+                        <TableBody>
+                          {snapshotsQuery.data.data.map(
+                            (snapshot: DuckLakeSnapshotDetail) => (
+                              <TableRow key={safeToString(snapshot.snapshotId)}>
+                                <TableCell>
+                                  <Chip
+                                    label={safeToString(snapshot.snapshotId)}
+                                    size="small"
+                                    color="primary"
+                                  />
+                                </TableCell>
+                                <TableCell>
+                                  {moment(snapshot.snapshotTime).format(
+                                    'YYYY-MM-DD HH:mm:ss',
+                                  )}
+                                  <Typography
+                                    variant="caption"
+                                    display="block"
+                                    color="text.secondary"
+                                  >
+                                    {moment(snapshot.snapshotTime).fromNow()}
+                                  </Typography>
+                                </TableCell>
+                                <TableCell>
+                                  {safeToString(snapshot.schemaVersion)}
+                                </TableCell>
+                                <TableCell>
+                                  {snapshot.changesMade || '-'}
+                                </TableCell>
+                              </TableRow>
+                            ),
+                          )}
+                        </TableBody>
+                      </Table>
+                    </TableContainer>
+                    <TablePagination
+                      component="div"
+                      count={snapshotsQuery.data.total}
+                      page={snapshotPage}
+                      onPageChange={handleChangePage}
+                      rowsPerPage={snapshotRowsPerPage}
+                      onRowsPerPageChange={handleChangeRowsPerPage}
+                      rowsPerPageOptions={[10, 25, 50, 100]}
+                    />
+                  </>
+                )}
+
+              {!snapshotsQuery.isLoading &&
+                (!snapshotsQuery.data ||
+                  snapshotsQuery.data.data.length === 0) && (
+                  <Alert severity="info">No snapshot history available</Alert>
+                )}
+            </Box>
+          )}
+          {currentTab === 3 && (
             <Box sx={{ mt: 2 }}>
               <Typography variant="body1" color="text.secondary">
-                Activity history coming soon...
+                Activity coming soon...
               </Typography>
             </Box>
           )}
diff --git a/src/renderer/components/dataLake/DataLakeTableDetails.tsx b/src/renderer/components/dataLake/DataLakeTableDetails.tsx
index 993acf6..8208fe1 100644
--- a/src/renderer/components/dataLake/DataLakeTableDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeTableDetails.tsx
@@ -621,9 +621,7 @@ export const DataLakeTableDetails: React.FC = () => {
                       <TableCell>Snapshot ID</TableCell>
                       <TableCell>Time</TableCell>
                       <TableCell>Schema Version</TableCell>
-                      <TableCell>Author</TableCell>
                       <TableCell>Changes</TableCell>
-                      <TableCell>Commit Message</TableCell>
                     </TableRow>
                   </TableHead>
                   <TableBody>
@@ -652,9 +650,7 @@ export const DataLakeTableDetails: React.FC = () => {
                           <TableCell>
                             {safeToString(snapshot.schemaVersion)}
                           </TableCell>
-                          <TableCell>{snapshot.author || '-'}</TableCell>
                           <TableCell>{snapshot.changesMade || '-'}</TableCell>
-                          <TableCell>{snapshot.commitMessage || '-'}</TableCell>
                         </TableRow>
                       ),
                     )}
diff --git a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
index a38cd5b..c7928e9 100644
--- a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
+++ b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
@@ -108,16 +108,17 @@ export const DataLakeTableImportWizard: React.FC<
 
   const handleImport = () => {
     let sourceQuery = '';
-
-    switch (sourceType) {
-      case 'url':
-        sourceQuery = `CREATE TABLE ${tableName} AS FROM '${sourceUrl}'`;
-        break;
-      case 'file':
-        sourceQuery = `CREATE TABLE ${tableName} AS FROM '${filePath}'`;
-        break;
-      default:
-        sourceQuery = '';
+    const src = sourceType === 'url' ? sourceUrl : filePath;
+    const isCsv = src.toLowerCase().endsWith('.csv');
+
+    if (isCsv) {
+      // Use specific CSV reader with error handling options
+      // ignore_errors=true: Skips rows with parsing errors
+      // null_padding=true: Pads missing columns with NULL
+      sourceQuery = `CREATE TABLE ${tableName} AS SELECT * FROM read_csv_auto('${src}', ignore_errors=true, null_padding=true)`;
+    } else {
+      // Default behavior for other formats (Parquet, JSON, etc.)
+      sourceQuery = `CREATE TABLE ${tableName} AS FROM '${src}'`;
     }
 
     onImport(tableName, sourceQuery);
diff --git a/src/renderer/components/dataLake/DataLakeTables.tsx b/src/renderer/components/dataLake/DataLakeTables.tsx
index 0025f8d..ce9bc81 100644
--- a/src/renderer/components/dataLake/DataLakeTables.tsx
+++ b/src/renderer/components/dataLake/DataLakeTables.tsx
@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import {
   Box,
   Card,
@@ -46,9 +46,18 @@ export const DataLakeTables: React.FC<DuckLakeTablesProps> = ({
 }) => {
   const navigate = useNavigate();
 
-  const filteredTables = selectedInstanceId
-    ? tables.filter((table) => table.instanceId === selectedInstanceId)
-    : tables;
+  const filteredTables = useMemo(() => {
+    const result = selectedInstanceId
+      ? tables.filter((table) => table.instanceId === selectedInstanceId)
+      : [...tables];
+
+    // Sort by createdAt descending (newest first)
+    return result.sort((a, b) => {
+      const dateA = new Date(a.createdAt).getTime();
+      const dateB = new Date(b.createdAt).getTime();
+      return dateB - dateA;
+    });
+  }, [tables, selectedInstanceId]);
 
   const formatBytes = (bytes?: number) => {
     if (!bytes) return 'Unknown';
diff --git a/src/renderer/components/dataLake/DataLakeTablesView.tsx b/src/renderer/components/dataLake/DataLakeTablesView.tsx
index 4fae272..ffe2898 100644
--- a/src/renderer/components/dataLake/DataLakeTablesView.tsx
+++ b/src/renderer/components/dataLake/DataLakeTablesView.tsx
@@ -115,6 +115,7 @@ export const DataLakeTablesView: React.FC<DataLakeTablesViewProps> = ({
     schema: table.schema,
     rowCount: table.rowCount,
     sizeBytes: table.sizeBytes,
+    lastAccessed: table.updatedAt?.toISOString(),
     createdAt: table.createdAt?.toISOString() || new Date().toISOString(),
   }));
 
diff --git a/src/renderer/controllers/duckLake.controller.ts b/src/renderer/controllers/duckLake.controller.ts
index 493d42f..54485d4 100644
--- a/src/renderer/controllers/duckLake.controller.ts
+++ b/src/renderer/controllers/duckLake.controller.ts
@@ -1,6 +1,7 @@
 import { useQuery, useMutation, useQueryClient } from 'react-query';
 import { toast } from 'react-toastify';
 import { DuckLakeService } from '../services/duckLake.service';
+import { DuckLakeSnapshotParams } from '../../types/duckLake';
 import { cloudExplorerKeys } from './cloudExplorer.controller';
 
 // Query keys for React Query cache management
@@ -18,6 +19,8 @@ export const duckLakeKeys = {
     [...duckLakeKeys.table(instanceId, tableName), 'details'] as const, // Phase 8b
   snapshots: (instanceId: string, tableName: string) =>
     [...duckLakeKeys.table(instanceId, tableName), 'snapshots'] as const,
+  instanceSnapshots: (instanceId: string, params?: DuckLakeSnapshotParams) =>
+    [...duckLakeKeys.instance(instanceId), 'snapshots', params] as const,
   maintenanceTasks: (instanceId: string) =>
     [...duckLakeKeys.instance(instanceId), 'maintenance'] as const,
   maintenanceTask: (taskId: string) =>
@@ -193,6 +196,19 @@ export function useDuckLakeSnapshots(instanceId: string, tableName: string) {
   });
 }
 
+export function useDuckLakeInstanceSnapshots(
+  instanceId: string,
+  params: DuckLakeSnapshotParams,
+) {
+  return useQuery({
+    queryKey: duckLakeKeys.instanceSnapshots(instanceId, params),
+    queryFn: () => DuckLakeService.listInstanceSnapshots(instanceId, params),
+    enabled: !!instanceId,
+    keepPreviousData: true,
+    staleTime: 30000,
+  });
+}
+
 /**
  * Get comprehensive table details from DuckLake metadata catalog (Phase 8b)
  * Fetches complete table information including schema, statistics, data files, partitions, snapshots, and tags
diff --git a/src/renderer/services/duckLake.service.ts b/src/renderer/services/duckLake.service.ts
index f4948df..3560ca3 100644
--- a/src/renderer/services/duckLake.service.ts
+++ b/src/renderer/services/duckLake.service.ts
@@ -10,11 +10,14 @@ import {
   DuckLakeInstanceHealth,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryRequest,
   DuckLakeQueryResult,
   DuckLakeMaintenanceTask,
   DuckLakeCatalogConfig,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../types/duckLake';
 
 export namespace DuckLakeService {
@@ -152,6 +155,17 @@ export namespace DuckLakeService {
     );
   }
 
+  export async function listInstanceSnapshots(
+    instanceId: string,
+    params?: DuckLakeSnapshotParams,
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>> {
+    return window.electron.ipcRenderer.invoke(
+      'ducklake:instance:listSnapshots',
+      instanceId,
+      params,
+    );
+  }
+
   export async function restoreSnapshot(
     instanceId: string,
     tableName: string,
diff --git a/src/types/duckLake.ts b/src/types/duckLake.ts
index 46632bf..9828fc5 100644
--- a/src/types/duckLake.ts
+++ b/src/types/duckLake.ts
@@ -121,9 +121,6 @@ export interface DuckLakeSnapshotDetail {
   nextCatalogId: number;
   nextFileId: number;
   changesMade?: string;
-  author?: string;
-  commitMessage?: string;
-  commitExtraInfo?: string;
 }
 
 /**
@@ -576,6 +573,12 @@ export interface DuckLakeIpcChannels {
     tableName: string,
   ) => Promise<DuckLakeTableDetails>;
 
+  // Instance Snapshots (Phase: History Fix)
+  'ducklake:instance:listSnapshots': (
+    instanceId: string,
+    params: DuckLakeSnapshotParams,
+  ) => Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>>;
+
   // Cloud Connection Management (Phase: Connection Integration)
   'ducklake:connection:list': () => Promise<any[]>; // Returns CloudConnection[]
   'ducklake:connection:get': (id: string) => Promise<any | null>; // Returns CloudConnection | null
@@ -585,3 +588,20 @@ export interface DuckLakeIpcChannels {
     config: any;
   }) => Promise<boolean>;
 }
+
+// ============================================================================
+// Phase 9: Snapshot Pagination Types
+// ============================================================================
+
+export interface DuckLakeSnapshotParams {
+  page: number;
+  pageSize: number;
+  filter?: string;
+}
+
+export interface DuckLakePaginatedResult<T> {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+}
diff --git a/src/types/ipc.ts b/src/types/ipc.ts
index 7ffe68a..b9c356c 100644
--- a/src/types/ipc.ts
+++ b/src/types/ipc.ts
@@ -262,6 +262,7 @@ export type DuckLakeChannels =
 
   // Snapshot Management
   | 'ducklake:snapshot:list'
+  | 'ducklake:instance:listSnapshots'
   | 'ducklake:snapshot:restore'
 
   // Query Execution

From 5ee4b04c900db73da2f74cb19a800a0b058255e4 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 14:50:14 +0100
Subject: [PATCH 05/21] fix(datalake): fix PostgreSQL connection string
 encoding

Properly encode username, password, and database name in PostgreSQL
connection URLs to handle special characters.
---
 .../duckLake/adapters/postgresql.adapter.ts   | 30 ++++++++++++++-----
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/main/services/duckLake/adapters/postgresql.adapter.ts b/src/main/services/duckLake/adapters/postgresql.adapter.ts
index 95e1ac8..5b3a7f2 100644
--- a/src/main/services/duckLake/adapters/postgresql.adapter.ts
+++ b/src/main/services/duckLake/adapters/postgresql.adapter.ts
@@ -59,14 +59,13 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
       const connectionString = this.buildPostgreSQLConnectionString(pgConfig);
 
       // Attach DuckLake catalog with PostgreSQL backend
+      // We must escape single quotes in the connection string for SQL safety
       const attachString = `ducklake:postgres:${connectionString}`;
+      const escapedAttachString = attachString.replace(/'/g, "''");
 
-      // For S3 storage we expect instance.dataPath to be an s3:// URI such as
-      // s3://adaptivescale/ducklake_nuri/ and rely on httpfs + secret created
-      // via createSecrets above. We just pass through instance.dataPath here.
       await this.attachDuckLakeCatalog(
         connection,
-        attachString,
+        escapedAttachString,
         instance.name,
         instance.dataPath,
       );
@@ -185,10 +184,21 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
       // Test PostgreSQL connection
       const pgConfig = config.postgresql!;
       const connectionString = this.buildPostgreSQLConnectionString(pgConfig);
+      const escapedConnectionString = connectionString.replace(/'/g, "''");
 
-      // Test basic PostgreSQL connection
-      const testQuery = `SELECT 1 FROM postgres_query('${connectionString}', 'SELECT 1 as test')`;
-      await testConnection.run(testQuery);
+      // Test basic PostgreSQL connection using ATTACH (more reliable than postgres_query for testing)
+      const tempAlias = `test_pg_${Date.now()}`;
+      try {
+        await testConnection.run(
+          `ATTACH '${escapedConnectionString}' AS ${tempAlias} (TYPE postgres)`,
+        );
+        await testConnection.run(`DETACH ${tempAlias}`);
+      } catch (err) {
+        // If ATTACH fails, we still try a direct query as a fallback
+        // in case the specific DuckDB version doesn't support ATTACH (TYPE postgres)
+        const testQuery = `SELECT 1 FROM postgres_query('${escapedConnectionString}', 'SELECT 1 as test')`;
+        await testConnection.run(testQuery);
+      }
 
       const responseTime = Date.now() - startTime;
 
@@ -1289,14 +1299,18 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
   private buildPostgreSQLConnectionString(
     config: NonNullable<DuckLakeCatalogConfig['postgresql']>,
   ): string {
+    // For DuckDB's postgres extension, the keyword=value format is often more reliable
+    // across different versions than the URI format.
     const parts = [
-      `dbname=${config.database}`,
       `host=${config.host}`,
       `port=${config.port}`,
       `user=${config.username}`,
+      `dbname=${config.database}`,
     ];
 
     if (config.password) {
+      // For DuckDB's postgres extension, we use the keyword=value format.
+      // We don't need internal quoting here because we escape the whole string in the SQL literals.
       parts.push(`password=${config.password}`);
     }
 

From 1fdcb12064cf95709ae2aa5a377d2d3b36475b7f Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 14:56:52 +0100
Subject: [PATCH 06/21] fix linting

---
 src/main/ipcHandlers/duckLake.ipcHandlers.ts |  5 ----
 src/types/duckLake.ts                        | 30 +++++++++-----------
 2 files changed, 13 insertions(+), 22 deletions(-)

diff --git a/src/main/ipcHandlers/duckLake.ipcHandlers.ts b/src/main/ipcHandlers/duckLake.ipcHandlers.ts
index 57defb9..491314b 100644
--- a/src/main/ipcHandlers/duckLake.ipcHandlers.ts
+++ b/src/main/ipcHandlers/duckLake.ipcHandlers.ts
@@ -107,11 +107,6 @@ const registerDuckLakeHandlers = () => {
   ipcMain.handle(
     'ducklake:instance:listSnapshots',
     async (_event, instanceId: string, params: any) => {
-      console.log(
-        '[DuckLake IPC] Handling ducklake:instance:listSnapshots for:',
-        instanceId,
-        params,
-      );
       // Ensure params has defaults if missing (though Service also defaults)
       const listParams = params || { page: 1, pageSize: 100 };
       return DuckLakeService.listInstanceSnapshots(instanceId, listParams);
diff --git a/src/types/duckLake.ts b/src/types/duckLake.ts
index 9828fc5..2de6b9b 100644
--- a/src/types/duckLake.ts
+++ b/src/types/duckLake.ts
@@ -487,6 +487,19 @@ export interface DuckLakeTableDetails {
   columnTags: DuckLakeColumnTag[];
 }
 
+export interface DuckLakeSnapshotParams {
+  page: number;
+  pageSize: number;
+  filter?: string;
+}
+
+export interface DuckLakePaginatedResult<T> {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+}
+
 // IPC Channel Types (for type-safe IPC communication)
 export interface DuckLakeIpcChannels {
   // Instance Management
@@ -588,20 +601,3 @@ export interface DuckLakeIpcChannels {
     config: any;
   }) => Promise<boolean>;
 }
-
-// ============================================================================
-// Phase 9: Snapshot Pagination Types
-// ============================================================================
-
-export interface DuckLakeSnapshotParams {
-  page: number;
-  pageSize: number;
-  filter?: string;
-}
-
-export interface DuckLakePaginatedResult<T> {
-  data: T[];
-  total: number;
-  page: number;
-  pageSize: number;
-}

From dbe72fe4f87cde24085dbbd5dbf3593098b1e677 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 15:03:42 +0100
Subject: [PATCH 07/21] fix: typescript error

---
 src/main/services/duckLake/instanceStore.service.ts | 10 ++++++++--
 src/renderer/screens/dataLake/index.tsx             | 12 +-----------
 2 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/main/services/duckLake/instanceStore.service.ts b/src/main/services/duckLake/instanceStore.service.ts
index 3ed46a2..ce085fc 100644
--- a/src/main/services/duckLake/instanceStore.service.ts
+++ b/src/main/services/duckLake/instanceStore.service.ts
@@ -437,8 +437,14 @@ export default class DuckLakeInstanceStore {
       dataPath: instance.dataPath,
       storage: storagePersisted,
       catalog: catalogPersisted,
-      createdAt: instance.createdAt.toISOString(),
-      updatedAt: instance.updatedAt.toISOString(),
+      createdAt: (instance.createdAt instanceof Date
+        ? instance.createdAt
+        : new Date(instance.createdAt)
+      ).toISOString(),
+      updatedAt: (instance.updatedAt instanceof Date
+        ? instance.updatedAt
+        : new Date(instance.updatedAt)
+      ).toISOString(),
       status: instance.status,
       tags: instance.tags,
       runtimeOptions: instance.runtimeOptions,
diff --git a/src/renderer/screens/dataLake/index.tsx b/src/renderer/screens/dataLake/index.tsx
index cbdd14c..836e7bb 100644
--- a/src/renderer/screens/dataLake/index.tsx
+++ b/src/renderer/screens/dataLake/index.tsx
@@ -365,17 +365,7 @@ const DataLake: React.FC = () => {
   };
 
   return (
-    <AppLayout
-      sidebarContent={
-        <DataLakeSidebar
-          instances={instances.map((i) => ({
-            id: i.id,
-            name: i.name,
-            status: i.status,
-          }))}
-        />
-      }
-    >
+    <AppLayout sidebarContent={<DataLakeSidebar instances={instances} />}>
       <Box sx={{ p: 2 }}>
         <Box>{renderContent()}</Box>
       </Box>

From 5ad12a235f3dcd68d4c3083eb6751d9b83602666 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Tue, 6 Jan 2026 15:18:14 +0100
Subject: [PATCH 08/21] Fix SQL injection vulnerability in
 DataLakeTableImportWizard by escaping single quotes in source paths

---
 .../components/dataLake/DataLakeTableImportWizard.tsx        | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
index c7928e9..547216e 100644
--- a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
+++ b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
@@ -109,16 +109,17 @@ export const DataLakeTableImportWizard: React.FC<
   const handleImport = () => {
     let sourceQuery = '';
     const src = sourceType === 'url' ? sourceUrl : filePath;
+    const escapedSrc = src.replace(/'/g, "''");
     const isCsv = src.toLowerCase().endsWith('.csv');
 
     if (isCsv) {
       // Use specific CSV reader with error handling options
       // ignore_errors=true: Skips rows with parsing errors
       // null_padding=true: Pads missing columns with NULL
-      sourceQuery = `CREATE TABLE ${tableName} AS SELECT * FROM read_csv_auto('${src}', ignore_errors=true, null_padding=true)`;
+      sourceQuery = `CREATE TABLE ${tableName} AS SELECT * FROM read_csv_auto('${escapedSrc}', ignore_errors=true, null_padding=true)`;
     } else {
       // Default behavior for other formats (Parquet, JSON, etc.)
-      sourceQuery = `CREATE TABLE ${tableName} AS FROM '${src}'`;
+      sourceQuery = `CREATE TABLE ${tableName} AS FROM '${escapedSrc}'`;
     }
 
     onImport(tableName, sourceQuery);

From 5e1daf8cc95cc41f6b503232d0b659f942ec0a80 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Fri, 9 Jan 2026 15:38:23 +0100
Subject: [PATCH 09/21] fix: update editor tabs on file rename and folder
 deletion

- Implemented `renameTab` in [useTabManager] to properly update tab paths and titles when files are renamed.
- Updated `closeTabByPath` to recursively find and close all tabs associated with files inside a deleted directory.
- Added `onRename` callback propagation from [RenderTree] up to [ProjectDetails] to synchronize tab state with file system operations pursuant to rename actions.
- Refactored [RenderTree] to trigger the rename callback upon successful file rename.
---
 .../components/fileTreeViewer/RenderTree.tsx  | 19 +++++-
 .../components/fileTreeViewer/index.tsx       |  3 +
 .../components/sidebar/project-sidebar.tsx    |  6 ++
 src/renderer/hooks/useTabManager.ts           | 59 ++++++++++++++++---
 src/renderer/screens/projectDetails/index.tsx |  7 +++
 5 files changed, 85 insertions(+), 9 deletions(-)

diff --git a/src/renderer/components/fileTreeViewer/RenderTree.tsx b/src/renderer/components/fileTreeViewer/RenderTree.tsx
index cac1c65..0b83ceb 100644
--- a/src/renderer/components/fileTreeViewer/RenderTree.tsx
+++ b/src/renderer/components/fileTreeViewer/RenderTree.tsx
@@ -50,6 +50,7 @@ type Props = {
   copyPathData: string;
   onPastePath: (source: string, target: string) => void;
   selectedPath?: string;
+  onRename?: (oldPath: string, newPath: string) => void;
 };
 
 const getColorByStatus = (status?: string) => {
@@ -85,6 +86,7 @@ const RenderTree: React.FC<Props> = ({
   onPastePath,
   copyPathData,
   selectedPath,
+  onRename,
 }) => {
   const [menuPosition, setMenuPosition] =
     React.useState<null | PopoverPosition>(null);
@@ -113,6 +115,20 @@ const RenderTree: React.FC<Props> = ({
         path: node.path,
         newName,
       });
+      const parentPath = node.path.substring(
+        0,
+        node.path.lastIndexOf(node.name),
+      );
+      const separator = node.path.includes('\\') ? '\\' : '/';
+      const cleanParentPath = parentPath.endsWith(separator)
+        ? parentPath
+        : parentPath + separator;
+      const newPath = cleanParentPath + newName;
+
+      if (typeof onRename === 'function') {
+        onRename(node.path, newPath);
+      }
+
       if (typeof onRefresh === 'function') {
         onRefresh();
       }
@@ -121,7 +137,7 @@ const RenderTree: React.FC<Props> = ({
     } finally {
       setRenameOpen(false);
     }
-  }, [renameValue, node.path, node.name, onRefresh]);
+  }, [renameValue, node.path, node.name, onRefresh, onRename]);
 
   const fileStatus = fileStatuses[node.path];
   const labelColor = getColorByStatus(fileStatus);
@@ -416,6 +432,7 @@ const RenderTree: React.FC<Props> = ({
           onPastePath={onPastePath}
           copyPathData={copyPathData}
           selectedPath={selectedPath}
+          onRename={onRename}
         />
       ))}
     </TreeItem>
diff --git a/src/renderer/components/fileTreeViewer/index.tsx b/src/renderer/components/fileTreeViewer/index.tsx
index 0d54d51..d6f66e7 100644
--- a/src/renderer/components/fileTreeViewer/index.tsx
+++ b/src/renderer/components/fileTreeViewer/index.tsx
@@ -25,6 +25,7 @@ type Props = {
   statuses: FileStatus[];
   copyPath: (source: string, target: string) => Promise<void>;
   selectedPath?: string;
+  onRenameCallback?: (oldPath: string, newPath: string) => void;
 };
 
 const filterTreeAndCollectExpanded = (
@@ -106,6 +107,7 @@ const FileTreeViewer: React.FC<Props> = ({
   statuses,
   copyPath,
   selectedPath,
+  onRenameCallback,
 }) => {
   const { data: project } = useGetSelectedProject();
   const [expandedItems, setExpandedItems] = React.useState<string[]>([]);
@@ -294,6 +296,7 @@ const FileTreeViewer: React.FC<Props> = ({
           onPastePath={(source, target) => copyPath(source, target)}
           copyPathData={copyPathData}
           selectedPath={selectedPath}
+          onRename={onRenameCallback}
         />
       </StyledTreeView>
       {(fileModal || folderModal) && (
diff --git a/src/renderer/components/sidebar/project-sidebar.tsx b/src/renderer/components/sidebar/project-sidebar.tsx
index 70a71f6..02f12e8 100644
--- a/src/renderer/components/sidebar/project-sidebar.tsx
+++ b/src/renderer/components/sidebar/project-sidebar.tsx
@@ -20,6 +20,7 @@ interface ExplorerTabProps {
   onRefreshFiles: () => Promise<void>;
   onCopyPath: (source: string, target: string) => Promise<void>;
   onNewFile: (filePath?: string) => void;
+  onRenameFile?: (oldPath: string, newPath: string) => void;
 }
 
 const ExplorerTab: React.FC<ExplorerTabProps> = ({
@@ -32,6 +33,7 @@ const ExplorerTab: React.FC<ExplorerTabProps> = ({
   onRefreshFiles,
   onCopyPath,
   onNewFile,
+  onRenameFile,
 }) => {
   return (
     <FileTreeContainer>
@@ -46,6 +48,7 @@ const ExplorerTab: React.FC<ExplorerTabProps> = ({
           copyPath={onCopyPath}
           onNewFileCallback={onNewFile}
           selectedPath={selectedFilePath}
+          onRenameCallback={onRenameFile}
         />
       )}
     </FileTreeContainer>
@@ -96,6 +99,7 @@ interface ProjectSidebarProps {
   onRefreshFiles: () => Promise<void>;
   onCopyPath: (source: string, target: string) => Promise<void>;
   onNewFile: (filePath?: string) => void;
+  onRenameFile?: (oldPath: string, newPath: string) => void;
 
   // Source Control tab integration with Monaco editor
   onSourceControlOpenFile?: (filePath: string) => void;
@@ -118,6 +122,7 @@ export const ProjectSidebar: React.FC<ProjectSidebarProps> = ({
   onRefreshFiles,
   onCopyPath,
   onNewFile,
+  onRenameFile,
   onSourceControlOpenFile,
   onSourceControlFileSelect,
   onSourceControlRefreshFileContent,
@@ -272,6 +277,7 @@ export const ProjectSidebar: React.FC<ProjectSidebarProps> = ({
             onRefreshFiles={onRefreshFiles}
             onCopyPath={onCopyPath}
             onNewFile={onNewFile}
+            onRenameFile={onRenameFile}
           />
         )}
 
diff --git a/src/renderer/hooks/useTabManager.ts b/src/renderer/hooks/useTabManager.ts
index 8b32dbc..0818fa4 100644
--- a/src/renderer/hooks/useTabManager.ts
+++ b/src/renderer/hooks/useTabManager.ts
@@ -168,6 +168,7 @@ export interface UseTabManagerReturn {
   reorderTabs: (fromIndex: number, toIndex: number) => void;
   reset: () => void;
   getTabByPath: (path: string) => EditorTabState | undefined;
+  renameTab: (oldPath: string, newPath: string) => void;
   refreshTabContentByPath: (path: string) => Promise<void>;
   // Unsaved changes dialog support
   pendingClose: PendingCloseState | null;
@@ -270,15 +271,41 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
     [performClose],
   );
 
-  const closeTabByPath = React.useCallback(
-    (path: string) => {
-      const targetTab = tabsRef.current.find((tab) => tab.path === path);
-      if (targetTab) {
-        closeTab(targetTab.id);
+  const closeTabByPath = React.useCallback((path: string) => {
+    const currentTabs = tabsRef.current;
+    const tabsToClose = currentTabs.filter(
+      (tab) =>
+        tab.path === path ||
+        tab.path.startsWith(`${path}/`) ||
+        tab.path.startsWith(`${path}\\`),
+    );
+
+    if (tabsToClose.length === 0) {
+      return;
+    }
+
+    const idsToClose = new Set(tabsToClose.map((t) => t.id));
+
+    setTabs((current) => {
+      const nextTabs = current.filter((t) => !idsToClose.has(t.id));
+
+      return nextTabs;
+    });
+
+    setActiveTabId((currentId) => {
+      if (currentId && idsToClose.has(currentId)) {
+        // If the active tab was closed, try to find a neighbor in the remaining tabs.
+        // Since tabs ref might not be updated yet, we derive remaining tabs from current ref.
+        const remaining = tabsRef.current.filter((t) => !idsToClose.has(t.id));
+        if (remaining.length === 0) {
+          return null;
+        }
+        // Fallback to the last available tab, or similar logic to performClose
+        return remaining[remaining.length - 1].id;
       }
-    },
-    [closeTab],
-  );
+      return currentId;
+    });
+  }, []);
 
   const updateTab = React.useCallback(
     (tabId: EditorTabId, updater: (tab: EditorTabState) => EditorTabState) => {
@@ -365,6 +392,21 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
     [markTabSaved],
   );
 
+  const renameTab = React.useCallback((oldPath: string, newPath: string) => {
+    setTabs((current) =>
+      current.map((tab) => {
+        if (tab.path !== oldPath) {
+          return tab;
+        }
+        return {
+          ...tab,
+          path: newPath,
+          title: deriveTitleFromPath(newPath),
+        };
+      }),
+    );
+  }, []);
+
   const reorderTabs = React.useCallback(
     (fromIndex: number, toIndex: number) => {
       setTabs((current) => {
@@ -615,6 +657,7 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
     reorderTabs,
     reset,
     getTabByPath,
+    renameTab,
     refreshTabContentByPath,
     // Unsaved changes dialog support
     pendingClose,
diff --git a/src/renderer/screens/projectDetails/index.tsx b/src/renderer/screens/projectDetails/index.tsx
index 6cb6292..9d0bc34 100644
--- a/src/renderer/screens/projectDetails/index.tsx
+++ b/src/renderer/screens/projectDetails/index.tsx
@@ -110,6 +110,7 @@ const ProjectDetails: React.FC = () => {
     reorderTabs,
     reset,
     getTabByPath,
+    renameTab,
     refreshTabContentByPath,
     // Unsaved changes dialog support
     pendingClose,
@@ -745,6 +746,12 @@ const ProjectDetails: React.FC = () => {
             setSelectedFilePath(filePath);
             openTab(filePath);
           }}
+          onRenameFile={(oldPath, newPath) => {
+            renameTab(oldPath, newPath);
+            if (activeTab?.path === oldPath || selectedFilePath === oldPath) {
+              setSelectedFilePath(newPath);
+            }
+          }}
           // Source Control Monaco Editor Integration
           onSourceControlOpenFile={(filePath: string) => {
             setSelectedFilePath(filePath);

From 0e10cc239ddcdce72c0d3a6d41512f3944077387 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 09:31:35 +0100
Subject: [PATCH 10/21] Fixes issue where:

- Path computation failed when filename appeared multiple times in path (e.g., projects/test/test/file.txt)
---
 .../components/fileTreeViewer/RenderTree.tsx  | 14 ++++----
 src/renderer/hooks/useTabManager.ts           | 32 +++++++++++++++----
 2 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/src/renderer/components/fileTreeViewer/RenderTree.tsx b/src/renderer/components/fileTreeViewer/RenderTree.tsx
index 0b83ceb..1a266fa 100644
--- a/src/renderer/components/fileTreeViewer/RenderTree.tsx
+++ b/src/renderer/components/fileTreeViewer/RenderTree.tsx
@@ -115,15 +115,13 @@ const RenderTree: React.FC<Props> = ({
         path: node.path,
         newName,
       });
-      const parentPath = node.path.substring(
-        0,
-        node.path.lastIndexOf(node.name),
+      const lastSepIndex = Math.max(
+        node.path.lastIndexOf('/'),
+        node.path.lastIndexOf('\\'),
       );
-      const separator = node.path.includes('\\') ? '\\' : '/';
-      const cleanParentPath = parentPath.endsWith(separator)
-        ? parentPath
-        : parentPath + separator;
-      const newPath = cleanParentPath + newName;
+      const parentPath =
+        lastSepIndex > 0 ? node.path.substring(0, lastSepIndex + 1) : '';
+      const newPath = parentPath + newName;
 
       if (typeof onRename === 'function') {
         onRename(node.path, newPath);
diff --git a/src/renderer/hooks/useTabManager.ts b/src/renderer/hooks/useTabManager.ts
index 0818fa4..ebbfd21 100644
--- a/src/renderer/hooks/useTabManager.ts
+++ b/src/renderer/hooks/useTabManager.ts
@@ -395,14 +395,32 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
   const renameTab = React.useCallback((oldPath: string, newPath: string) => {
     setTabs((current) =>
       current.map((tab) => {
-        if (tab.path !== oldPath) {
-          return tab;
+        // Exact match - file rename
+        if (tab.path === oldPath) {
+          return {
+            ...tab,
+            path: newPath,
+            title: deriveTitleFromPath(newPath),
+          };
         }
-        return {
-          ...tab,
-          path: newPath,
-          title: deriveTitleFromPath(newPath),
-        };
+
+        // Check if tab is a child of renamed folder
+        // Normalize paths to ensure proper prefix matching
+        const isChild =
+          tab.path.startsWith(`${oldPath}/`) ||
+          tab.path.startsWith(`${oldPath}\\`);
+
+        if (isChild) {
+          // Replace the old path prefix with the new path
+          const updatedPath = tab.path.replace(oldPath, newPath);
+          return {
+            ...tab,
+            path: updatedPath,
+            title: deriveTitleFromPath(updatedPath),
+          };
+        }
+
+        return tab;
       }),
     );
   }, []);

From 8a16b23f01e7dd7f35bc03fc7e5a8dcc5448634d Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 12:32:04 +0100
Subject: [PATCH 11/21] feat: implement SQL query cancellation and refine
 result UI

- Implement backend query cancellation for Postgres, Redshift, Snowflake, Databricks, and DuckDB
- Create `connector:cancel-query` IPC channel and tracking mechanism for active queries
- Add "Stop Query" button with centered layout in the results pane
- Update [SqlEditor] to generate unique query IDs and handle cancellation flow
- Refactor `QueryResult` styling to ensure success messages are top-aligned and full-width
- Remove redundant `toast.error` calls (errors are now shown inline)
- Fix row count display formatting in query results
---
 .../ipcHandlers/connectors.ipcHandlers.ts     | 19 +++-
 src/main/services/connectors.service.ts       | 94 +++++++++++++++----
 src/main/utils/connectors.ts                  | 62 +++++++++++-
 .../customTable/CustomTableToolbar.tsx        | 48 +++++++---
 src/renderer/components/customTable/index.tsx |  4 +-
 src/renderer/components/customTable/types.ts  |  1 +
 .../components/schemaTreeViewer/index.tsx     | 16 +++-
 src/renderer/components/sqlEditor/index.tsx   | 83 +++++++++++++++-
 .../sqlEditor/queryHistory/index.tsx          | 84 +++++++++++------
 src/renderer/screens/sql/index.tsx            | 49 +++++++++-
 src/renderer/screens/sql/queryResult.tsx      | 85 ++++++++++++++++-
 src/renderer/services/connectors.service.ts   |  7 +-
 src/types/backend.ts                          |  4 +
 src/types/ipc.ts                              |  3 +-
 14 files changed, 475 insertions(+), 84 deletions(-)

diff --git a/src/main/ipcHandlers/connectors.ipcHandlers.ts b/src/main/ipcHandlers/connectors.ipcHandlers.ts
index eba59e6..0439d2c 100644
--- a/src/main/ipcHandlers/connectors.ipcHandlers.ts
+++ b/src/main/ipcHandlers/connectors.ipcHandlers.ts
@@ -1,6 +1,10 @@
 import { ipcMain } from 'electron';
 import { ConnectorsService } from '../services';
-import type { ConnectionInput, QueryResponseType } from '../../types/backend';
+import type {
+  ConnectionInput,
+  QueryResponseType,
+  ExecuteStatementType,
+} from '../../types/backend';
 import { ConfigureConnectionBody, UpdateConnectionBody } from '../../types/ipc';
 import { CloudConnection, RecentItem } from '../../types/frontend';
 
@@ -10,6 +14,7 @@ const handlerChannels = [
   'connector:validate',
   'connector:getJdbcUrl',
   'connector:query',
+  'connector:cancel-query',
   'connector:list',
 ];
 
@@ -67,10 +72,7 @@ const registerConnectorsHandlers = () => {
 
   ipcMain.handle(
     'connector:query',
-    async (
-      _event,
-      body: { connection: ConnectionInput; query: string; projectName: string },
-    ): Promise<QueryResponseType> => {
+    async (_event, body: ExecuteStatementType): Promise<QueryResponseType> => {
       try {
         return ConnectorsService.executeSelectStatement(body);
       } catch (error: any) {
@@ -79,6 +81,13 @@ const registerConnectorsHandlers = () => {
     },
   );
 
+  ipcMain.handle(
+    'connector:cancel-query',
+    async (_event, queryId: string): Promise<void> => {
+      return ConnectorsService.cancelQuery(queryId);
+    },
+  );
+
   ipcMain.handle(
     'connector:setConnectionEnvVariable',
     async (_event, { key, value }: { key: string; value: string }) => {
diff --git a/src/main/services/connectors.service.ts b/src/main/services/connectors.service.ts
index 08809e1..045bffa 100644
--- a/src/main/services/connectors.service.ts
+++ b/src/main/services/connectors.service.ts
@@ -347,6 +347,17 @@ export default class ConnectorsService {
     }
   }
 
+  private static runningQueries = new Map<string, () => void>();
+
+  static async cancelQuery(queryId: string): Promise<void> {
+    const cancelFn = this.runningQueries.get(queryId);
+    if (cancelFn) {
+      // Execute the cancellation function (closes connection/client)
+      cancelFn();
+      this.runningQueries.delete(queryId);
+    }
+  }
+
   /**
    * Run a select statement and expect the results and fields
    */
@@ -354,6 +365,7 @@ export default class ConnectorsService {
     connection,
     query,
     projectName,
+    queryId,
   }: ExecuteStatementType): Promise<QueryResponseType> {
     const storeUser = await SecureStorageService.getCredential(
       `db-user-${projectName}`,
@@ -384,25 +396,71 @@ export default class ConnectorsService {
       (connection as any).keyfile = bigQueryKey;
     }
 
-    switch (connection.type) {
-      case 'postgres':
-        return executePostgresQuery(connection, query);
-      case 'snowflake':
-        return executeSnowflakeQuery(connection, query);
-      case 'bigquery':
-        return executeBigQueryQuery(connection, query);
-      case 'databricks':
-        return executeDatabricksQuery(connection, query);
-      case 'duckdb':
-        return executeDuckDBQuery(connection, query);
-      case 'redshift':
-        return executeRedshiftQuery(connection, query);
-      default:
-        // Use the literal type instead of accessing the property to avoid TypeScript error
-        throw new Error(
-          `Unsupported connection type: ${(connection as any).type}`,
-        );
+    const startTime = Date.now();
+    let response: QueryResponseType;
+
+    // Helper to register cancel callback if queryId is present
+    const registerCancel = queryId
+      ? (fn: () => void) => {
+          this.runningQueries.set(queryId, fn);
+        }
+      : undefined;
+
+    try {
+      switch (connection.type) {
+        case 'postgres':
+          response = await executePostgresQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'snowflake':
+          response = await executeSnowflakeQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'bigquery':
+          // BigQuery cancellation not yet implemented in utils
+          response = await executeBigQueryQuery(connection, query);
+          break;
+        case 'databricks':
+          response = await executeDatabricksQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'duckdb':
+          response = await executeDuckDBQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'redshift':
+          response = await executeRedshiftQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        default:
+          throw new Error(
+            `Unsupported connection type: ${(connection as any).type}`,
+          );
+      }
+    } finally {
+      // Clean up running query registry
+      if (queryId) {
+        this.runningQueries.delete(queryId);
+      }
     }
+
+    response.duration = Date.now() - startTime;
+    return response;
   }
 
   static extractDbNameFromPath = (url: string) => {
diff --git a/src/main/utils/connectors.ts b/src/main/utils/connectors.ts
index 2aee683..3fbc39c 100644
--- a/src/main/utils/connectors.ts
+++ b/src/main/utils/connectors.ts
@@ -70,6 +70,7 @@ export async function testRedshiftConnection(
 export const executePostgresQuery = async (
   config: PostgresConnection,
   query: string,
+  registerCancel?: (fn: () => void) => void,
 ): Promise<QueryResponseType> => {
   const client = new pg.Client({
     host: config.host,
@@ -80,6 +81,12 @@ export const executePostgresQuery = async (
     connectionTimeoutMillis: 5000,
   });
 
+  if (registerCancel) {
+    registerCancel(() => {
+      client.end();
+    });
+  }
+
   try {
     await client.connect();
     const result = await client.query(query);
@@ -99,6 +106,7 @@ export const executePostgresQuery = async (
 export const executeRedshiftQuery = async (
   config: RedshiftConnection,
   query: string,
+  registerCancel?: (fn: () => void) => void,
 ): Promise<QueryResponseType> => {
   const clientConfig: any = {
     host: config.host,
@@ -118,6 +126,12 @@ export const executeRedshiftQuery = async (
 
   const client = new pg.Client(clientConfig);
 
+  if (registerCancel) {
+    registerCancel(() => {
+      client.end();
+    });
+  }
+
   try {
     await client.connect();
     const result = await client.query(query);
@@ -187,9 +201,16 @@ export async function testSnowflakeConnection(
 export const executeSnowflakeQuery = async (
   config: SnowflakeConnection,
   query: string,
+  registerCancel?: (fn: () => void) => void,
 ): Promise<QueryResponseType> => {
   const connection = createSnowflakeConnection(config);
 
+  if (registerCancel) {
+    registerCancel(() => {
+      connection.destroy(() => {});
+    });
+  }
+
   return new Promise((resolve) => {
     connection.connect((err) => {
       if (err) {
@@ -255,8 +276,23 @@ export async function testDatabricksConnection(
 export const executeDatabricksQuery = async (
   config: DatabricksConnection,
   query: string,
+  registerCancel?: (fn: () => void) => void,
 ): Promise<QueryResponseType> => {
   const client = new DBSQLClient();
+  let session: any;
+  let queryOperation: any;
+
+  if (registerCancel) {
+    registerCancel(async () => {
+      try {
+        if (queryOperation) await queryOperation.close();
+        if (session) await session.close();
+        await client.close();
+      } catch (e) {
+        // ignore errors during cancellation
+      }
+    });
+  }
 
   try {
     const connection = await client.connect({
@@ -265,8 +301,8 @@ export const executeDatabricksQuery = async (
       path: config.httpPath,
     });
 
-    const session = await connection.openSession();
-    const queryOperation = await session.executeStatement(query, {
+    session = await connection.openSession();
+    queryOperation = await session.executeStatement(query, {
       runAsync: true,
     });
 
@@ -582,10 +618,32 @@ export async function testDuckDBConnection(
 export const executeDuckDBQuery = async (
   config: DuckDBConnection,
   query: string,
+  registerCancel?: (fn: () => void) => void,
 ): Promise<QueryResponseType> => {
   let instance: any = null;
   let connection: any = null;
 
+  if (registerCancel) {
+    registerCancel(async () => {
+      try {
+        if (connection) {
+          if (typeof connection.close === 'function') await connection.close();
+          else if (typeof connection.closeSync === 'function')
+            connection.closeSync();
+        }
+        if (instance) {
+          if (typeof instance.close === 'function') await instance.close();
+          else if (typeof instance.closeSync === 'function')
+            instance.closeSync();
+          else if (typeof instance.terminate === 'function')
+            await instance.terminate();
+        }
+      } catch (e) {
+        // ignore
+      }
+    });
+  }
+
   try {
     instance = await DuckDBInstance.create(config.database_path);
     connection = await instance.connect();
diff --git a/src/renderer/components/customTable/CustomTableToolbar.tsx b/src/renderer/components/customTable/CustomTableToolbar.tsx
index 18bd0a3..ecf8c70 100644
--- a/src/renderer/components/customTable/CustomTableToolbar.tsx
+++ b/src/renderer/components/customTable/CustomTableToolbar.tsx
@@ -1,5 +1,5 @@
-import React from 'react';
-import { Toolbar, Typography, Tooltip, TextField } from '@mui/material';
+import React, { ReactNode } from 'react';
+import { Toolbar, Typography, Tooltip, TextField, Box } from '@mui/material';
 import { makeStyles } from '@mui/styles';
 
 const useStyles = makeStyles({
@@ -10,34 +10,54 @@ const useStyles = makeStyles({
   title: {
     flex: '1 1 45%',
   },
+  searchContainer: {
+    paddingTop: '4px',
+    paddingBottom: '4px',
+  },
 });
 
 type Props = {
   name: string;
   handleSearch: (keyword: string) => void;
+  toolbarContent?: ReactNode;
 };
 
-const CustomTableToolbar = ({ name, handleSearch }: Props) => {
+const CustomTableToolbar = ({ name, handleSearch, toolbarContent }: Props) => {
   const classes = useStyles();
   return (
     <div>
-      <Toolbar>
-        <Typography
-          className={classes.title}
-          variant="h6"
-          id="tableTitle"
-          component="div"
-        >
-          {name}
-        </Typography>
+      <Toolbar
+        variant="dense"
+        style={{ minHeight: '36px', paddingLeft: '8px', paddingRight: '8px' }}
+      >
+        {name ? (
+          <Typography
+            className={classes.title}
+            variant="h6"
+            id="tableTitle"
+            component="div"
+          >
+            {name}
+          </Typography>
+        ) : (
+          <div className={classes.title} />
+        )}
+
+        {toolbarContent && <Box mr={2}>{toolbarContent}</Box>}
+
         <Tooltip title="Search by name">
           <TextField
             name="search"
-            label="Search"
-            color="primary"
+            placeholder="Search..."
+            variant="outlined"
+            size="small"
+            className={classes.searchContainer}
             onChange={(event) => {
               handleSearch(event.target.value);
             }}
+            InputProps={{
+              style: { height: 32, fontSize: '0.875rem' },
+            }}
           />
         </Tooltip>
       </Toolbar>
diff --git a/src/renderer/components/customTable/index.tsx b/src/renderer/components/customTable/index.tsx
index 5762c34..b20aaf6 100644
--- a/src/renderer/components/customTable/index.tsx
+++ b/src/renderer/components/customTable/index.tsx
@@ -19,6 +19,7 @@ const CustomTable = <T,>({
   loading,
   rowActions,
   containerStyle,
+  toolbarContent,
 }: CustomTableType<T>) => {
   const [page, setPage] = React.useState(0);
   const [perPage, setPerPage] = useLocalStorage(id, '10');
@@ -58,6 +59,7 @@ const CustomTable = <T,>({
       )}
       <CustomTableToolbar
         name={name}
+        toolbarContent={toolbarContent}
         handleSearch={(value) => {
           if (customPagination) {
             customPagination.setKeyword(value);
@@ -73,7 +75,7 @@ const CustomTable = <T,>({
           pointerEvents: loading ? 'none' : 'auto',
         }}
       >
-        <Table stickyHeader>
+        <Table stickyHeader size="small">
           <CustomTableHead
             onRequestSort={(property) => {
               if (customPagination) {
diff --git a/src/renderer/components/customTable/types.ts b/src/renderer/components/customTable/types.ts
index 6d31f93..fcaaea2 100644
--- a/src/renderer/components/customTable/types.ts
+++ b/src/renderer/components/customTable/types.ts
@@ -37,4 +37,5 @@ export type CustomTableType<T> = {
   customPagination?: CustomTablePagination<T>;
   rowActions?: Array<TableRowAction<T>>;
   containerStyle?: CSSProperties;
+  toolbarContent?: ReactNode;
 };
diff --git a/src/renderer/components/schemaTreeViewer/index.tsx b/src/renderer/components/schemaTreeViewer/index.tsx
index 5e56c65..6a5de98 100644
--- a/src/renderer/components/schemaTreeViewer/index.tsx
+++ b/src/renderer/components/schemaTreeViewer/index.tsx
@@ -60,10 +60,22 @@ const SchemaTreeViewer: React.FC<Props> = React.memo(
             </Tooltip>
           </Header>
         </Box>
-        {tables.length === 0 && (
+        {isLoadingSchema && (
+          <Box
+            sx={{
+              display: 'flex',
+              justifyContent: 'center',
+              alignItems: 'center',
+              padding: 4,
+            }}
+          >
+            <CircularProgress size={24} />
+          </Box>
+        )}
+        {!isLoadingSchema && tables.length === 0 && (
           <NoDataMessage>No Schema available</NoDataMessage>
         )}
-        {tables.length > 0 && (
+        {!isLoadingSchema && tables.length > 0 && (
           <StyledTreeView
             expandedItems={expandedItems}
             onExpandedItemsChange={handleExpandedItemsChange}
diff --git a/src/renderer/components/sqlEditor/index.tsx b/src/renderer/components/sqlEditor/index.tsx
index c5761ca..a5c5fa6 100644
--- a/src/renderer/components/sqlEditor/index.tsx
+++ b/src/renderer/components/sqlEditor/index.tsx
@@ -7,6 +7,7 @@ import { QueryHistoryType } from '../../../types/frontend';
 import { ConnectionInput, Project } from '../../../types/backend';
 import { SqlEditorComponent } from './editorComponent';
 import { QueryHistory } from './queryHistory';
+import { useAppContext } from '../../hooks';
 
 type Props = {
   completions: Omit<monacoType.languages.CompletionItem, 'range'>[];
@@ -17,6 +18,7 @@ type Props = {
   setLoadingQuery: (v: boolean) => void;
   setQueryResults: (v: any) => void;
   setError: (v: any) => void;
+  onQueryStart?: (queryId: string) => void;
 };
 
 export const SqlEditor: React.FC<Props> = ({
@@ -28,46 +30,119 @@ export const SqlEditor: React.FC<Props> = ({
   setLoadingQuery,
   setQueryResults,
   setError,
+  onQueryStart,
 }) => {
+  const { fetchSchema } = useAppContext();
   const editorRef = useRef<monacoType.editor.IStandaloneCodeEditor | null>(
     null,
   );
 
+  // Helper function to detect DDL operations that modify schema
+  const isDDLOperation = (query: string): boolean => {
+    const normalizedQuery = query.trim().toUpperCase();
+    const ddlKeywords = [
+      'CREATE TABLE',
+      'DROP TABLE',
+      'ALTER TABLE',
+      'CREATE SCHEMA',
+      'DROP SCHEMA',
+      'CREATE VIEW',
+      'DROP VIEW',
+      'RENAME TABLE',
+      'TRUNCATE TABLE',
+    ];
+    return ddlKeywords.some((keyword) => normalizedQuery.includes(keyword));
+  };
+
+  const getCommandType = (query: string): string => {
+    const normalized = query.trim().toUpperCase();
+    // Helper uses strict keyword check, but we can also check DML
+    if (isDDLOperation(query)) return 'DDL';
+    if (
+      normalized.startsWith('INSERT') ||
+      normalized.startsWith('UPDATE') ||
+      normalized.startsWith('DELETE') ||
+      normalized.startsWith('MERGE') ||
+      normalized.startsWith('TRUNCATE')
+    ) {
+      return 'DML';
+    }
+    return 'SELECT';
+  };
+
   const handleRunQuery = async (selectedQuery: string) => {
     if (!connectionInput || !selectedProject) {
       toast.error('No database connection configured for this project');
       return;
     }
 
+    // Generate semi-unique ID for query cancellation
+    const queryId = `query-${Date.now()}-${Math.random()
+      .toString(36)
+      .substr(2, 9)}`;
+
     setError(undefined);
     setLoadingQuery(true);
 
+    if (onQueryStart) {
+      onQueryStart(queryId);
+    }
+
     try {
       const result = await connectorsServices.queryData({
         connection: connectionInput,
         query: selectedQuery,
         projectName: selectedProject.name,
+        queryId,
       });
 
       if (result.error) {
-        toast.error(result.error);
         setError(result.error);
         setLoadingQuery(false);
         return;
       }
 
-      setQueryResults(result);
+      // Check if this was a DDL operation
+      const wasDDL = isDDLOperation(selectedQuery);
+      const commandType = getCommandType(selectedQuery);
+
+      const enrichedResult = {
+        ...result,
+        isCommand: commandType === 'DDL' || commandType === 'DML',
+        commandType,
+      };
+
+      setQueryResults(enrichedResult);
+
+      // Truncate results for history storage to prevent quota issues
+      // LocalStorage has a limit, so we can't store thousands of rows per query history item
+      const historyResults = {
+        ...result,
+        data: result.data?.slice(0, 10), // Only store first 10 rows in history
+      };
 
       const newHistoryItem: QueryHistoryType = {
         id: new Date().toISOString(),
         executedAt: new Date(),
-        results: result,
+        results: historyResults,
         projectId: selectedProject.id,
         projectName: selectedProject.name,
         query: selectedQuery,
       };
 
-      setQueryHistory([...queryHistory, newHistoryItem]);
+      // Limit history to last 50 items to prevent storage overflow
+      // We append new item then slice the end of the array
+      const updatedHistory = [...queryHistory, newHistoryItem];
+      if (updatedHistory.length > 50) {
+        setQueryHistory(updatedHistory.slice(updatedHistory.length - 50));
+      } else {
+        setQueryHistory(updatedHistory);
+      }
+
+      // Refresh schema if DDL operation was executed
+      if (wasDDL) {
+        fetchSchema();
+      }
     } catch (error) {
       toast.error('An unexpected error occurred while executing the query');
       setError(error);
diff --git a/src/renderer/components/sqlEditor/queryHistory/index.tsx b/src/renderer/components/sqlEditor/queryHistory/index.tsx
index 93876f1..5d6eca8 100644
--- a/src/renderer/components/sqlEditor/queryHistory/index.tsx
+++ b/src/renderer/components/sqlEditor/queryHistory/index.tsx
@@ -206,48 +206,60 @@ export const QueryHistoryToolbar: React.FC<ToolbarProps> = ({
           maxHeight: 500,
         }}
       >
-        <MenuItem
+        <div
           style={{
-            marginTop: -8,
-            paddingTop: 8,
+            padding: '8px 16px',
+            fontWeight: 600,
+            color: theme.palette.text.secondary,
           }}
-          disabled
         >
           Query History
-        </MenuItem>
+        </div>
         {sortedHistory.map((qh, index) => (
           <Tooltip key={index} title={qh.query} placement="left">
             <MenuItem
               style={{
                 display: 'flex',
                 alignItems: 'center',
-                gap: 10,
-                margin: '4px 0',
+                gap: 12,
+                padding: '8px 16px',
+                borderBottom: `1px solid ${theme.palette.divider}`,
               }}
               onClick={() => {
                 setSelectedQueryHistory(qh);
                 handleClose();
               }}
             >
+              <HistoryOutlined
+                style={{
+                  fontSize: 18,
+                  color: theme.palette.text.secondary,
+                }}
+              />
               <div
                 style={{
-                  padding: '4px 12px',
-                  background: theme.palette.background.paper,
-                  borderRadius: theme.shape.borderRadius,
-                  fontSize: 16,
-                  color: theme.palette.primary.main,
+                  fontFamily: 'monospace',
+                  fontSize: 14,
+                  fontWeight: 500,
+                  color: theme.palette.text.primary,
+                  overflow: 'hidden',
+                  textOverflow: 'ellipsis',
+                  whiteSpace: 'nowrap',
+                  maxWidth: '200px',
                 }}
               >
-                {qh.query.trim().slice(0, 16)}...
+                {qh.query.trim().slice(0, 30)}
+                {qh.query.trim().length > 30 ? '...' : ''}
               </div>
               <div
                 style={{
                   marginLeft: 'auto',
-                  fontSize: 14,
+                  fontSize: 12,
                   color: theme.palette.text.secondary,
+                  whiteSpace: 'nowrap',
                 }}
               >
-                {moment(qh.executedAt).fromNow()}
+                {moment(qh.executedAt).fromNow(true)} ago
               </div>
             </MenuItem>
           </Tooltip>
@@ -415,48 +427,60 @@ const QueryHistory: React.FC<Props> = ({
           maxHeight: 500,
         }}
       >
-        <MenuItem
+        <div
           style={{
-            marginTop: -8,
-            paddingTop: 8,
+            padding: '8px 16px',
+            fontWeight: 600,
+            color: theme.palette.text.secondary,
           }}
-          disabled
         >
           Query History
-        </MenuItem>
+        </div>
         {sortedHistory.map((qh, index) => (
           <Tooltip key={index} title={qh.query} placement="left">
             <MenuItem
               style={{
                 display: 'flex',
                 alignItems: 'center',
-                gap: 10,
-                margin: '4px 0',
+                gap: 12,
+                padding: '8px 16px',
+                borderBottom: `1px solid ${theme.palette.divider}`,
               }}
               onClick={() => {
                 setSelectedQueryHistory(qh);
                 handleClose();
               }}
             >
+              <HistoryOutlined
+                style={{
+                  fontSize: 18,
+                  color: theme.palette.text.secondary,
+                }}
+              />
               <div
                 style={{
-                  padding: '4px 12px',
-                  background: theme.palette.background.paper,
-                  borderRadius: theme.shape.borderRadius,
-                  fontSize: 16,
-                  color: theme.palette.primary.main,
+                  fontFamily: 'monospace',
+                  fontSize: 14,
+                  fontWeight: 500,
+                  color: theme.palette.text.primary,
+                  overflow: 'hidden',
+                  textOverflow: 'ellipsis',
+                  whiteSpace: 'nowrap',
+                  maxWidth: '200px',
                 }}
               >
-                {qh.query.trim().slice(0, 16)}...
+                {qh.query.trim().slice(0, 30)}
+                {qh.query.trim().length > 30 ? '...' : ''}
               </div>
               <div
                 style={{
                   marginLeft: 'auto',
-                  fontSize: 14,
+                  fontSize: 12,
                   color: theme.palette.text.secondary,
+                  whiteSpace: 'nowrap',
                 }}
               >
-                {moment(qh.executedAt).fromNow()}
+                {moment(qh.executedAt).fromNow(true)} ago
               </div>
             </MenuItem>
           </Tooltip>
diff --git a/src/renderer/screens/sql/index.tsx b/src/renderer/screens/sql/index.tsx
index 03bef3d..fb3b4b7 100644
--- a/src/renderer/screens/sql/index.tsx
+++ b/src/renderer/screens/sql/index.tsx
@@ -1,6 +1,9 @@
 import React, { useState } from 'react';
 import SplitPane from 'split-pane-react';
-import { Box, useTheme } from '@mui/material';
+import { Box, Button, CircularProgress, useTheme } from '@mui/material';
+import { Stop } from '@mui/icons-material';
+import { toast } from 'react-toastify';
+import { connectorsServices } from '../../services';
 import { useGetConnectionById, useGetSelectedProject } from '../../controllers';
 import { useAppContext, useLocalStorage } from '../../hooks';
 import { QueryHistoryType } from '../../../types/frontend';
@@ -35,9 +38,10 @@ const Sql = () => {
     JSON.stringify([]),
   );
   const [sizes, setSizes] = useState<[number, number]>([
-    window.innerHeight - 250,
-    250,
+    window.innerHeight - 350,
+    350,
   ]);
+  const [activeQueryId, setActiveQueryId] = useState<string | null>(null);
 
   const connectionInput = React.useMemo(() => {
     return connection ? getConnectionInput(connection) : undefined;
@@ -47,6 +51,20 @@ const Sql = () => {
     return schema ? utils.generateMonacoCompletions(schema) : [];
   }, [schema]);
 
+  const handleCancelQuery = async () => {
+    if (activeQueryId) {
+      try {
+        await connectorsServices.cancelQuery(activeQueryId);
+        toast.info('Query execution cancelled');
+      } catch (e) {
+        toast.error('Failed to cancel query');
+      } finally {
+        setActiveQueryId(null);
+        setLoadingQuery(false);
+      }
+    }
+  };
+
   const renderSash = () => (
     <Box
       sx={{
@@ -96,6 +114,7 @@ const Sql = () => {
               setLoadingQuery={setLoadingQuery}
               setQueryResults={setQueryResults}
               setError={setError}
+              onQueryStart={(id) => setActiveQueryId(id)}
             />
 
             <Box
@@ -106,7 +125,29 @@ const Sql = () => {
                 background: theme.palette.background.paper,
               }}
             >
-              {loadingQuery && <Loader />}
+              {loadingQuery && (
+                <Box
+                  sx={{
+                    display: 'flex',
+                    flexDirection: 'column',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    height: '100%',
+                    gap: 2,
+                  }}
+                >
+                  <Button
+                    variant="contained"
+                    color="error"
+                    onClick={handleCancelQuery}
+                    size="small"
+                    startIcon={<Stop />}
+                  >
+                    Stop Query
+                  </Button>
+                  <CircularProgress size={50} />
+                </Box>
+              )}
               {!loadingQuery && error && (
                 <ErrorMessage title="Query Failed" description={error} />
               )}
diff --git a/src/renderer/screens/sql/queryResult.tsx b/src/renderer/screens/sql/queryResult.tsx
index 818496c..457f8d0 100644
--- a/src/renderer/screens/sql/queryResult.tsx
+++ b/src/renderer/screens/sql/queryResult.tsx
@@ -1,8 +1,32 @@
 import React from 'react';
+import { styled } from '@mui/material/styles';
+import { Box, Typography } from '@mui/material';
+import { CheckCircleOutline } from '@mui/icons-material';
 import { QueryResponseType } from '../../../types/backend';
 import { CustomTable } from '../../components/customTable';
 import { underscoreToTitleCase } from '../../helpers/utils';
 
+const SuccessContainer = styled(Box)(({ theme }) => ({
+  backgroundColor: theme.palette.success.light,
+  color: theme.palette.success.contrastText,
+  border: `1px solid ${theme.palette.success.main}`,
+  borderRadius: theme.shape.borderRadius,
+  padding: theme.spacing(2),
+  display: 'flex',
+  alignItems: 'center',
+  gap: theme.spacing(2),
+  boxShadow: theme.shadows[2],
+  margin: theme.spacing(2, 0),
+  width: '100%',
+}));
+
+const IconWrapper = styled(Box)(() => ({
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'center',
+  fontSize: '2rem',
+}));
+
 type Props = {
   results: QueryResponseType;
 };
@@ -16,10 +40,67 @@ export const QueryResult: React.FC<Props> = ({ results }) => {
     return results.data ?? [];
   }, [results]);
 
+  // Use isCommand flag if available, otherwise fallback to field check
+  const isCommand =
+    results.isCommand ||
+    ((!results.fields || results.fields.length === 0) && results.success);
+
+  // Show row count for DML or generic commands with rowCount > 0
+  const showRowCount =
+    results.commandType === 'DML' ||
+    (results.commandType !== 'DDL' &&
+      results.rowCount !== undefined &&
+      results.rowCount > 0);
+
+  if (isCommand) {
+    return (
+      <SuccessContainer>
+        <IconWrapper>
+          <CheckCircleOutline fontSize="large" />
+        </IconWrapper>
+        <Box>
+          <Typography variant="h6" fontWeight="bold">
+            Command executed successfully
+          </Typography>
+          {showRowCount && results.rowCount !== undefined && (
+            <Typography variant="body2">
+              {`${results.rowCount} row${
+                results.rowCount !== 1 ? 's' : ''
+              } affected`}
+            </Typography>
+          )}
+          {results.duration !== undefined && (
+            <Typography variant="caption" sx={{ display: 'block', mt: 0.5 }}>
+              Duration:{' '}
+              {results.duration! > 1000
+                ? `${(results.duration! / 1000).toFixed(2)}s`
+                : `${results.duration!}ms`}
+            </Typography>
+          )}
+        </Box>
+      </SuccessContainer>
+    );
+  }
+
   return (
     <CustomTable<Record<string, any>>
       id="query-result"
-      name="Query Result"
+      name=""
+      toolbarContent={
+        results.duration !== undefined ? (
+          <span
+            style={{
+              fontSize: '0.875rem',
+              color: 'text.secondary',
+              opacity: 0.7,
+            }}
+          >
+            {results.duration > 1000
+              ? `${(results.duration / 1000).toFixed(2)}s`
+              : `${results.duration}ms`}
+          </span>
+        ) : null
+      }
       rows={rows as any}
       columns={columns.map((column) => ({
         id: column,
@@ -28,7 +109,7 @@ export const QueryResult: React.FC<Props> = ({ results }) => {
           <div
             style={{
               whiteSpace: 'nowrap',
-              minHeight: '40px',
+              minHeight: '24px',
               display: 'flex',
               alignItems: 'center',
             }}
diff --git a/src/renderer/services/connectors.service.ts b/src/renderer/services/connectors.service.ts
index 285d4e8..bec479e 100644
--- a/src/renderer/services/connectors.service.ts
+++ b/src/renderer/services/connectors.service.ts
@@ -57,14 +57,19 @@ export const queryData = async (body: {
   connection: ConnectionInput;
   query: string;
   projectName: string;
+  queryId?: string;
 }): Promise<QueryResponseType> => {
   const { data } = await client.post<
-    { connection: ConnectionInput; query: string },
+    { connection: ConnectionInput; query: string; queryId?: string },
     QueryResponseType
   >('connector:query', body);
   return data;
 };
 
+export const cancelQuery = async (queryId: string): Promise<void> => {
+  await client.post<string, void>('connector:cancel-query', queryId);
+};
+
 export const setConnectionEnvVariable = async (
   key: string,
   value: string,
diff --git a/src/types/backend.ts b/src/types/backend.ts
index 56bddf9..01c51e6 100644
--- a/src/types/backend.ts
+++ b/src/types/backend.ts
@@ -381,6 +381,9 @@ export type QueryResponseType = {
   fields?: { name: string; type: number }[];
   rowCount?: number; // Add rowCount for affected rows in INSERT/UPDATE/DELETE operations
   error?: string;
+  duration?: number;
+  isCommand?: boolean;
+  commandType?: string;
 };
 
 export type CliUpdateItem = {
@@ -490,6 +493,7 @@ export type ExecuteStatementType = {
   connection: ConnectionInput;
   query: string;
   projectName: string;
+  queryId?: string;
 };
 
 // AI Provider Types
diff --git a/src/types/ipc.ts b/src/types/ipc.ts
index 7ffe68a..ef27bba 100644
--- a/src/types/ipc.ts
+++ b/src/types/ipc.ts
@@ -65,7 +65,8 @@ export type ConnectorChannels =
   | 'connector:list'
   | 'connector:get'
   | 'connector:update'
-  | 'connector:delete';
+  | 'connector:delete'
+  | 'connector:cancel-query';
 
 export type SourcesChannels =
   | 'sources:create'

From 2030d60ede9dd87d0a8d3297d4f076fc7824282d Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 12:47:54 +0100
Subject: [PATCH 12/21] Change styles of Alerts and fix history comments

---
 .../components/errorMessage/index.tsx         |  8 ++---
 .../sqlEditor/queryHistory/index.tsx          | 29 ++++++++++++++++---
 src/renderer/screens/sql/queryResult.tsx      |  8 ++---
 3 files changed, 33 insertions(+), 12 deletions(-)

diff --git a/src/renderer/components/errorMessage/index.tsx b/src/renderer/components/errorMessage/index.tsx
index 3283725..6361c2c 100644
--- a/src/renderer/components/errorMessage/index.tsx
+++ b/src/renderer/components/errorMessage/index.tsx
@@ -4,9 +4,9 @@ import { Box, Typography } from '@mui/material';
 import ErrorOutlineIcon from '@mui/icons-material/ErrorOutline';
 
 const ErrorContainer = styled(Box)(({ theme }) => ({
-  backgroundColor: theme.palette.error.light,
-  color: theme.palette.error.contrastText,
-  border: `1px solid ${theme.palette.error.main}`,
+  backgroundColor: theme.palette.background.paper,
+  color: theme.palette.text.primary,
+  border: `1px solid ${theme.palette.divider}`,
   borderRadius: theme.shape.borderRadius,
   padding: theme.spacing(2),
   display: 'flex',
@@ -35,7 +35,7 @@ export const ErrorMessage: React.FC<Props> = ({
   return (
     <ErrorContainer>
       <IconWrapper>
-        <ErrorOutlineIcon fontSize="large" />
+        <ErrorOutlineIcon fontSize="large" color="error" />
       </IconWrapper>
       <Box>
         <Typography variant="h6" fontWeight="bold">
diff --git a/src/renderer/components/sqlEditor/queryHistory/index.tsx b/src/renderer/components/sqlEditor/queryHistory/index.tsx
index 5d6eca8..d20cb3e 100644
--- a/src/renderer/components/sqlEditor/queryHistory/index.tsx
+++ b/src/renderer/components/sqlEditor/queryHistory/index.tsx
@@ -23,6 +23,29 @@ import { Container } from './styles';
 import { QueryHistoryType } from '../../../../types/frontend';
 import { projectsServices } from '../../../services';
 
+const formatQueryPreview = (query: string, maxLength: number = 30) => {
+  if (!query) return '';
+
+  const lines = query.split('\n');
+  // Find the first line that is not a comment and not empty
+  const firstSignificantLine = lines.find((line) => {
+    const trimmed = line.trim();
+    return (
+      trimmed.length > 0 &&
+      !trimmed.startsWith('--') &&
+      !trimmed.startsWith('/*')
+    );
+  });
+
+  // If no significant line found, fallback to the first non-empty line
+  const preview = firstSignificantLine
+    ? firstSignificantLine.trim()
+    : query.trim().split('\n')[0].trim();
+
+  if (preview.length <= maxLength) return preview;
+  return `${preview.slice(0, maxLength)}...`;
+};
+
 type Props = {
   onQuerySelect: (value: QueryHistoryType) => void;
   queryHistory: QueryHistoryType[];
@@ -248,8 +271,7 @@ export const QueryHistoryToolbar: React.FC<ToolbarProps> = ({
                   maxWidth: '200px',
                 }}
               >
-                {qh.query.trim().slice(0, 30)}
-                {qh.query.trim().length > 30 ? '...' : ''}
+                {formatQueryPreview(qh.query, 30)}
               </div>
               <div
                 style={{
@@ -469,8 +491,7 @@ const QueryHistory: React.FC<Props> = ({
                   maxWidth: '200px',
                 }}
               >
-                {qh.query.trim().slice(0, 30)}
-                {qh.query.trim().length > 30 ? '...' : ''}
+                {formatQueryPreview(qh.query, 30)}
               </div>
               <div
                 style={{
diff --git a/src/renderer/screens/sql/queryResult.tsx b/src/renderer/screens/sql/queryResult.tsx
index 457f8d0..fbaf476 100644
--- a/src/renderer/screens/sql/queryResult.tsx
+++ b/src/renderer/screens/sql/queryResult.tsx
@@ -7,9 +7,9 @@ import { CustomTable } from '../../components/customTable';
 import { underscoreToTitleCase } from '../../helpers/utils';
 
 const SuccessContainer = styled(Box)(({ theme }) => ({
-  backgroundColor: theme.palette.success.light,
-  color: theme.palette.success.contrastText,
-  border: `1px solid ${theme.palette.success.main}`,
+  backgroundColor: theme.palette.background.paper,
+  color: theme.palette.text.primary,
+  border: `1px solid ${theme.palette.divider}`,
   borderRadius: theme.shape.borderRadius,
   padding: theme.spacing(2),
   display: 'flex',
@@ -56,7 +56,7 @@ export const QueryResult: React.FC<Props> = ({ results }) => {
     return (
       <SuccessContainer>
         <IconWrapper>
-          <CheckCircleOutline fontSize="large" />
+          <CheckCircleOutline fontSize="large" color="success" />
         </IconWrapper>
         <Box>
           <Typography variant="h6" fontWeight="bold">

From a723caad5932209663c403d08c87af35ceea708b Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 13:02:34 +0100
Subject: [PATCH 13/21] fix: update request type generic in connectors service

- Add `projectName: string` to the `client.post` generic in [queryData]
- Ensure type alignment between frontend service and backend IPC handler
---
 src/renderer/screens/sql/queryResult.tsx    | 12 +++++-------
 src/renderer/services/connectors.service.ts |  7 ++++++-
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/renderer/screens/sql/queryResult.tsx b/src/renderer/screens/sql/queryResult.tsx
index fbaf476..9531e2e 100644
--- a/src/renderer/screens/sql/queryResult.tsx
+++ b/src/renderer/screens/sql/queryResult.tsx
@@ -88,17 +88,15 @@ export const QueryResult: React.FC<Props> = ({ results }) => {
       name=""
       toolbarContent={
         results.duration !== undefined ? (
-          <span
-            style={{
-              fontSize: '0.875rem',
-              color: 'text.secondary',
-              opacity: 0.7,
-            }}
+          <Typography
+            variant="body2"
+            color="text.secondary"
+            sx={{ opacity: 0.7 }}
           >
             {results.duration > 1000
               ? `${(results.duration / 1000).toFixed(2)}s`
               : `${results.duration}ms`}
-          </span>
+          </Typography>
         ) : null
       }
       rows={rows as any}
diff --git a/src/renderer/services/connectors.service.ts b/src/renderer/services/connectors.service.ts
index bec479e..7ee5226 100644
--- a/src/renderer/services/connectors.service.ts
+++ b/src/renderer/services/connectors.service.ts
@@ -60,7 +60,12 @@ export const queryData = async (body: {
   queryId?: string;
 }): Promise<QueryResponseType> => {
   const { data } = await client.post<
-    { connection: ConnectionInput; query: string; queryId?: string },
+    {
+      connection: ConnectionInput;
+      query: string;
+      projectName: string;
+      queryId?: string;
+    },
     QueryResponseType
   >('connector:query', body);
   return data;

From 6a0d09a164b1ef3e79485f41d22e0556f823a832 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 13:22:27 +0100
Subject: [PATCH 14/21] Fix: Remove depreciated config from profiles.yml

---
 src/main/services/connectors.service.ts | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/main/services/connectors.service.ts b/src/main/services/connectors.service.ts
index 08809e1..ef92461 100644
--- a/src/main/services/connectors.service.ts
+++ b/src/main/services/connectors.service.ts
@@ -637,10 +637,6 @@ export default class ConnectorsService {
     conn: ConnectionInput,
   ): Promise<string> {
     const profileConfig = {
-      config: {
-        send_anonymous_usage_stats: false,
-        partial_parse: true,
-      },
       [name]: {
         target: 'dev',
         outputs: {

From afa5dc507816049fe7de6d61368ac03696942331 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 15:42:50 +0100
Subject: [PATCH 15/21] fix(editor): prevent tab content corruption when
 opening non-editable files

When switching from an editable tab to a non-editable file (e.g., .duckdb),
the previous tab's content was being overwritten with the non-editable
file's placeholder message.

Root cause: Monaco editor fires onChange events when its value prop changes
during tab switches. The handleChange callback had stale closure references,
causing content updates to be attributed to the wrong tab.

Changes:
- editor/index.tsx: Use refs to track activeTabId and expectedContent
  synchronously during render. Only forward genuine user edits to state,
  ignoring Monaco's internal sync events during tab transitions.
- useTabManager.ts: Restore proper ID capturing from within setTabs
  callback and keep tabsRef in sync for consistent tab lookups.
---
 src/renderer/components/editor/index.tsx | 45 ++++++++++++++++++++----
 src/renderer/hooks/useTabManager.ts      | 13 ++++---
 2 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/src/renderer/components/editor/index.tsx b/src/renderer/components/editor/index.tsx
index cfee856..5acd5d3 100644
--- a/src/renderer/components/editor/index.tsx
+++ b/src/renderer/components/editor/index.tsx
@@ -151,13 +151,46 @@ export const Editor: React.FC<EditorProps> = ({
     return () => window.removeEventListener('keydown', handleKeyDown);
   }, [handleSave]);
 
+  // Track the active tab ID and expected content using refs to prevent stale closures
+  // This is critical because Monaco fires onChange when content prop changes,
+  // but at that moment the closure might still have the old activeTab
+  const activeTabIdRef = React.useRef(activeTabId);
+  const expectedContentRef = React.useRef(activeContent);
+
+  // Update refs synchronously before render completes
+  activeTabIdRef.current = activeTabId;
+  expectedContentRef.current = activeContent;
+
   // Content change handler (no auto-save)
-  const handleChange: OnChange = (value) => {
-    if (value === undefined || !activeTab || !activeTabId) {
-      return;
-    }
-    onTabContentChange(activeTabId, value);
-  };
+  // Only handle ACTUAL user edits, not programmatic content changes from tab switching
+  const handleChange: OnChange = React.useCallback(
+    (value) => {
+      // Ignore undefined values
+      if (value === undefined) {
+        return;
+      }
+
+      // Get the current active tab ID from the ref (always up-to-date)
+      const currentTabId = activeTabIdRef.current;
+      if (!currentTabId) {
+        return;
+      }
+
+      // Get the expected content for the current tab
+      const expectedContent = expectedContentRef.current;
+
+      // CRITICAL: If the incoming value matches what we expect for this tab,
+      // it means Monaco is just syncing to our controlled value (tab switch).
+      // Only process changes that are DIFFERENT from what we set.
+      if (value === expectedContent) {
+        return;
+      }
+
+      // This is a genuine user edit - update the tab content
+      onTabContentChange(currentTabId, value);
+    },
+    [onTabContentChange],
+  );
 
   if (tabs.length === 0) {
     return (
diff --git a/src/renderer/hooks/useTabManager.ts b/src/renderer/hooks/useTabManager.ts
index 8b32dbc..29e3780 100644
--- a/src/renderer/hooks/useTabManager.ts
+++ b/src/renderer/hooks/useTabManager.ts
@@ -412,12 +412,15 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
       let isEditable = false;
       let hasInitialContent = false;
 
+      isEditable = isEditableFile(path);
+      hasInitialContent = typeof options?.content === 'string';
+
       setTabs((current) => {
         const existingTab = current.find((tab) => tab.path === path);
         if (existingTab) {
           targetId = existingTab.id;
           // Update existing tab with new options
-          return current.map((tab) =>
+          const updated = current.map((tab) =>
             tab.path === path
               ? {
                   ...tab,
@@ -425,11 +428,13 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
                 }
               : tab,
           );
+          tabsRef.current = updated;
+          return updated;
         }
 
-        isEditable = isEditableFile(path);
-        hasInitialContent = typeof options?.content === 'string';
         const id = ensureUniqueId(path, current);
+        targetId = id;
+
         const initialContent =
           options?.content ??
           (isEditable ? '' : getNonEditableFileMessage(path));
@@ -447,13 +452,13 @@ const useTabManager = (projectId?: string): UseTabManagerReturn => {
           isReadOnly: options?.isReadOnly ?? !isEditable,
         };
 
-        targetId = id;
         shouldLoadContent = isEditable && !hasInitialContent;
         const updated = [...current, newTab];
         tabsRef.current = updated;
         return updated;
       });
 
+      // The setTabs callback runs synchronously, so targetId is set before this line
       if (!targetId) {
         return null;
       }

From 0cc6aaebc90952cd878bb8c1626476a37ab2f713 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 16:18:49 +0100
Subject: [PATCH 16/21] refactor(dataLake): migrate TextField InputProps to MUI
 v6 slotProps

- DataLakeInstanceDetails: Replace deprecated InputProps with slotProps
  for snapshot search field, moving startAdornment and sx into slotProps.input
- DataLakeTableImportWizard: Replace deprecated InputProps with slotProps
  for file path field, moving endAdornment into slotProps.input
---
 .../dataLake/DataLakeInstanceDetails.tsx         | 16 +++++++++-------
 .../dataLake/DataLakeTableImportWizard.tsx       | 14 ++++++++------
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index 7ec5a25..26d0fa4 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -858,13 +858,15 @@ export const DataLakeInstanceDetails: React.FC<
                   placeholder="Search snapshots (ID or changes)..."
                   value={snapshotFilter}
                   onChange={(e) => setSnapshotFilter(e.target.value)}
-                  InputProps={{
-                    startAdornment: (
-                      <InputAdornment position="start">
-                        <Search fontSize="small" />
-                      </InputAdornment>
-                    ),
-                    sx: { fontSize: '0.8125rem', height: '32px' },
+                  slotProps={{
+                    input: {
+                      startAdornment: (
+                        <InputAdornment position="start">
+                          <Search fontSize="small" />
+                        </InputAdornment>
+                      ),
+                      sx: { fontSize: '0.8125rem', height: '32px' },
+                    },
                   }}
                   sx={{
                     width: 300,
diff --git a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
index 547216e..1ab9a34 100644
--- a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
+++ b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
@@ -244,12 +244,14 @@ export const DataLakeTableImportWizard: React.FC<
             onChange={(e) => setFilePath(e.target.value)}
             placeholder="/path/to/file.csv"
             helperText="Absolute or relative path to CSV, Parquet, or JSON file"
-            InputProps={{
-              endAdornment: (
-                <IconButton onClick={handleFileSelect} edge="end">
-                  <FolderOpen />
-                </IconButton>
-              ),
+            slotProps={{
+              input: {
+                endAdornment: (
+                  <IconButton onClick={handleFileSelect} edge="end">
+                    <FolderOpen />
+                  </IconButton>
+                ),
+              },
             }}
           />
           <Alert severity="info" sx={{ mt: 2 }}>

From eba92a1f2b21a10fca8cf31709b4ad8ede1ac366 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 16:27:14 +0100
Subject: [PATCH 17/21] feat(dataLake): implement instance snapshot history
 with pagination

- Add instance-wide snapshot history tab with paginated table view
- Filter table-specific snapshots by table ID in backend queries
- Add snapshot search with pagination reset on filter change
- Invalidate snapshot cache on refresh
- Fix text overflow with word wrapping in history columns
- Migrate TextField InputProps to MUI v6 slotProps format
---
 .../components/dataLake/DataLakeInstanceDetails.tsx       | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index 26d0fa4..8ce0307 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -153,10 +153,11 @@ export const DataLakeInstanceDetails: React.FC<
   };
 
   const handleRefresh = () => {
-    // Invalidate tables and health status for this instance
+    // Invalidate tables, health status, and snapshots for this instance
     queryClient.invalidateQueries(duckLakeKeys.tables(instance.id));
     queryClient.invalidateQueries(duckLakeKeys.instanceHealth(instance.id));
     queryClient.invalidateQueries(duckLakeKeys.instance(instance.id));
+    queryClient.invalidateQueries(duckLakeKeys.instanceSnapshots(instance.id));
   };
 
   const isStorageHealthy = (value?: boolean) =>
@@ -857,7 +858,10 @@ export const DataLakeInstanceDetails: React.FC<
                   size="small"
                   placeholder="Search snapshots (ID or changes)..."
                   value={snapshotFilter}
-                  onChange={(e) => setSnapshotFilter(e.target.value)}
+                  onChange={(e) => {
+                    setSnapshotFilter(e.target.value);
+                    setSnapshotPage(0); // Reset pagination when filter changes
+                  }}
                   slotProps={{
                     input: {
                       startAdornment: (

From c1d26b5d703cd175ec81c3f624f650b284ebc224 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 16:33:32 +0100
Subject: [PATCH 18/21] fix(dataLake): handle zero/negative bytes in
 formatBytes to prevent NaN

---
 src/renderer/components/dataLake/DataLakeInstanceDetails.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index 8ce0307..efee207 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -143,6 +143,7 @@ export const DataLakeInstanceDetails: React.FC<
   };
 
   const formatBytes = (bytes: number) => {
+    if (bytes <= 0) return '0 Bytes';
     const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
     const i = Math.floor(Math.log(bytes) / Math.log(1024));
     return `${Math.round((bytes / 1024 ** i) * 100) / 100} ${sizes[i]}`;

From b9fb52f687381a0855809c2134cb0aa802a67f50 Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 16:55:06 +0100
Subject: [PATCH 19/21] fix(dataLake): address SQL injection, syntax errors,
 and edge cases

- postgresql.adapter: Remove trailing commas in SELECT clauses for
  columnStatsQuery and dataFilesQuery to fix SQL syntax errors
- DataLakeInstanceDetails: Handle zero/negative bytes in formatBytes,
  add BigInt support and try/catch in safeToString, use exact:false
  for snapshot cache invalidation, reset pagination on filter change
- DataLakeTableImportWizard: Quote table name as identifier to prevent
  SQL injection and handle reserved words
---
 .../duckLake/adapters/postgresql.adapter.ts   |  4 ++--
 .../dataLake/DataLakeInstanceDetails.tsx      | 22 +++++++++++++------
 .../dataLake/DataLakeTableImportWizard.tsx    |  6 +++--
 3 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/main/services/duckLake/adapters/postgresql.adapter.ts b/src/main/services/duckLake/adapters/postgresql.adapter.ts
index 5b3a7f2..342eaa3 100644
--- a/src/main/services/duckLake/adapters/postgresql.adapter.ts
+++ b/src/main/services/duckLake/adapters/postgresql.adapter.ts
@@ -848,7 +848,7 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
           cs.contains_null,
           cs.contains_nan,
           cs.min_value,
-          cs.max_value,
+          cs.max_value
         FROM ${quotedMetadataDatabase}.ducklake_table_column_stats cs
         JOIN ${quotedMetadataDatabase}.ducklake_column c 
           ON cs.column_id = c.column_id 
@@ -899,7 +899,7 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
           file_order,
           begin_snapshot,
           end_snapshot,
-          partition_id,
+          partition_id
         FROM ${quotedMetadataDatabase}.ducklake_data_file
         WHERE table_id = ${tableId}
           AND ${currentSnapshot} >= begin_snapshot
diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index efee207..68cd9f0 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -158,7 +158,10 @@ export const DataLakeInstanceDetails: React.FC<
     queryClient.invalidateQueries(duckLakeKeys.tables(instance.id));
     queryClient.invalidateQueries(duckLakeKeys.instanceHealth(instance.id));
     queryClient.invalidateQueries(duckLakeKeys.instance(instance.id));
-    queryClient.invalidateQueries(duckLakeKeys.instanceSnapshots(instance.id));
+    // Use exact: false to match parameterized snapshot queries
+    queryClient.invalidateQueries(duckLakeKeys.instanceSnapshots(instance.id), {
+      exact: false,
+    });
   };
 
   const isStorageHealthy = (value?: boolean) =>
@@ -756,21 +759,26 @@ export const DataLakeInstanceDetails: React.FC<
     </Box>
   );
 
-  /**
-   * Safely convert any value to string for React rendering
-   * Handles DuckDB hugeint objects and other non-primitive types
-   */
+  // Safely convert any value to string for React rendering (handles DuckDB hugeint, BigInt, circular objects)
   const safeToString = (value: any): string => {
     if (value === null || value === undefined) {
       return '-';
     }
+    // Handle BigInt explicitly
+    if (typeof value === 'bigint') {
+      return String(value);
+    }
     if (typeof value === 'object') {
       // Handle DuckDB hugeint objects
       if (value.hugeint !== undefined) {
         return String(value.hugeint);
       }
-      // Handle other objects
-      return JSON.stringify(value);
+      // Handle other objects with try/catch for circular references
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return '-';
+      }
     }
     return String(value);
   };
diff --git a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
index 1ab9a34..bb7792d 100644
--- a/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
+++ b/src/renderer/components/dataLake/DataLakeTableImportWizard.tsx
@@ -110,16 +110,18 @@ export const DataLakeTableImportWizard: React.FC<
     let sourceQuery = '';
     const src = sourceType === 'url' ? sourceUrl : filePath;
     const escapedSrc = src.replace(/'/g, "''");
+    // Quote table name as identifier to prevent SQL injection and handle reserved words
+    const escapedTableName = `"${tableName.replace(/"/g, '""')}"`;
     const isCsv = src.toLowerCase().endsWith('.csv');
 
     if (isCsv) {
       // Use specific CSV reader with error handling options
       // ignore_errors=true: Skips rows with parsing errors
       // null_padding=true: Pads missing columns with NULL
-      sourceQuery = `CREATE TABLE ${tableName} AS SELECT * FROM read_csv_auto('${escapedSrc}', ignore_errors=true, null_padding=true)`;
+      sourceQuery = `CREATE TABLE ${escapedTableName} AS SELECT * FROM read_csv_auto('${escapedSrc}', ignore_errors=true, null_padding=true)`;
     } else {
       // Default behavior for other formats (Parquet, JSON, etc.)
-      sourceQuery = `CREATE TABLE ${tableName} AS FROM '${escapedSrc}'`;
+      sourceQuery = `CREATE TABLE ${escapedTableName} AS FROM '${escapedSrc}'`;
     }
 
     onImport(tableName, sourceQuery);

From eb253988f7833fed93b03a5ce102e9337a9694bc Mon Sep 17 00:00:00 2001
From: Nuri Lacka <nurilacka@gmail.com>
Date: Mon, 12 Jan 2026 17:11:16 +0100
Subject: [PATCH 20/21] fix(datalake): escape SQL LIKE wildcards in snapshot
 filters

- Update PostgreSQL, SQLite, and DuckDB adapters to properly escape
  `%`, `_`, and `\` in snapshot search filters to prevent unintended
  wildcard matching
- Add explicit `ESCAPE '\'` clause to all LIKE queries for consistent
  behavior across different database backends
---
 .../services/duckLake/adapters/duckdb.adapter.ts    | 11 ++++++++---
 .../duckLake/adapters/postgresql.adapter.ts         | 11 ++++++++---
 .../services/duckLake/adapters/sqlite.adapter.ts    | 11 ++++++++---
 .../components/dataLake/DataLakeInstanceDetails.tsx | 13 +++++++++++--
 4 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/src/main/services/duckLake/adapters/duckdb.adapter.ts b/src/main/services/duckLake/adapters/duckdb.adapter.ts
index ee21b56..3bd4c5c 100644
--- a/src/main/services/duckLake/adapters/duckdb.adapter.ts
+++ b/src/main/services/duckLake/adapters/duckdb.adapter.ts
@@ -604,10 +604,15 @@ export class DuckDBCatalogAdapter extends CatalogAdapter {
       let whereClause = '';
       if (filter) {
         // Sanitize filter for simple SQL injection prevention
-        const safeFilter = filter.replace(/'/g, "''");
+        // Escape LIKE wildcards first, then single quotes for SQL
+        const safeFilter = filter
+          .replace(/\\/g, '\\\\')
+          .replace(/%/g, '\\%')
+          .replace(/_/g, '\\_')
+          .replace(/'/g, "''");
         whereClause = `
-          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%'
-             OR sc.changes_made LIKE '%${safeFilter}%'
+          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%' ESCAPE '\\'
+             OR sc.changes_made LIKE '%${safeFilter}%' ESCAPE '\\'
         `;
       }
 
diff --git a/src/main/services/duckLake/adapters/postgresql.adapter.ts b/src/main/services/duckLake/adapters/postgresql.adapter.ts
index 342eaa3..25751aa 100644
--- a/src/main/services/duckLake/adapters/postgresql.adapter.ts
+++ b/src/main/services/duckLake/adapters/postgresql.adapter.ts
@@ -582,10 +582,15 @@ export class PostgreSQLCatalogAdapter extends CatalogAdapter {
       // Build WHERE clause
       let whereClause = '';
       if (filter) {
-        const safeFilter = filter.replace(/'/g, "''");
+        // Escape LIKE wildcards first, then single quotes for SQL
+        const safeFilter = filter
+          .replace(/\\/g, '\\\\')
+          .replace(/%/g, '\\%')
+          .replace(/_/g, '\\_')
+          .replace(/'/g, "''");
         whereClause = `
-          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%'
-             OR sc.changes_made LIKE '%${safeFilter}%'
+          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%' ESCAPE '\\'
+             OR sc.changes_made LIKE '%${safeFilter}%' ESCAPE '\\'
         `;
       }
 
diff --git a/src/main/services/duckLake/adapters/sqlite.adapter.ts b/src/main/services/duckLake/adapters/sqlite.adapter.ts
index 818906d..225e0da 100644
--- a/src/main/services/duckLake/adapters/sqlite.adapter.ts
+++ b/src/main/services/duckLake/adapters/sqlite.adapter.ts
@@ -555,10 +555,15 @@ export class SQLiteCatalogAdapter extends CatalogAdapter {
         // Sanitize filter for simple SQL injection prevention (basic)
         // In real implementations, use bound parameters if possible, but DuckDB Node bindings might differ
         // For text search in snapshots
-        const safeFilter = filter.replace(/'/g, "''");
+        // Escape LIKE wildcards first, then single quotes for SQL
+        const safeFilter = filter
+          .replace(/\\/g, '\\\\')
+          .replace(/%/g, '\\%')
+          .replace(/_/g, '\\_')
+          .replace(/'/g, "''");
         whereClause = `
-          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%'
-             OR sc.changes_made LIKE '%${safeFilter}%'
+          WHERE CAST(s.snapshot_id AS VARCHAR) LIKE '%${safeFilter}%' ESCAPE '\\'
+             OR sc.changes_made LIKE '%${safeFilter}%' ESCAPE '\\'
         `;
       }
 
diff --git a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
index 68cd9f0..1842a49 100644
--- a/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
+++ b/src/renderer/components/dataLake/DataLakeInstanceDetails.tsx
@@ -720,8 +720,8 @@ export const DataLakeInstanceDetails: React.FC<
                         Optimizer
                       </Typography>
                       <Typography variant="body1">
-                        {instance.runtime?.enableOptimizer ||
-                        instance.runtimeOptions?.enableOptimizer
+                        {(instance.runtime?.enableOptimizer ??
+                        instance.runtimeOptions?.enableOptimizer)
                           ? 'Enabled'
                           : 'Disabled'}
                       </Typography>
@@ -896,7 +896,15 @@ export const DataLakeInstanceDetails: React.FC<
 
               {snapshotsQuery.isLoading && <LinearProgress />}
 
+              {snapshotsQuery.isError && (
+                <Alert severity="error">
+                  Failed to load snapshot history:{' '}
+                  {(snapshotsQuery.error as Error)?.message || 'Unknown error'}
+                </Alert>
+              )}
+
               {!snapshotsQuery.isLoading &&
+                !snapshotsQuery.isError &&
                 snapshotsQuery.data &&
                 snapshotsQuery.data.data.length > 0 && (
                   <>
@@ -958,6 +966,7 @@ export const DataLakeInstanceDetails: React.FC<
                 )}
 
               {!snapshotsQuery.isLoading &&
+                !snapshotsQuery.isError &&
                 (!snapshotsQuery.data ||
                   snapshotsQuery.data.data.length === 0) && (
                   <Alert severity="info">No snapshot history available</Alert>

From ffa99aeabfc0517881754574712ebbad6176a74b Mon Sep 17 00:00:00 2001
From: jasir99 <jasirfetai@gmail.com>
Date: Tue, 13 Jan 2026 14:24:32 +0100
Subject: [PATCH 21/21] version bump: 1.2.6

---
 package-lock.json             | 4 ++--
 package.json                  | 2 +-
 release/app/package-lock.json | 4 ++--
 release/app/package.json      | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 290a40a..b79f31f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "rosetta-dbt-studio",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "rosetta-dbt-studio",
-      "version": "1.2.5",
+      "version": "1.2.6",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
diff --git a/package.json b/package.json
index 0e2dced..2f1893a 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
 {
-  "version": "1.2.5",
+  "version": "1.2.6",
   "name": "rosetta-dbt-studio",
   "description": "Turn Raw Data into Business Insights—Faster with RosettaDB",
   "keywords": [
diff --git a/release/app/package-lock.json b/release/app/package-lock.json
index 9776e2a..3c84dbc 100644
--- a/release/app/package-lock.json
+++ b/release/app/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "rosetta-dbt-studio",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "rosetta-dbt-studio",
-      "version": "1.2.5",
+      "version": "1.2.6",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
diff --git a/release/app/package.json b/release/app/package.json
index d944643..cc66731 100644
--- a/release/app/package.json
+++ b/release/app/package.json
@@ -1,6 +1,6 @@
 {
   "name": "rosetta-dbt-studio",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "A modern DBT desktop IDE",
   "license": "MIT",
   "author": {