diff --git a/apps/tauri/src-tauri/Cargo.lock b/apps/tauri/src-tauri/Cargo.lock index e881438b..b7e43402 100644 --- a/apps/tauri/src-tauri/Cargo.lock +++ b/apps/tauri/src-tauri/Cargo.lock @@ -74,6 +74,12 @@ dependencies = [ "object", ] +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + [[package]] name = "async-broadcast" version = "0.7.2" @@ -349,6 +355,30 @@ dependencies = [ "piper", ] +[[package]] +name = "borsh" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "553c5d846a6ba5150c65e3b1b8ec073bcf1abc20f9b7220de384a4443ea4e20a" +dependencies = [ + "borsh-derive", + "bytes", + "cfg_aliases", +] + +[[package]] +name = "borsh-derive" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12cdfe656708a01f89b451a7d36466e6fe6c414de0aa18fc54f864f6f9ca9f56" +dependencies = [ + "once_cell", + "proc-macro-crate 3.5.0", + "proc-macro2", + "quote", + "syn 3.0.10", +] + [[package]] name = "brotli" version = "9.1.1" @@ -517,6 +547,12 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + [[package]] name = "chrono" version = "0.4.45" @@ -2485,7 +2521,7 @@ dependencies = [ "num-integer", "num-iter", "num-traits", - "rand", + "rand 0.8.8", "smallvec", "zeroize", ] @@ -3177,6 +3213,7 @@ dependencies = [ "futures-util", "keyring", "rusqlite", + "rust_decimal", "serde", "serde_json", "sqlparser", @@ -3226,8 +3263,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c" dependencies = [ "libc", - "rand_chacha", - "rand_core", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.5", ] [[package]] @@ -3237,7 +3284,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" dependencies = [ "ppv-lite86", - "rand_core", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", ] [[package]] @@ -3249,6 +3306,15 @@ dependencies = [ "getrandom 0.2.17", ] +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + [[package]] name = "raw-window-handle" version = "0.6.2" @@ -3436,7 +3502,7 @@ dependencies = [ "num-traits", "pkcs1", "pkcs8", - "rand_core", + "rand_core 0.6.4", "signature", "spki", "subtle", @@ -3457,6 +3523,23 @@ dependencies = [ "smallvec", ] +[[package]] +name = "rust_decimal" +version = "1.43.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7653272e75dcac41dc199fbea6f5797633994fafd339943c06c9af16bf29cd3a" +dependencies = [ + "arrayvec", + "borsh", + "bytes", + "num-traits", + "rand 0.8.8", + "rand 0.9.5", + "serde", + "serde_json", + "wasm-bindgen", +] + [[package]] name = "rustc-hash" version = "2.1.3" @@ -3870,7 +3953,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" dependencies = [ "digest", - "rand_core", + "rand_core 0.6.4", ] [[package]] @@ -4024,6 +4107,7 @@ dependencies = [ "memchr", "once_cell", "percent-encoding", + "rust_decimal", "serde", "serde_json", "sha2", @@ -4033,6 +4117,7 @@ dependencies = [ "tokio-stream", "tracing", "url", + "uuid", ] [[package]] @@ -4103,8 +4188,9 @@ dependencies = [ "memchr", "once_cell", "percent-encoding", - "rand", + "rand 0.8.8", "rsa", + "rust_decimal", "serde", "sha1", "sha2", @@ -4113,6 +4199,7 @@ dependencies = [ "stringprep", "thiserror 2.0.21", "tracing", + "uuid", "whoami", ] @@ -4142,7 +4229,8 @@ dependencies = [ "md-5", "memchr", "once_cell", - "rand", + "rand 0.8.8", + "rust_decimal", "serde", "serde_json", "sha2", @@ -4151,6 +4239,7 @@ dependencies = [ "stringprep", "thiserror 2.0.21", "tracing", + "uuid", "whoami", ] @@ -4177,6 +4266,7 @@ dependencies = [ "thiserror 2.0.21", "tracing", "url", + "uuid", ] [[package]] @@ -5255,6 +5345,7 @@ checksum = "a0181c14ddd6c7b8b0b0132a5f1ea2f32be0d893cd3ea97b6e3b28886b8a3d1c" dependencies = [ "cfg-if", "rustversion", + "serde", "wasm-bindgen-macro", "wasm-bindgen-shared", ] diff --git a/apps/tauri/src-tauri/Cargo.toml b/apps/tauri/src-tauri/Cargo.toml index 2435e08c..49e5ad29 100644 --- a/apps/tauri/src-tauri/Cargo.toml +++ b/apps/tauri/src-tauri/Cargo.toml @@ -27,11 +27,14 @@ sqlx = { version = "0.8", default-features = false, features = [ "postgres", "json", "chrono", + "rust_decimal", + "uuid", ] } futures-util = "0.3" chrono = { version = "0.4", default-features = false, features = ["clock", "std"] } keyring = { version = "3", features = ["apple-native", "windows-native", "linux-native-sync-persistent"] } sqlparser = "0.64" +rust_decimal = { version = "1", features = ["serde"] } [profile.release] codegen-units = 1 diff --git a/apps/tauri/src-tauri/src/connection/error.rs b/apps/tauri/src-tauri/src/connection/error.rs index a3bbb538..a5da31d3 100644 --- a/apps/tauri/src-tauri/src/connection/error.rs +++ b/apps/tauri/src-tauri/src/connection/error.rs @@ -13,8 +13,11 @@ pub enum ConnectionError { UnsupportedDriver { driver: DriverKind }, Io { message: String }, Driver { driver: DriverKind, message: String }, - /// sqlparser / product SQL guard refusal (`rule` is a stable id). - SqlGuard { rule: String, message: String }, + /// sqlparser / product SQL guard refusal (typed `rule` for UI branching). + SqlGuard { + rule: super::sql_guard::SqlGuardRule, + message: String, + }, } impl ConnectionError { @@ -42,7 +45,7 @@ impl ConnectionError { message: impl Into, ) -> Self { Self::SqlGuard { - rule: rule.as_str().to_owned(), + rule, message: message.into(), } } @@ -63,7 +66,7 @@ impl fmt::Display for ConnectionError { write!(f, "{driver} error: {message}") } Self::SqlGuard { rule, message } => { - write!(f, "sql guard ({rule}): {message}") + write!(f, "sql guard ({}): {message}", rule.as_str()) } } } diff --git a/apps/tauri/src-tauri/src/connection/manager.rs b/apps/tauri/src-tauri/src/connection/manager.rs index 5e4d19c6..f85905ae 100644 --- a/apps/tauri/src-tauri/src/connection/manager.rs +++ b/apps/tauri/src-tauri/src/connection/manager.rs @@ -432,7 +432,7 @@ mod tests { .unwrap_err(); match err { ConnectionError::SqlGuard { rule, .. } => { - assert_eq!(rule, "single_statement"); + assert_eq!(rule.as_str(), "single_statement"); } other => panic!("expected SqlGuard, got {other:?}"), } diff --git a/apps/tauri/src-tauri/src/connection/object_tree.rs b/apps/tauri/src-tauri/src/connection/object_tree.rs index 4f1b768d..3ca0f2b5 100644 --- a/apps/tauri/src-tauri/src/connection/object_tree.rs +++ b/apps/tauri/src-tauri/src/connection/object_tree.rs @@ -1,4 +1,4 @@ -//! Driver-agnostic SQL object tree (schemas → tables/views → columns). +//! Driver-agnostic SQL object tree (schemas → folders → objects → columns). use super::error::{ConnectionError, ConnectionResult}; use super::id::DriverKind; @@ -10,39 +10,111 @@ use serde::{Deserialize, Serialize}; #[serde(rename_all = "snake_case")] pub enum SqlObjectKind { Schema, + /// Virtual group under a schema (Tables, Functions, Indexes, …). + Folder, Table, View, + MaterializedView, Column, Index, Trigger, Function, Procedure, + Sequence, + /// User-defined type (enum / composite / domain / range). + #[serde(rename = "type")] + Type, +} + +/// Schema-level folder keys (Flutter `connections_panel_pg_tree` parity). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum SchemaFolderKind { + Tables, + Views, + MaterializedViews, + Functions, + Sequences, + Indexes, + Triggers, + Types, +} + +impl SchemaFolderKind { + pub fn as_str(self) -> &'static str { + match self { + Self::Tables => "tables", + Self::Views => "views", + Self::MaterializedViews => "materialized_views", + Self::Functions => "functions", + Self::Sequences => "sequences", + Self::Indexes => "indexes", + Self::Triggers => "triggers", + Self::Types => "types", + } + } + + pub fn label(self) -> &'static str { + match self { + Self::Tables => "Tables", + Self::Views => "Views", + Self::MaterializedViews => "Materialized views", + Self::Functions => "Functions", + Self::Sequences => "Sequences", + Self::Indexes => "Indexes", + Self::Triggers => "Triggers", + Self::Types => "Types", + } + } + + pub fn parse(s: &str) -> Option { + Self::ALL.into_iter().find(|folder| folder.as_str() == s) + } + + pub const ALL: [Self; 8] = [ + Self::Tables, + Self::Views, + Self::MaterializedViews, + Self::Functions, + Self::Sequences, + Self::Indexes, + Self::Triggers, + Self::Types, + ]; } impl SqlObjectKind { pub fn as_str(self) -> &'static str { match self { Self::Schema => "schema", + Self::Folder => "folder", Self::Table => "table", Self::View => "view", + Self::MaterializedView => "materialized_view", Self::Column => "column", Self::Index => "index", Self::Trigger => "trigger", Self::Function => "function", Self::Procedure => "procedure", + Self::Sequence => "sequence", + Self::Type => "type", } } fn parse(s: &str) -> Option { match s { "schema" => Some(Self::Schema), + "folder" => Some(Self::Folder), "table" => Some(Self::Table), "view" => Some(Self::View), + "materialized_view" => Some(Self::MaterializedView), "column" => Some(Self::Column), "index" => Some(Self::Index), "trigger" => Some(Self::Trigger), "function" => Some(Self::Function), "procedure" => Some(Self::Procedure), + "sequence" => Some(Self::Sequence), + "type" => Some(Self::Type), _ => None, } } @@ -50,12 +122,19 @@ impl SqlObjectKind { pub fn is_expandable(self) -> bool { matches!( self, - Self::Schema | Self::Table | Self::View | Self::Index | Self::Function | Self::Procedure + Self::Schema + | Self::Folder + | Self::Table + | Self::View + | Self::MaterializedView ) } pub fn is_relation(self) -> bool { - matches!(self, Self::Table | Self::View) + matches!( + self, + Self::Table | Self::View | Self::MaterializedView + ) } } @@ -127,6 +206,15 @@ pub fn schema_id(driver: DriverKind, schema: &str) -> String { format!("{}:schema:{}", driver.as_str(), enc_segment(schema)) } +pub fn folder_id(driver: DriverKind, schema: &str, folder: SchemaFolderKind) -> String { + format!( + "{}:folder:{}:{}", + driver.as_str(), + enc_segment(schema), + folder.as_str() + ) +} + pub fn relation_id(driver: DriverKind, kind: SqlObjectKind, schema: &str, name: &str) -> String { debug_assert!(kind.is_relation()); format!( @@ -148,6 +236,40 @@ pub fn column_id(driver: DriverKind, schema: &str, table: &str, column: &str) -> ) } +/// Schema-scoped object (function / sequence / type / …). +pub fn named_object_id( + driver: DriverKind, + kind: SqlObjectKind, + schema: &str, + name: &str, +) -> String { + format!( + "{}:{}:{}:{}", + driver.as_str(), + kind.as_str(), + enc_segment(schema), + enc_segment(name) + ) +} + +/// Index or trigger scoped to a relation: `driver:kind:schema:table:name`. +pub fn relation_child_id( + driver: DriverKind, + kind: SqlObjectKind, + schema: &str, + table: &str, + name: &str, +) -> String { + format!( + "{}:{}:{}:{}:{}", + driver.as_str(), + kind.as_str(), + enc_segment(schema), + enc_segment(table), + enc_segment(name) + ) +} + /// Parsed object id. #[derive(Debug, Clone, PartialEq, Eq)] pub enum ParsedObjectId { @@ -155,6 +277,11 @@ pub enum ParsedObjectId { driver: DriverKind, schema: String, }, + Folder { + driver: DriverKind, + schema: String, + folder: SchemaFolderKind, + }, Relation { driver: DriverKind, kind: SqlObjectKind, @@ -167,23 +294,42 @@ pub enum ParsedObjectId { table: String, column: String, }, + /// Function / sequence / type / procedure under a schema. + Named { + driver: DriverKind, + kind: SqlObjectKind, + schema: String, + name: String, + }, + /// Index / trigger under a relation. + RelationChild { + driver: DriverKind, + kind: SqlObjectKind, + schema: String, + table: String, + name: String, + }, } fn bad_id(msg: impl Into) -> ConnectionError { ConnectionError::invalid_config(msg) } +fn parse_driver(s: &str) -> ConnectionResult { + match s { + "sqlite" => Ok(DriverKind::Sqlite), + "postgres" => Ok(DriverKind::Postgres), + "mysql" => Ok(DriverKind::Mysql), + other => Err(bad_id(format!("unknown driver in object id: {other}"))), + } +} + pub fn parse_object_id(id: &str) -> ConnectionResult { let parts: Vec<&str> = id.split(':').collect(); if parts.len() < 3 { return Err(bad_id(format!("invalid object id: {id}"))); } - let driver = match parts[0] { - "sqlite" => DriverKind::Sqlite, - "postgres" => DriverKind::Postgres, - "mysql" => DriverKind::Mysql, - other => return Err(bad_id(format!("unknown driver in object id: {other}"))), - }; + let driver = parse_driver(parts[0])?; let kind = SqlObjectKind::parse(parts[1]) .ok_or_else(|| bad_id(format!("unknown object kind in id: {id}")))?; @@ -192,7 +338,18 @@ pub fn parse_object_id(id: &str) -> ConnectionResult { driver, schema: dec_segment(parts[2]), }), - SqlObjectKind::Table | SqlObjectKind::View if parts.len() == 4 => { + SqlObjectKind::Folder if parts.len() == 4 => { + let folder = SchemaFolderKind::parse(parts[3]) + .ok_or_else(|| bad_id(format!("unknown folder kind in id: {id}")))?; + Ok(ParsedObjectId::Folder { + driver, + schema: dec_segment(parts[2]), + folder, + }) + } + SqlObjectKind::Table | SqlObjectKind::View | SqlObjectKind::MaterializedView + if parts.len() == 4 => + { Ok(ParsedObjectId::Relation { driver, kind, @@ -206,15 +363,29 @@ pub fn parse_object_id(id: &str) -> ConnectionResult { table: dec_segment(parts[3]), column: dec_segment(parts[4]), }), - SqlObjectKind::Schema => Err(bad_id(format!("invalid schema id: {id}"))), - SqlObjectKind::Table | SqlObjectKind::View => { - Err(bad_id(format!("invalid relation id: {id}"))) + SqlObjectKind::Function + | SqlObjectKind::Procedure + | SqlObjectKind::Sequence + | SqlObjectKind::Type + if parts.len() == 4 => + { + Ok(ParsedObjectId::Named { + driver, + kind, + schema: dec_segment(parts[2]), + name: dec_segment(parts[3]), + }) + } + SqlObjectKind::Index | SqlObjectKind::Trigger if parts.len() == 5 => { + Ok(ParsedObjectId::RelationChild { + driver, + kind, + schema: dec_segment(parts[2]), + table: dec_segment(parts[3]), + name: dec_segment(parts[4]), + }) } - SqlObjectKind::Column => Err(bad_id(format!("invalid column id: {id}"))), - other => Err(bad_id(format!( - "object kind {:?} not supported in ids yet", - other - ))), + _ => Err(bad_id(format!("invalid object id: {id}"))), } } @@ -253,4 +424,31 @@ mod tests { other => panic!("unexpected {other:?}"), } } + + #[test] + fn folder_and_function_ids_round_trip() { + let fid = folder_id(DriverKind::Postgres, "shop", SchemaFolderKind::Functions); + assert_eq!(fid, "postgres:folder:shop:functions"); + match parse_object_id(&fid).unwrap() { + ParsedObjectId::Folder { folder, schema, .. } => { + assert_eq!(schema, "shop"); + assert_eq!(folder, SchemaFolderKind::Functions); + } + other => panic!("unexpected {other:?}"), + } + + let fn_id = named_object_id( + DriverKind::Postgres, + SqlObjectKind::Function, + "shop", + "total_orders", + ); + match parse_object_id(&fn_id).unwrap() { + ParsedObjectId::Named { kind, name, .. } => { + assert_eq!(kind, SqlObjectKind::Function); + assert_eq!(name, "total_orders"); + } + other => panic!("unexpected {other:?}"), + } + } } diff --git a/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs b/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs index 1a8b3514..d57e981d 100644 --- a/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs +++ b/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs @@ -1,15 +1,20 @@ -//! Postgres object tree: schemas → tables/views → columns. +//! Postgres object tree: schemas → folders → objects (Flutter pg tree parity). use super::error::{ConnectionError, ConnectionResult}; use super::id::DriverKind; use super::introspect::{ColumnMeta, TableSchema}; use super::object_tree::{ - column_id, parse_object_id, relation_id, schema_id, ObjectTreeProvider, ParsedObjectId, - SqlObjectKind, SqlObjectNode, + column_id, folder_id, named_object_id, parse_object_id, relation_child_id, relation_id, + schema_id, ObjectTreeProvider, ParsedObjectId, SchemaFolderKind, SqlObjectKind, SqlObjectNode, }; use super::postgres::PostgresSession; use super::runtime; use sqlx::Row; +use std::fmt::Display; + +fn postgres_err(e: impl Display) -> ConnectionError { + ConnectionError::driver(DriverKind::Postgres, e.to_string()) +} pub struct PostgresObjectTree { session: PostgresSession, @@ -26,14 +31,19 @@ impl ObjectTreeProvider for PostgresObjectTree { match parent_id { None => self.list_schemas(), Some(pid) => match parse_object_id(pid)? { - ParsedObjectId::Schema { schema, .. } => self.list_relations(&schema), + ParsedObjectId::Schema { schema, .. } => self.list_schema_folders(&schema), + ParsedObjectId::Folder { schema, folder, .. } => { + self.list_folder_children(&schema, folder) + } ParsedObjectId::Relation { kind, schema, name, .. } => self.list_columns_nodes(kind, &schema, &name), - ParsedObjectId::Column { .. } => Ok(vec![]), + ParsedObjectId::Column { .. } + | ParsedObjectId::Named { .. } + | ParsedObjectId::RelationChild { .. } => Ok(vec![]), }, } } @@ -62,7 +72,7 @@ impl PostgresObjectTree { ) .fetch_all(pool) .await - .map_err(|e| ConnectionError::driver(DriverKind::Postgres, e.to_string()))?; + .map_err(postgres_err)?; Ok(rows .into_iter() @@ -81,35 +91,144 @@ impl PostgresObjectTree { }) } - fn list_relations(&self, schema: &str) -> ConnectionResult> { + fn list_schema_folders(&self, schema: &str) -> ConnectionResult> { + let parent = schema_id(DriverKind::Postgres, schema); + Ok(SchemaFolderKind::ALL + .into_iter() + .map(|folder| { + SqlObjectNode::new( + folder_id(DriverKind::Postgres, schema, folder), + folder.label().to_owned(), + SqlObjectKind::Folder, + Some(schema.to_owned()), + Some(parent.clone()), + ) + }) + .collect()) + } + + fn list_folder_children( + &self, + schema: &str, + folder: SchemaFolderKind, + ) -> ConnectionResult> { + match folder { + SchemaFolderKind::Tables => self.list_relations(schema, RelationFilter::Tables), + SchemaFolderKind::Views => self.list_relations(schema, RelationFilter::Views), + SchemaFolderKind::MaterializedViews => { + self.list_relations(schema, RelationFilter::MaterializedViews) + } + SchemaFolderKind::Functions => self.list_named_objects( + schema, + "SELECT DISTINCT p.proname + FROM pg_proc p + JOIN pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = $1 + AND p.prokind IN ('f', 'a', 'w') + ORDER BY p.proname", + SchemaFolderKind::Functions, + SqlObjectKind::Function, + ), + SchemaFolderKind::Sequences => self.list_named_objects( + schema, + "SELECT c.relname + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 AND c.relkind = 'S' + ORDER BY c.relname", + SchemaFolderKind::Sequences, + SqlObjectKind::Sequence, + ), + SchemaFolderKind::Indexes => self.list_relation_children( + schema, + "SELECT c.relname::text, i.relname::text + FROM pg_index x + JOIN pg_class c ON c.oid = x.indrelid + JOIN pg_class i ON i.oid = x.indexrelid + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind IN ('r', 'm', 'p') + ORDER BY c.relname, i.relname", + SchemaFolderKind::Indexes, + SqlObjectKind::Index, + ), + SchemaFolderKind::Triggers => self.list_relation_children( + schema, + "SELECT c.relname::text, t.tgname::text + FROM pg_trigger t + JOIN pg_class c ON c.oid = t.tgrelid + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND NOT t.tgisinternal + ORDER BY c.relname, t.tgname", + SchemaFolderKind::Triggers, + SqlObjectKind::Trigger, + ), + SchemaFolderKind::Types => self.list_named_objects( + schema, + "SELECT t.typname::text + FROM pg_type t + JOIN pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = $1 + AND t.typtype IN ('c', 'd', 'e', 'r', 'm') + ORDER BY t.typname", + SchemaFolderKind::Types, + SqlObjectKind::Type, + ), + } + } + + fn list_relations( + &self, + schema: &str, + filter: RelationFilter, + ) -> ConnectionResult> { let schema_owned = schema.to_owned(); + let sql = match filter { + RelationFilter::Tables => { + "SELECT c.relname, c.relkind::text + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind IN ('r', 'p') + AND NOT c.relispartition + ORDER BY c.relname" + } + RelationFilter::Views => { + "SELECT c.relname, c.relkind::text + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind = 'v' + ORDER BY c.relname" + } + RelationFilter::MaterializedViews => { + "SELECT c.relname, c.relkind::text + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind = 'm' + ORDER BY c.relname" + } + }; self.session.with_pool(|pool| { runtime::block_on(async { - let rows = sqlx::query( - "SELECT c.relname, - CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'view' ELSE 'table' END - FROM pg_class c - JOIN pg_namespace n ON n.oid = c.relnamespace - WHERE n.nspname = $1 - AND c.relkind IN ('r', 'p', 'v', 'm') - AND NOT c.relispartition - ORDER BY c.relname", - ) - .bind(&schema_owned) - .fetch_all(pool) - .await - .map_err(|e| ConnectionError::driver(DriverKind::Postgres, e.to_string()))?; + let rows = sqlx::query(sql) + .bind(&schema_owned) + .fetch_all(pool) + .await + .map_err(postgres_err)?; - let parent = schema_id(DriverKind::Postgres, &schema_owned); + let parent = folder_id(DriverKind::Postgres, &schema_owned, filter.folder()); Ok(rows .into_iter() .map(|r| { let name: String = r.get(0); - let kind_s: String = r.get(1); - let kind = if kind_s == "view" { - SqlObjectKind::View - } else { - SqlObjectKind::Table + let relkind: String = r.get(1); + let kind = match relkind.as_str() { + "v" => SqlObjectKind::View, + "m" => SqlObjectKind::MaterializedView, + _ => SqlObjectKind::Table, }; SqlObjectNode::new( relation_id(DriverKind::Postgres, kind, &schema_owned, &name), @@ -124,6 +243,82 @@ impl PostgresObjectTree { }) } + fn list_named_objects( + &self, + schema: &str, + sql: &str, + folder: SchemaFolderKind, + kind: SqlObjectKind, + ) -> ConnectionResult> { + let schema_owned = schema.to_owned(); + self.session.with_pool(|pool| { + runtime::block_on(async { + let rows = sqlx::query(sql) + .bind(&schema_owned) + .fetch_all(pool) + .await + .map_err(postgres_err)?; + + let parent = folder_id(DriverKind::Postgres, &schema_owned, folder); + Ok(rows + .into_iter() + .map(|r| { + let name: String = r.get(0); + SqlObjectNode::new( + named_object_id(DriverKind::Postgres, kind, &schema_owned, &name), + name, + kind, + Some(schema_owned.clone()), + Some(parent.clone()), + ) + }) + .collect()) + }) + }) + } + + fn list_relation_children( + &self, + schema: &str, + sql: &str, + folder: SchemaFolderKind, + kind: SqlObjectKind, + ) -> ConnectionResult> { + let schema_owned = schema.to_owned(); + self.session.with_pool(|pool| { + runtime::block_on(async { + let rows = sqlx::query(sql) + .bind(&schema_owned) + .fetch_all(pool) + .await + .map_err(postgres_err)?; + + let parent = folder_id(DriverKind::Postgres, &schema_owned, folder); + Ok(rows + .into_iter() + .map(|r| { + let table: String = r.get(0); + let name: String = r.get(1); + let label = format!("{table}.{name}"); + SqlObjectNode::new( + relation_child_id( + DriverKind::Postgres, + kind, + &schema_owned, + &table, + &name, + ), + label, + kind, + Some(schema_owned.clone()), + Some(parent.clone()), + ) + }) + .collect()) + }) + }) + } + fn list_columns_nodes( &self, kind: SqlObjectKind, @@ -181,13 +376,10 @@ impl PostgresObjectTree { .bind(&table) .fetch_all(pool) .await - .map_err(|e| ConnectionError::driver(DriverKind::Postgres, e.to_string()))?; + .map_err(postgres_err)?; if rows.is_empty() { - return Err(ConnectionError::driver( - DriverKind::Postgres, - format!("relation {schema}.{table} not found"), - )); + return Err(postgres_err(format!("relation {schema}.{table} not found"))); } let mut columns = Vec::with_capacity(rows.len()); @@ -227,6 +419,22 @@ impl PostgresObjectTree { } } +enum RelationFilter { + Tables, + Views, + MaterializedViews, +} + +impl RelationFilter { + fn folder(self) -> SchemaFolderKind { + match self { + Self::Tables => SchemaFolderKind::Tables, + Self::Views => SchemaFolderKind::Views, + Self::MaterializedViews => SchemaFolderKind::MaterializedViews, + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -257,13 +465,38 @@ mod tests { let schemas = tree.list_children(None).expect("schemas"); assert!(schemas.iter().any(|s| s.name == "shop")); let shop = schemas.iter().find(|s| s.name == "shop").unwrap(); - let rels = tree.list_children(Some(&shop.id)).expect("rels"); - assert!(rels.iter().any(|r| r.name == "customers")); - let customers = rels.iter().find(|r| r.name == "customers").unwrap(); + + let folders = tree.list_children(Some(&shop.id)).expect("folders"); + let names: Vec<_> = folders.iter().map(|f| f.name.as_str()).collect(); + assert!(names.contains(&"Tables")); + assert!(names.contains(&"Functions")); + assert!(names.contains(&"Indexes")); + assert!(names.contains(&"Triggers")); + assert!(folders.iter().all(|f| f.kind == SqlObjectKind::Folder)); + + let tables_folder = folders.iter().find(|f| f.name == "Tables").unwrap(); + let tables = tree.list_children(Some(&tables_folder.id)).expect("tables"); + assert!(tables.iter().any(|r| r.name == "customers")); + + let customers = tables.iter().find(|r| r.name == "customers").unwrap(); let cols = tree.list_children(Some(&customers.id)).expect("cols"); assert!(cols.iter().any(|c| c.name == "id")); let desc = tree.describe(&customers.id).expect("describe"); assert!(desc.primary_keys.iter().any(|k| k == "id")); + + let fn_folder = folders.iter().find(|f| f.name == "Functions").unwrap(); + let functions = tree.list_children(Some(&fn_folder.id)).expect("functions"); + assert!( + !functions.is_empty(), + "shop schema should expose functions in the tree" + ); + assert!(functions.iter().all(|f| f.kind == SqlObjectKind::Function)); + + let idx_folder = folders.iter().find(|f| f.name == "Indexes").unwrap(); + let indexes = tree.list_children(Some(&idx_folder.id)).expect("indexes"); + assert!(indexes.iter().any(|i| i.name.contains("customers"))); + assert!(indexes.iter().all(|i| i.kind == SqlObjectKind::Index)); + session.disconnect().ok(); } } diff --git a/apps/tauri/src-tauri/src/connection/postgres_query.rs b/apps/tauri/src-tauri/src/connection/postgres_query.rs index 55fd51e2..b7b68881 100644 --- a/apps/tauri/src-tauri/src/connection/postgres_query.rs +++ b/apps/tauri/src-tauri/src/connection/postgres_query.rs @@ -119,51 +119,79 @@ fn pg_cell(row: &PgRow, i: usize) -> serde_json::Value { return serde_json::Value::Null; } + // sqlx matches Decode by exact Postgres type — INT4≠i64, FLOAT4≠f64, etc. let type_info = raw.type_info(); let type_name = type_info.name(); - - // Typed attempts — first match wins. - if type_name == "BOOL" { - if let Ok(v) = row.try_get::(i) { - return serde_json::Value::Bool(v); + match type_name { + "BOOL" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::Value::Bool(v); + } } - } - if matches!(type_name, "INT2" | "INT4" | "INT8") { - if let Ok(v) = row.try_get::(i) { - return serde_json::json!(v); + "INT2" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::json!(v); + } } - } - if matches!(type_name, "FLOAT4" | "FLOAT8") { - if let Ok(v) = row.try_get::(i) { - return serde_json::Number::from_f64(v) - .map(serde_json::Value::Number) - .unwrap_or(serde_json::Value::Null); + "INT4" | "OID" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::json!(v); + } } - } - if matches!(type_name, "JSON" | "JSONB") { - if let Ok(v) = row.try_get::(i) { - return v; + "INT8" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::json!(v); + } } - } - if type_name == "TIMESTAMPTZ" { - if let Ok(v) = row.try_get::, _>(i) { - return serde_json::Value::String(v.to_rfc3339()); + "FLOAT4" => { + if let Ok(v) = row.try_get::(i) { + return f64_json(f64::from(v)); + } } - } - if type_name == "TIMESTAMP" { - if let Ok(v) = row.try_get::(i) { - return serde_json::Value::String(v.format("%Y-%m-%dT%H:%M:%S%.f").to_string()); + "FLOAT8" => { + if let Ok(v) = row.try_get::(i) { + return f64_json(v); + } } - } - if type_name == "DATE" { - if let Ok(v) = row.try_get::(i) { - return serde_json::Value::String(v.to_string()); + "NUMERIC" => { + if let Ok(v) = row.try_get::(i) { + // Keep full precision as string (JSON number can't hold all NUMERIC). + return serde_json::Value::String(v.normalize().to_string()); + } } - } - if type_name == "BYTEA" { - if let Ok(v) = row.try_get::, _>(i) { - return serde_json::Value::String(bytes_to_hex(&v)); + "JSON" | "JSONB" => { + if let Ok(v) = row.try_get::(i) { + return v; + } + } + "TIMESTAMPTZ" => { + if let Ok(v) = row.try_get::, _>(i) { + return serde_json::Value::String(v.to_rfc3339()); + } + } + "TIMESTAMP" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::Value::String( + v.format("%Y-%m-%dT%H:%M:%S%.f").to_string(), + ); + } + } + "DATE" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::Value::String(v.to_string()); + } + } + "BYTEA" => { + if let Ok(v) = row.try_get::, _>(i) { + return serde_json::Value::String(bytes_to_hex(&v)); + } + } + "UUID" => { + if let Ok(v) = row.try_get::(i) { + return serde_json::Value::String(v.to_string()); + } } + _ => {} } if let Ok(v) = row.try_get::(i) { @@ -175,6 +203,12 @@ fn pg_cell(row: &PgRow, i: usize) -> serde_json::Value { serde_json::Value::String(format!("<{type_name}>")) } +fn f64_json(v: f64) -> serde_json::Value { + serde_json::Number::from_f64(v) + .map(serde_json::Value::Number) + .unwrap_or(serde_json::Value::Null) +} + fn bytes_to_hex(bytes: &[u8]) -> String { const HEX: &[u8] = b"0123456789abcdef"; let mut out = String::with_capacity(bytes.len() * 2); @@ -260,6 +294,59 @@ mod tests { }) .sum(); assert_eq!(rows, 5); + + // INT4 must decode to numbers — not the `` fallback placeholder. + let first_id = events.iter().find_map(|e| match e { + QueryEvent::Rows { rows, .. } => rows.first().and_then(|r| r.first()), + _ => None, + }); + match first_id { + Some(serde_json::Value::Number(n)) => assert!(n.as_i64().is_some()), + other => panic!("expected numeric id, got {other:?}"), + } + + session.disconnect().unwrap(); + } + + #[test] + fn live_postgres_decodes_numeric_not_placeholder() { + let Some(params) = live_params() else { + return; + }; + let session = match open_postgres(params) { + Ok(s) => s, + Err(_) => return, + }; + let mut events = Vec::new(); + session + .execute_streaming( + "SELECT id, total, discount FROM shop.orders ORDER BY id LIMIT 3", + Some(3), + |ev| { + events.push(ev); + Ok(()) + }, + ) + .expect("stream"); + let row = events.iter().find_map(|e| match e { + QueryEvent::Rows { rows, .. } => rows.first().cloned(), + _ => None, + }); + let Some(cells) = row else { + panic!("no rows"); + }; + assert!( + matches!(cells[0], serde_json::Value::Number(_)), + "id INT4: {cells:?}" + ); + assert!( + matches!(&cells[1], serde_json::Value::String(s) if !s.starts_with('<')), + "total NUMERIC: {cells:?}" + ); + assert!( + !matches!(&cells[1], serde_json::Value::String(s) if s == ""), + "total must not be type placeholder: {cells:?}" + ); session.disconnect().unwrap(); } diff --git a/apps/tauri/src-tauri/src/connection/sql_guard.rs b/apps/tauri/src-tauri/src/connection/sql_guard.rs index e9c61a6d..f730e915 100644 --- a/apps/tauri/src-tauri/src/connection/sql_guard.rs +++ b/apps/tauri/src-tauri/src/connection/sql_guard.rs @@ -18,6 +18,15 @@ pub enum SqlGuardRule { Parse, } +impl serde::Serialize for SqlGuardRule { + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer, + { + serializer.serialize_str(self.as_str()) + } +} + impl SqlGuardRule { pub fn as_str(self) -> &'static str { match self { @@ -89,7 +98,7 @@ mod tests { fn block_rule(sql: &str, driver: DriverKind, rule: SqlGuardRule) { let err = assert_single_statement(sql, driver).expect_err("expected block"); match err { - ConnectionError::SqlGuard { rule: r, .. } => assert_eq!(r, rule.as_str()), + ConnectionError::SqlGuard { rule: r, .. } => assert_eq!(r, rule), other => panic!("expected SqlGuard, got {other:?}"), } } diff --git a/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs b/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs index 94bb3984..134d5cb3 100644 --- a/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs +++ b/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs @@ -31,7 +31,10 @@ impl ObjectTreeProvider for SqliteObjectTree { ParsedObjectId::Relation { schema, name, .. } => { self.list_columns(&schema, &name, id) } - ParsedObjectId::Column { .. } => Ok(vec![]), + ParsedObjectId::Column { .. } + | ParsedObjectId::Folder { .. } + | ParsedObjectId::Named { .. } + | ParsedObjectId::RelationChild { .. } => Ok(vec![]), }, } } @@ -39,9 +42,9 @@ impl ObjectTreeProvider for SqliteObjectTree { fn describe(&self, object_id: &str) -> ConnectionResult { match parse_object_id(object_id)? { ParsedObjectId::Relation { name, .. } => self.session.list_columns(&name), - ParsedObjectId::Schema { .. } | ParsedObjectId::Column { .. } => Err( - ConnectionError::invalid_config("describe requires a table or view id"), - ), + _ => Err(ConnectionError::invalid_config( + "describe requires a table or view id", + )), } } } diff --git a/apps/tauri/src/api/connection.ts b/apps/tauri/src/api/connection.ts index 80665a41..74c3cdeb 100644 --- a/apps/tauri/src/api/connection.ts +++ b/apps/tauri/src/api/connection.ts @@ -10,13 +10,17 @@ export type SchemaObject = { export type SqlObjectKind = | "schema" + | "folder" | "table" | "view" + | "materialized_view" | "column" | "index" | "trigger" | "function" - | "procedure"; + | "procedure" + | "sequence" + | "type"; /** Stable tree node from `db_list_children`. */ export type SqlObjectNode = { @@ -28,6 +32,19 @@ export type SqlObjectNode = { expandable: boolean; }; +/** Mirrors Rust `ConnectionError` (serde tag = kind). */ +export type SqlGuardRule = "empty_query" | "single_statement" | "parse_error"; + +export type ConnectionError = + | { kind: "not_found"; id: string } + | { kind: "already_connected"; id: string } + | { kind: "disconnected"; id: string } + | { kind: "invalid_config"; message: string } + | { kind: "unsupported_driver"; driver: string } + | { kind: "io"; message: string } + | { kind: "driver"; driver: string; message: string } + | { kind: "sql_guard"; rule: SqlGuardRule; message: string }; + export type ColumnMeta = { name: string; data_type: string; @@ -193,16 +210,35 @@ export async function dbSqliteOverview(id: string): Promise { return invoke("db_sqlite_overview", { id }); } +export function isConnectionError(err: unknown): err is ConnectionError { + return ( + !!err && + typeof err === "object" && + typeof (err as { kind?: unknown }).kind === "string" + ); +} + export function formatConnectionError(err: unknown): string { if (typeof err === "string") return err; + if (isConnectionError(err)) { + switch (err.kind) { + case "sql_guard": + return `sql_guard: ${err.rule}: ${err.message}`; + case "driver": + return `${err.driver}: ${err.message}`; + case "not_found": + case "already_connected": + case "disconnected": + return `${err.kind}: ${err.id}`; + case "unsupported_driver": + return `unsupported_driver: ${err.driver}`; + case "invalid_config": + case "io": + return `${err.kind}: ${err.message}`; + } + } if (err && typeof err === "object") { const e = err as Record; - if (typeof e.kind === "string") { - const parts = [e.kind, e.driver, e.message, e.id].filter( - (v): v is string => typeof v === "string" && v.length > 0, - ); - return parts.join(": "); - } if (typeof e.message === "string") return e.message; } return String(err); diff --git a/apps/tauri/src/stores/objectTree.ts b/apps/tauri/src/stores/objectTree.ts index 254d7040..5a9e85a9 100644 --- a/apps/tauri/src/stores/objectTree.ts +++ b/apps/tauri/src/stores/objectTree.ts @@ -74,13 +74,22 @@ export function filterTree(nodes: TreeUiNode[], q: string): TreeUiNode[] { return out; } +function isRelationKind( + kind: TreeUiNode["kind"], +): kind is "table" | "view" | "materialized_view" { + return kind === "table" || kind === "view" || kind === "materialized_view"; +} + +/** Collect tables/views under schemas (and Postgres folder groups). */ function relationsOf(roots: TreeUiNode[]): TreeUiNode[] { const out: TreeUiNode[] = []; - for (const root of roots) { - for (const child of root.children ?? []) { - if (child.kind === "table" || child.kind === "view") out.push(child); + function walk(nodes: TreeUiNode[]) { + for (const n of nodes) { + if (isRelationKind(n.kind)) out.push(n); + if (n.children) walk(n.children); } } + walk(roots); return out; } diff --git a/apps/tauri/src/stores/shellNav.ts b/apps/tauri/src/stores/shellNav.ts index ea7a8f1c..4ce32b95 100644 --- a/apps/tauri/src/stores/shellNav.ts +++ b/apps/tauri/src/stores/shellNav.ts @@ -10,7 +10,7 @@ export type ObjectStripTab = "data" | "relations"; export type SelectedObject = { connectionId: string; name: string; - kind: "table" | "view"; + kind: "table" | "view" | "materialized_view"; /** Stable object id when known (`sqlite:table:main:users`). */ objectId?: string; schema?: string | null; diff --git a/apps/tauri/src/ui/ConnectionHome.vue b/apps/tauri/src/ui/ConnectionHome.vue index b32cb4a1..53ab5d43 100644 --- a/apps/tauri/src/ui/ConnectionHome.vue +++ b/apps/tauri/src/ui/ConnectionHome.vue @@ -27,7 +27,9 @@ const tables = computed(() => tree.relations.filter((o) => o.kind === "table"), ); const views = computed(() => - tree.relations.filter((o) => o.kind === "view"), + tree.relations.filter( + (o) => o.kind === "view" || o.kind === "materialized_view", + ), ); const overview = ref(null); @@ -119,7 +121,12 @@ watch( function openRelation(o: { id: string; name: string; kind: string; schema?: string | null }) { if (!conn.value) return; - if (o.kind !== "table" && o.kind !== "view") return; + if ( + o.kind !== "table" && + o.kind !== "view" && + o.kind !== "materialized_view" + ) + return; nav.selectObject({ connectionId: conn.value.id, name: o.name, diff --git a/apps/tauri/src/ui/ConnectionsPanel.vue b/apps/tauri/src/ui/ConnectionsPanel.vue index 4b25b60f..ff4e93b3 100644 --- a/apps/tauri/src/ui/ConnectionsPanel.vue +++ b/apps/tauri/src/ui/ConnectionsPanel.vue @@ -157,7 +157,12 @@ function onFolderExpand(id: string, e: MouseEvent) { } function onRelationClick(connectionId: string, node: TreeUiNode) { - if (node.kind !== "table" && node.kind !== "view") return; + if ( + node.kind !== "table" && + node.kind !== "view" && + node.kind !== "materialized_view" + ) + return; connections.select(connectionId); nav.selectObject({ connectionId, diff --git a/apps/tauri/src/ui/QuickSwitcher.vue b/apps/tauri/src/ui/QuickSwitcher.vue index 16c27eb1..a7ab7a5f 100644 --- a/apps/tauri/src/ui/QuickSwitcher.vue +++ b/apps/tauri/src/ui/QuickSwitcher.vue @@ -19,7 +19,7 @@ const input = ref(null); type Hit = { connectionId: string; name: string; - kind: "table" | "view"; + kind: "table" | "view" | "materialized_view"; connectionName: string; }; @@ -38,7 +38,7 @@ const hits = computed(() => { out.push({ connectionId: c.id, name: o.name, - kind: o.kind as "table" | "view", + kind: o.kind as "table" | "view" | "materialized_view", connectionName: c.name, }); } diff --git a/apps/tauri/src/ui/SqlObjectTreeNodes.vue b/apps/tauri/src/ui/SqlObjectTreeNodes.vue index 31a93194..967ae71d 100644 --- a/apps/tauri/src/ui/SqlObjectTreeNodes.vue +++ b/apps/tauri/src/ui/SqlObjectTreeNodes.vue @@ -18,8 +18,22 @@ function kindGlyph(kind: TreeUiNode["kind"]): string { switch (kind) { case "schema": return "▣"; + case "folder": + return "▸"; case "view": + case "materialized_view": return "◌"; + case "function": + case "procedure": + return "ƒ"; + case "sequence": + return "#"; + case "index": + return "⌘"; + case "trigger": + return "⚡"; + case "type": + return "T"; case "column": return "·"; default: @@ -27,8 +41,10 @@ function kindGlyph(kind: TreeUiNode["kind"]): string { } } -function isRelation(kind: TreeUiNode["kind"]): kind is "table" | "view" { - return kind === "table" || kind === "view"; +function isRelation( + kind: TreeUiNode["kind"], +): kind is "table" | "view" | "materialized_view" { + return kind === "table" || kind === "view" || kind === "materialized_view"; } function isSelected( @@ -74,7 +90,11 @@ function isSelected(