From 0d9273a4d9995a1ae35b854950b36968dfa4e068 Mon Sep 17 00:00:00 2001 From: ZhuchkaTriplesix Date: Sun, 15 Nov 2026 06:57:04 +0300 Subject: [PATCH] feat(rust): add SQLite schema introspection (schemas/tables/columns) Expose db_list_schemas / db_list_tables / db_list_columns over the registry with DTOs aligned to Flutter sqlite_connection, plus fixture tests. --- apps/tauri/src-tauri/src/commands.rs | 29 ++- .../src-tauri/src/connection/introspect.rs | 46 ++++ .../tauri/src-tauri/src/connection/manager.rs | 26 +++ apps/tauri/src-tauri/src/connection/mod.rs | 7 +- apps/tauri/src-tauri/src/connection/sqlite.rs | 54 ++++- .../src/connection/sqlite_introspect.rs | 200 ++++++++++++++++++ apps/tauri/src-tauri/src/lib.rs | 12 +- 7 files changed, 364 insertions(+), 10 deletions(-) create mode 100644 apps/tauri/src-tauri/src/connection/introspect.rs create mode 100644 apps/tauri/src-tauri/src/connection/sqlite_introspect.rs diff --git a/apps/tauri/src-tauri/src/commands.rs b/apps/tauri/src-tauri/src/commands.rs index 648a9528..d4f5c72e 100644 --- a/apps/tauri/src-tauri/src/commands.rs +++ b/apps/tauri/src-tauri/src/commands.rs @@ -1,5 +1,6 @@ use crate::connection::{ ConnectionConfig, ConnectionError, ConnectionId, ConnectionManager, ConnectionRegistry, + SchemaObject, TableSchema, }; use tauri::State; @@ -20,9 +21,31 @@ pub fn db_disconnect( } #[tauri::command] -pub fn db_is_connected( +pub fn db_is_connected(id: ConnectionId, registry: State<'_, ConnectionRegistry>) -> bool { + registry.is_connected(&id) +} + +#[tauri::command] +pub fn db_list_schemas( id: ConnectionId, registry: State<'_, ConnectionRegistry>, -) -> bool { - registry.is_connected(&id) +) -> Result, ConnectionError> { + registry.with_sqlite(&id, |s| s.list_schemas()) +} + +#[tauri::command] +pub fn db_list_tables( + id: ConnectionId, + registry: State<'_, ConnectionRegistry>, +) -> Result, ConnectionError> { + registry.with_sqlite(&id, |s| s.list_tables()) +} + +#[tauri::command] +pub fn db_list_columns( + id: ConnectionId, + table: String, + registry: State<'_, ConnectionRegistry>, +) -> Result { + registry.with_sqlite(&id, |s| s.list_columns(&table)) } diff --git a/apps/tauri/src-tauri/src/connection/introspect.rs b/apps/tauri/src-tauri/src/connection/introspect.rs new file mode 100644 index 00000000..23db1375 --- /dev/null +++ b/apps/tauri/src-tauri/src/connection/introspect.rs @@ -0,0 +1,46 @@ +//! Schema introspection DTOs shared across drivers (SQLite first). + +use serde::{Deserialize, Serialize}; + +/// Catalog object shown in the object tree. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub struct SchemaObject { + pub name: String, + pub kind: SchemaObjectKind, + /// SQLite uses `"main"`; other drivers may use real schema names. + #[serde(skip_serializing_if = "Option::is_none")] + pub schema: Option, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum SchemaObjectKind { + Table, + View, +} + +/// Column description for a table or view. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub struct ColumnMeta { + pub name: String, + pub data_type: String, + pub is_nullable: bool, + pub is_primary_key: bool, + #[serde(skip_serializing_if = "Option::is_none")] + pub primary_key_position: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub default_value: Option, +} + +/// Full table/view describe payload. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub struct TableSchema { + pub table_name: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub schema: Option, + pub columns: Vec, + pub primary_keys: Vec, +} diff --git a/apps/tauri/src-tauri/src/connection/manager.rs b/apps/tauri/src-tauri/src/connection/manager.rs index 57d97c0a..bd99ab13 100644 --- a/apps/tauri/src-tauri/src/connection/manager.rs +++ b/apps/tauri/src-tauri/src/connection/manager.rs @@ -1,6 +1,8 @@ use super::error::{ConnectionError, ConnectionResult}; use super::id::{ConnectionId, DriverKind}; +use super::sqlite::SqliteSession; use serde::{Deserialize, Serialize}; +use std::any::Any; use std::collections::HashMap; use std::sync::{Arc, Mutex}; @@ -44,6 +46,8 @@ pub trait ConnectionSession: Send + Sync { fn id(&self) -> &ConnectionId; fn driver(&self) -> DriverKind; fn disconnect(&mut self) -> ConnectionResult<()>; + /// Downcast hook for driver-specific APIs (introspection, query). + fn as_any(&self) -> &dyn Any; } /// Opens and tracks live DB sessions. @@ -101,6 +105,25 @@ impl ConnectionRegistry { .lock() .map_err(|_| ConnectionError::io("connection registry lock poisoned")) } + + /// Run a closure against a live [`SqliteSession`]. + pub fn with_sqlite( + &self, + id: &ConnectionId, + f: impl FnOnce(&SqliteSession) -> ConnectionResult, + ) -> ConnectionResult { + let map = self.lock()?; + let session = map + .get(id) + .ok_or_else(|| ConnectionError::NotFound { id: id.clone() })?; + let sqlite = session + .as_any() + .downcast_ref::() + .ok_or(ConnectionError::UnsupportedDriver { + driver: session.driver(), + })?; + f(sqlite) + } } impl ConnectionManager for ConnectionRegistry { @@ -160,6 +183,9 @@ mod tests { self.closed = true; Ok(()) } + fn as_any(&self) -> &dyn Any { + self + } } #[test] diff --git a/apps/tauri/src-tauri/src/connection/mod.rs b/apps/tauri/src-tauri/src/connection/mod.rs index 3f75adb2..6ba58642 100644 --- a/apps/tauri/src-tauri/src/connection/mod.rs +++ b/apps/tauri/src-tauri/src/connection/mod.rs @@ -2,13 +2,16 @@ mod error; mod id; +mod introspect; mod manager; mod sqlite; +mod sqlite_introspect; 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 / introspection issues +#[allow(unused_imports)] // public API for later IPC / frontend issues pub use manager::ConnectionSession; -#[allow(unused_imports)] // public API for later IPC / introspection issues +#[allow(unused_imports)] // public API for later IPC / frontend issues pub use sqlite::{open_sqlite, SqliteSession}; diff --git a/apps/tauri/src-tauri/src/connection/sqlite.rs b/apps/tauri/src-tauri/src/connection/sqlite.rs index c99a3fd7..e5d0c42d 100644 --- a/apps/tauri/src-tauri/src/connection/sqlite.rs +++ b/apps/tauri/src-tauri/src/connection/sqlite.rs @@ -15,12 +15,10 @@ pub struct SqliteSession { } impl SqliteSession { - #[allow(dead_code)] // used by introspection / query issues next pub fn path(&self) -> &str { &self.path } - #[allow(dead_code)] // used by execute_query / tree issues next pub fn with_connection( &self, f: impl FnOnce(&Connection) -> ConnectionResult, @@ -36,6 +34,21 @@ impl SqliteSession { })?; f(conn) } + + pub fn list_schemas(&self) -> ConnectionResult> { + self.with_connection(super::sqlite_introspect::list_schemas) + } + + pub fn list_tables(&self) -> ConnectionResult> { + self.with_connection(super::sqlite_introspect::list_tables) + } + + pub fn list_columns( + &self, + table: &str, + ) -> ConnectionResult { + self.with_connection(|c| super::sqlite_introspect::list_columns(c, table)) + } } impl ConnectionSession for SqliteSession { @@ -58,6 +71,10 @@ impl ConnectionSession for SqliteSession { } Ok(()) } + + fn as_any(&self) -> &dyn std::any::Any { + self + } } /// Open a SQLite database file and return a live session. @@ -139,4 +156,37 @@ mod tests { assert!(!reg.is_connected(&id)); let _ = std::fs::remove_file(&path); } + + #[test] + fn registry_introspect_fixture() { + let path = temp_db(); + let path_str = path.to_string_lossy().to_string(); + { + let conn = Connection::open(&path).unwrap(); + conn.execute_batch( + "CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT NOT NULL);", + ) + .unwrap(); + } + let reg = ConnectionRegistry::with_builtin_drivers(); + let id = reg + .connect(ConnectionConfig::Sqlite { + path: path_str, + }) + .expect("connect"); + let schemas = reg + .with_sqlite(&id, |s| s.list_schemas()) + .expect("schemas"); + assert_eq!(schemas, vec!["main".to_string()]); + let tables = reg.with_sqlite(&id, |s| s.list_tables()).expect("tables"); + assert_eq!(tables.len(), 1); + assert_eq!(tables[0].name, "t"); + let cols = reg + .with_sqlite(&id, |s| s.list_columns("t")) + .expect("columns"); + assert_eq!(cols.primary_keys, vec!["id".to_string()]); + assert_eq!(cols.columns.len(), 2); + reg.disconnect(&id).unwrap(); + let _ = std::fs::remove_file(&path); + } } diff --git a/apps/tauri/src-tauri/src/connection/sqlite_introspect.rs b/apps/tauri/src-tauri/src/connection/sqlite_introspect.rs new file mode 100644 index 00000000..922d2487 --- /dev/null +++ b/apps/tauri/src-tauri/src/connection/sqlite_introspect.rs @@ -0,0 +1,200 @@ +//! SQLite catalog queries — mirrors Flutter `sqlite_connection.dart`. + +use super::error::{ConnectionError, ConnectionResult}; +use super::id::DriverKind; +use super::introspect::{ColumnMeta, SchemaObject, SchemaObjectKind, TableSchema}; +use rusqlite::Connection; + +/// SQLite has no real schemas; expose the default attached DB name. +pub fn list_schemas(_conn: &Connection) -> ConnectionResult> { + Ok(vec!["main".into()]) +} + +/// Tables and views from `sqlite_master` (excludes internal `sqlite_%`). +pub fn list_tables(conn: &Connection) -> ConnectionResult> { + let mut stmt = conn + .prepare( + "SELECT name, type FROM sqlite_master \ + WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' \ + ORDER BY type ASC, name ASC", + ) + .map_err(|e| ConnectionError::driver(DriverKind::Sqlite, e.to_string()))?; + + let rows = stmt + .query_map([], |row| { + let name: String = row.get(0)?; + let type_str: String = row.get(1)?; + Ok((name, type_str)) + }) + .map_err(|e| ConnectionError::driver(DriverKind::Sqlite, e.to_string()))?; + + let mut out = Vec::new(); + for row in rows { + let (name, type_str) = + row.map_err(|e| ConnectionError::driver(DriverKind::Sqlite, e.to_string()))?; + let kind = match type_str.as_str() { + "view" => SchemaObjectKind::View, + _ => SchemaObjectKind::Table, + }; + out.push(SchemaObject { + name, + kind, + schema: Some("main".into()), + }); + } + Ok(out) +} + +/// Column meta via `PRAGMA table_info`. +pub fn list_columns(conn: &Connection, table: &str) -> ConnectionResult { + let table = table.trim(); + if table.is_empty() { + return Err(ConnectionError::invalid_config("table name is empty")); + } + if table.contains('\0') { + return Err(ConnectionError::invalid_config( + "table name contains NUL", + )); + } + + let sql = format!("PRAGMA table_info({})", quote_ident(table)); + let mut stmt = conn + .prepare(&sql) + .map_err(|e| ConnectionError::driver(DriverKind::Sqlite, e.to_string()))?; + + let rows = stmt + .query_map([], |row| { + let name: String = row.get(1)?; + let data_type: String = row.get::<_, Option>(2)?.unwrap_or_default(); + let notnull: i32 = row.get(3)?; + let dflt: Option = row.get(4)?; + let pk: i32 = row.get(5)?; + Ok((name, data_type, notnull, dflt, pk)) + }) + .map_err(|e| ConnectionError::driver(DriverKind::Sqlite, e.to_string()))?; + + let mut columns = Vec::new(); + let mut primary_keys = Vec::new(); + for row in rows { + let (name, data_type, notnull, dflt, pk) = + row.map_err(|e| ConnectionError::driver(DriverKind::Sqlite, e.to_string()))?; + let is_pk = pk > 0; + if is_pk { + primary_keys.push(name.clone()); + } + columns.push(ColumnMeta { + name, + data_type, + is_nullable: notnull == 0, + is_primary_key: is_pk, + primary_key_position: if is_pk { Some(pk) } else { None }, + default_value: dflt, + }); + } + + if columns.is_empty() { + // Distinguish missing table from empty (SQLite returns 0 rows for unknown). + let exists: bool = conn + .query_row( + "SELECT 1 FROM sqlite_master WHERE name = ?1 AND type IN ('table','view') LIMIT 1", + [table], + |_| Ok(true), + ) + .unwrap_or(false); + if !exists { + return Err(ConnectionError::driver( + DriverKind::Sqlite, + format!("no such table: {table}"), + )); + } + } + + Ok(TableSchema { + table_name: table.to_owned(), + schema: Some("main".into()), + columns, + primary_keys, + }) +} + +fn quote_ident(name: &str) -> String { + format!("\"{}\"", name.replace('"', "\"\"")) +} + +#[cfg(test)] +mod tests { + use super::*; + use rusqlite::Connection; + + fn fixture() -> Connection { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE users ( + id INTEGER PRIMARY KEY, + email TEXT NOT NULL UNIQUE, + bio TEXT DEFAULT '' + ); + CREATE VIEW user_emails AS SELECT id, email FROM users;", + ) + .unwrap(); + conn + } + + #[test] + fn schemas_is_main() { + let conn = fixture(); + assert_eq!(list_schemas(&conn).unwrap(), vec!["main".to_string()]); + } + + #[test] + fn lists_tables_and_views() { + let conn = fixture(); + let objs = list_tables(&conn).unwrap(); + assert_eq!(objs.len(), 2); + assert_eq!(objs[0].name, "users"); + assert_eq!(objs[0].kind, SchemaObjectKind::Table); + assert_eq!(objs[1].name, "user_emails"); + assert_eq!(objs[1].kind, SchemaObjectKind::View); + } + + #[test] + fn lists_columns_with_pk() { + let conn = fixture(); + let schema = list_columns(&conn, "users").unwrap(); + assert_eq!(schema.table_name, "users"); + assert_eq!(schema.primary_keys, vec!["id".to_string()]); + assert_eq!(schema.columns.len(), 3); + let id = &schema.columns[0]; + assert!(id.is_primary_key); + assert_eq!(id.primary_key_position, Some(1)); + let email = &schema.columns[1]; + assert!(!email.is_nullable); + assert_eq!(email.data_type.to_uppercase(), "TEXT"); + let bio = &schema.columns[2]; + assert!(bio.is_nullable); + assert_eq!(bio.default_value.as_deref(), Some("''")); + } + + #[test] + fn missing_table_errors() { + let conn = fixture(); + let err = list_columns(&conn, "nope").unwrap_err(); + assert!(matches!(err, ConnectionError::Driver { .. })); + } + + #[test] + fn quoted_weird_name_round_trips() { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch(r#"CREATE TABLE "weird""name" (id INTEGER PRIMARY KEY);"#) + .unwrap(); + let schema = list_columns(&conn, "weird\"name").unwrap(); + assert_eq!(schema.columns.len(), 1); + } + + #[test] + fn rejects_nul_in_table_name() { + let conn = fixture(); + let err = list_columns(&conn, "users\0x").unwrap_err(); + assert!(matches!(err, ConnectionError::InvalidConfig { .. })); + } +} diff --git a/apps/tauri/src-tauri/src/lib.rs b/apps/tauri/src-tauri/src/lib.rs index f89547b9..d896f905 100644 --- a/apps/tauri/src-tauri/src/lib.rs +++ b/apps/tauri/src-tauri/src/lib.rs @@ -2,11 +2,14 @@ mod commands; mod connection; pub use connection::{ - ConnectionConfig, ConnectionError, ConnectionId, ConnectionManager, ConnectionRegistry, - DriverKind, + ColumnMeta, ConnectionConfig, ConnectionError, ConnectionId, ConnectionManager, + ConnectionRegistry, DriverKind, SchemaObject, SchemaObjectKind, TableSchema, }; -use commands::{db_connect_sqlite, db_disconnect, db_is_connected}; +use commands::{ + db_connect_sqlite, db_disconnect, db_is_connected, db_list_columns, db_list_schemas, + db_list_tables, +}; #[tauri::command] fn app_info() -> serde_json::Value { @@ -41,6 +44,9 @@ pub fn run() { db_connect_sqlite, db_disconnect, db_is_connected, + db_list_schemas, + db_list_tables, + db_list_columns, ]) .run(tauri::generate_context!()) .expect("error while running tauri application");