Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
36 changes: 35 additions & 1 deletion apps/tauri/src-tauri/src/commands.rs
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
use crate::connection::{
ConnectionConfig, ConnectionError, ConnectionId, ConnectionManager, ConnectionRegistry,
SchemaObject, TableSchema,
QueryEvent, SchemaObject, TableSchema,
};
use tauri::ipc::Channel;
use tauri::State;

#[tauri::command]
Expand Down Expand Up @@ -49,3 +50,36 @@ pub fn db_list_columns(
) -> Result<TableSchema, ConnectionError> {
registry.with_sqlite(&id, |s| s.list_columns(&table))
}

/// Execute SQL and stream `QueryEvent` batches over `on_event` (not one giant IPC payload).
#[tauri::command]
pub fn db_execute_query(
id: ConnectionId,
sql: String,
limit: Option<u32>,
on_event: Channel<QueryEvent>,
registry: State<'_, ConnectionRegistry>,
) -> Result<(), ConnectionError> {
let conn_arc = registry.sqlite_connection_arc(&id)?;
let guard = conn_arc
.lock()
.map_err(|_| ConnectionError::io("sqlite connection lock poisoned"))?;
let conn = guard
.as_ref()
.ok_or_else(|| ConnectionError::Disconnected { id: id.clone() })?;

let limit = limit.map(|n| n as usize);
match crate::connection::sqlite_query::execute_streaming(conn, &sql, limit, None, |ev| {
on_event
.send(ev)
.map_err(|e| ConnectionError::io(format!("query channel closed: {e}")))
}) {
Ok(()) => Ok(()),
Err(e) => {
let _ = on_event.send(QueryEvent::Error {
message: e.to_string(),
});
Err(e)
}
}
}
8 changes: 8 additions & 0 deletions apps/tauri/src-tauri/src/connection/manager.rs
Original file line number Diff line number Diff line change
Expand Up @@ -124,6 +124,14 @@ impl ConnectionRegistry {
})?;
f(sqlite)
}

/// Clone the SQLite connection Arc so callers can drop the registry lock.
pub fn sqlite_connection_arc(
&self,
id: &ConnectionId,
) -> ConnectionResult<std::sync::Arc<std::sync::Mutex<Option<rusqlite::Connection>>>> {
self.with_sqlite(id, |s| Ok(s.connection_arc()))
}
}

impl ConnectionManager for ConnectionRegistry {
Expand Down
3 changes: 3 additions & 0 deletions apps/tauri/src-tauri/src/connection/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -4,14 +4,17 @@ mod error;
mod id;
mod introspect;
mod manager;
mod query;
mod sqlite;
mod sqlite_introspect;
pub(crate) mod sqlite_query;

pub use error::ConnectionError;
pub use id::{ConnectionId, DriverKind};
pub use introspect::{ColumnMeta, SchemaObject, SchemaObjectKind, TableSchema};
pub use manager::{ConnectionConfig, ConnectionManager, ConnectionRegistry};
#[allow(unused_imports)] // public API for later IPC / frontend issues
pub use manager::ConnectionSession;
pub use query::QueryEvent;
#[allow(unused_imports)] // public API for later IPC / frontend issues
pub use sqlite::{open_sqlite, SqliteSession};
26 changes: 26 additions & 0 deletions apps/tauri/src-tauri/src/connection/query.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,26 @@
//! Query result streaming events (shared IPC shape).

use serde::Serialize;

/// Events pushed over a Tauri [`tauri::ipc::Channel`] during `db_execute_query`.
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum QueryEvent {
Columns {
names: Vec<String>,
},
Rows {
rows: Vec<Vec<serde_json::Value>>,
offset: u64,
},
Done {
row_count: u64,
truncated: bool,
#[serde(skip_serializing_if = "Option::is_none")]
affected_rows: Option<u64>,
elapsed_ms: u64,
},
Error {
message: String,
},
}
28 changes: 22 additions & 6 deletions apps/tauri/src-tauri/src/connection/sqlite.rs
Original file line number Diff line number Diff line change
Expand Up @@ -3,22 +3,27 @@
use super::error::{ConnectionError, ConnectionResult};
use super::id::{ConnectionId, DriverKind};
use super::manager::ConnectionSession;
use super::query::QueryEvent;
use rusqlite::Connection;
use std::path::Path;
use std::sync::Mutex;
use std::sync::{Arc, Mutex};

pub struct SqliteSession {
id: ConnectionId,
path: String,
/// rusqlite::Connection is !Sync — guard for Tauri/registry threads.
conn: Mutex<Option<Connection>>,
/// Shared so query streaming can drop the registry lock.
conn: Arc<Mutex<Option<Connection>>>,
}

impl SqliteSession {
pub fn path(&self) -> &str {
&self.path
}

pub fn connection_arc(&self) -> Arc<Mutex<Option<Connection>>> {
Arc::clone(&self.conn)
}

pub fn with_connection<T>(
&self,
f: impl FnOnce(&Connection) -> ConnectionResult<T>,
Expand Down Expand Up @@ -49,6 +54,17 @@ impl SqliteSession {
) -> ConnectionResult<super::introspect::TableSchema> {
self.with_connection(|c| super::sqlite_introspect::list_columns(c, table))
}

pub fn execute_streaming(
&self,
sql: &str,
limit: Option<usize>,
emit: impl FnMut(QueryEvent) -> ConnectionResult<()>,
) -> ConnectionResult<()> {
self.with_connection(|c| {
super::sqlite_query::execute_streaming(c, sql, limit, None, emit)
})
}
}

impl ConnectionSession for SqliteSession {
Expand All @@ -61,9 +77,9 @@ impl ConnectionSession for SqliteSession {
}

fn disconnect(&mut self) -> ConnectionResult<()> {
let guard = self
let mut guard = self
.conn
.get_mut()
.lock()
.map_err(|_| ConnectionError::io("sqlite connection lock poisoned"))?;
if let Some(conn) = guard.take() {
conn.close()
Expand Down Expand Up @@ -103,7 +119,7 @@ pub fn open_sqlite(path: impl AsRef<str>) -> ConnectionResult<Box<dyn Connection
Ok(Box::new(SqliteSession {
id: ConnectionId::new(),
path: path.to_owned(),
conn: Mutex::new(Some(conn)),
conn: Arc::new(Mutex::new(Some(conn))),
}))
}

Expand Down
Loading
Loading