drivers: fetch_indexes / fetch_foreign_keys (DDL UI #2)

Implement the new Connection trait methods on each driver so the
Structure tab can load existing indexes and FK constraints when
opening a table for editing.

- Postgres: pg_index + pg_constraint joined with pg_class /
  pg_attribute. array_agg(... ORDER BY ordinality) preserves the
  column order on composite indexes / FKs. confdeltype /
  confupdtype single-char codes map through pg_action_char_to_keyword
  to canonical SQL action keywords ("RESTRICT", "CASCADE", etc.).
- MySQL: information_schema.statistics for indexes (grouped by
  index_name in Rust since sqlx doesn't aggregate ordered column
  arrays natively); key_column_usage JOIN referential_constraints
  for FKs. "PRIMARY" maps to is_primary; non_unique inverts to unique.
- SQLite: PRAGMA index_list + per-index PRAGMA index_info. Implicit
  PK indexes that use the rowid alias don't appear in index_list
  so they're synthesised from PRAGMA table_info when no origin='pk'
  row exists. PRAGMA foreign_key_list grouped by synthetic id since
  SQLite doesn't store user-visible FK names — we render
  "fk_{table}_{id}" stably.

Author: datlechin

linux/crates/drivers/mysql/src/lib.rs

@@ -8,8 +8,8 @@ use sqlx::{Column, Pool, Row, TypeInfo};
 use futures::stream::StreamExt;
 
 use tablepro_core::{
-    ColumnInfo, ConnectOptions, Connection, DatabaseDriver, DriverError, ExecResult, MAX_QUERY_ROWS, QueryResult,
-    TableInfo, Value,
+    ColumnInfo, ConnectOptions, Connection, DatabaseDriver, DriverError, ExecResult, ForeignKeyInfo, IndexInfo,
+    MAX_QUERY_ROWS, QueryResult, TableInfo, Value,
 };
 
 pub struct MysqlDriver;
@@ -182,6 +182,94 @@ impl Connection for MysqlConnection {
         Ok(affected)
     }
 
+    async fn fetch_indexes(&self, schema: Option<&str>, table: &str) -> Result<Vec<IndexInfo>, DriverError> {
+        // information_schema.statistics returns one row per (index,
+        // column). Group rows by index_name in Rust because sqlx can't
+        // GROUP_CONCAT-then-split natively for ordered column lists.
+        // PRIMARY is the literal index name MySQL uses for the PK.
+        let rows = sqlx::query(
+            "SELECT
+                CAST(index_name AS CHAR) AS index_name,
+                non_unique,
+                CAST(column_name AS CHAR) AS column_name
+            FROM information_schema.statistics
+            WHERE table_schema = COALESCE(?, DATABASE())
+              AND table_name = ?
+            ORDER BY index_name, seq_in_index",
+        )
+        .bind(schema)
+        .bind(table)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(map_sqlx_error)?;
+        let mut by_name: std::collections::BTreeMap<String, IndexInfo> = std::collections::BTreeMap::new();
+        for r in rows {
+            let name: String = r.get(0);
+            let non_unique: i64 = r.try_get(1).unwrap_or(0);
+            let column: String = r.get(2);
+            let entry = by_name.entry(name.clone()).or_insert_with(|| IndexInfo {
+                name: name.clone(),
+                columns: Vec::new(),
+                unique: non_unique == 0,
+                primary: name == "PRIMARY",
+            });
+            entry.columns.push(column);
+        }
+        Ok(by_name.into_values().collect())
+    }
+
+    async fn fetch_foreign_keys(&self, schema: Option<&str>, table: &str) -> Result<Vec<ForeignKeyInfo>, DriverError> {
+        // key_column_usage gives us the FK column ↔ referenced column
+        // pairs (one row per (constraint, ordinal)); referential_constraints
+        // adds the ON DELETE / ON UPDATE rules. Group by constraint_name
+        // in Rust to assemble the column lists.
+        let rows = sqlx::query(
+            "SELECT
+                CAST(kcu.constraint_name AS CHAR),
+                CAST(kcu.column_name AS CHAR),
+                CAST(kcu.referenced_table_name AS CHAR),
+                CAST(kcu.referenced_table_schema AS CHAR),
+                CAST(kcu.referenced_column_name AS CHAR),
+                CAST(rc.delete_rule AS CHAR),
+                CAST(rc.update_rule AS CHAR)
+            FROM information_schema.key_column_usage kcu
+            JOIN information_schema.referential_constraints rc
+                ON rc.constraint_name = kcu.constraint_name
+                AND rc.constraint_schema = kcu.constraint_schema
+            WHERE kcu.table_schema = COALESCE(?, DATABASE())
+              AND kcu.table_name = ?
+              AND kcu.referenced_table_name IS NOT NULL
+            ORDER BY kcu.constraint_name, kcu.ordinal_position",
+        )
+        .bind(schema)
+        .bind(table)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(map_sqlx_error)?;
+        let mut by_name: std::collections::BTreeMap<String, ForeignKeyInfo> = std::collections::BTreeMap::new();
+        for r in rows {
+            let name: String = r.get(0);
+            let column: String = r.get(1);
+            let ref_table: String = r.get(2);
+            let ref_schema: Option<String> = r.try_get(3).unwrap_or(None);
+            let ref_column: String = r.get(4);
+            let delete_rule: Option<String> = r.try_get(5).ok();
+            let update_rule: Option<String> = r.try_get(6).ok();
+            let entry = by_name.entry(name.clone()).or_insert_with(|| ForeignKeyInfo {
+                name: name.clone(),
+                columns: Vec::new(),
+                ref_schema,
+                ref_table,
+                ref_columns: Vec::new(),
+                on_delete: delete_rule.filter(|s| !s.is_empty() && s != "NO ACTION"),
+                on_update: update_rule.filter(|s| !s.is_empty() && s != "NO ACTION"),
+            });
+            entry.columns.push(column);
+            entry.ref_columns.push(ref_column);
+        }
+        Ok(by_name.into_values().collect())
+    }
+
     async fn ping(&self) -> Result<(), DriverError> {
         sqlx::query("SELECT 1")
             .execute(&self.pool)

linux/crates/drivers/postgres/src/lib.rs

@@ -8,8 +8,8 @@ use sqlx::{Column, Pool, Postgres, Row, TypeInfo};
 use futures::stream::StreamExt;
 
 use tablepro_core::{
-    ColumnInfo, ConnectOptions, Connection, DatabaseDriver, DriverError, ExecResult, MAX_QUERY_ROWS, QueryResult,
-    TableInfo, Value,
+    ColumnInfo, ConnectOptions, Connection, DatabaseDriver, DriverError, ExecResult, ForeignKeyInfo, IndexInfo,
+    MAX_QUERY_ROWS, QueryResult, TableInfo, Value,
 };
 
 pub struct PgDriver;
@@ -207,6 +207,95 @@ impl Connection for PgConnection {
         Ok(affected)
     }
 
+    async fn fetch_indexes(&self, schema: Option<&str>, table: &str) -> Result<Vec<IndexInfo>, DriverError> {
+        // pg_index + pg_class + pg_attribute join. `array_agg ORDER BY
+        // ordinality` keeps the column order deterministic; pg_index
+        // stores `indkey` as an int2vector positional reference so we
+        // unnest with `WITH ORDINALITY` to capture position.
+        let rows = sqlx::query(
+            "SELECT
+                i.relname AS index_name,
+                ix.indisunique,
+                ix.indisprimary,
+                array_agg(a.attname ORDER BY k.ordinality) AS columns
+            FROM pg_catalog.pg_class t
+            JOIN pg_catalog.pg_namespace n ON t.relnamespace = n.oid
+            JOIN pg_catalog.pg_index ix ON ix.indrelid = t.oid
+            JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
+            JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ordinality) ON true
+            JOIN pg_catalog.pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+            WHERE n.nspname = COALESCE($2, current_schema())
+              AND t.relname = $1
+              AND a.attnum > 0
+            GROUP BY i.relname, ix.indisunique, ix.indisprimary
+            ORDER BY i.relname",
+        )
+        .bind(table)
+        .bind(schema)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(map_sqlx_error)?;
+        Ok(rows
+            .into_iter()
+            .map(|r| IndexInfo {
+                name: r.get::<String, _>(0),
+                unique: r.get::<bool, _>(1),
+                primary: r.get::<bool, _>(2),
+                columns: r.get::<Vec<String>, _>(3),
+            })
+            .collect())
+    }
+
+    async fn fetch_foreign_keys(&self, schema: Option<&str>, table: &str) -> Result<Vec<ForeignKeyInfo>, DriverError> {
+        // pg_constraint with contype = 'f'. confkey arrays are parallel
+        // to conkey via ordinality; the LATERAL join pairs them so the
+        // FK column ↔ referenced column mapping survives composite
+        // FKs. confdeltype / confupdtype are single chars normalised
+        // to canonical SQL keyword strings.
+        let rows = sqlx::query(
+            "SELECT
+                c.conname AS fk_name,
+                array_agg(a.attname ORDER BY kf.ordinality) AS columns,
+                fn_class.relname AS ref_table,
+                fn_ns.nspname AS ref_schema,
+                array_agg(fa.attname ORDER BY kf.ordinality) AS ref_columns,
+                c.confdeltype,
+                c.confupdtype
+            FROM pg_catalog.pg_constraint c
+            JOIN pg_catalog.pg_class t ON t.oid = c.conrelid
+            JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace
+            JOIN pg_catalog.pg_class fn_class ON fn_class.oid = c.confrelid
+            JOIN pg_catalog.pg_namespace fn_ns ON fn_ns.oid = fn_class.relnamespace
+            JOIN LATERAL unnest(c.conkey) WITH ORDINALITY AS kf(attnum, ordinality) ON true
+            JOIN pg_catalog.pg_attribute a ON a.attrelid = t.oid AND a.attnum = kf.attnum
+            JOIN LATERAL unnest(c.confkey) WITH ORDINALITY AS kfr(attnum, ordinality)
+                ON kfr.ordinality = kf.ordinality
+            JOIN pg_catalog.pg_attribute fa ON fa.attrelid = c.confrelid AND fa.attnum = kfr.attnum
+            WHERE c.contype = 'f'
+              AND n.nspname = COALESCE($2, current_schema())
+              AND t.relname = $1
+            GROUP BY c.conname, fn_class.relname, fn_ns.nspname, c.confdeltype, c.confupdtype
+            ORDER BY c.conname",
+        )
+        .bind(table)
+        .bind(schema)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(map_sqlx_error)?;
+        Ok(rows
+            .into_iter()
+            .map(|r| ForeignKeyInfo {
+                name: r.get::<String, _>(0),
+                columns: r.get::<Vec<String>, _>(1),
+                ref_table: r.get::<String, _>(2),
+                ref_schema: r.try_get::<Option<String>, _>(3).unwrap_or(None),
+                ref_columns: r.get::<Vec<String>, _>(4),
+                on_delete: pg_action_char_to_keyword(r.try_get::<String, _>(5).ok().as_deref().unwrap_or("a")),
+                on_update: pg_action_char_to_keyword(r.try_get::<String, _>(6).ok().as_deref().unwrap_or("a")),
+            })
+            .collect())
+    }
+
     async fn ping(&self) -> Result<(), DriverError> {
         sqlx::query("SELECT 1")
             .execute(&self.pool)
@@ -389,6 +478,21 @@ fn qualified(schema: Option<&str>, table: &str) -> String {
     }
 }
 
+/// Map `pg_constraint.confdeltype` / `confupdtype` single-char codes
+/// to canonical SQL action keywords. Returns `None` for the default
+/// "no action" so the FK builder can omit the redundant ON clause.
+fn pg_action_char_to_keyword(code: &str) -> Option<String> {
+    match code {
+        "r" => Some("RESTRICT".into()),
+        "c" => Some("CASCADE".into()),
+        "n" => Some("SET NULL".into()),
+        "d" => Some("SET DEFAULT".into()),
+        // 'a' = NO ACTION is the default; surface as None so the
+        // generated DDL stays clean.
+        _ => None,
+    }
+}
+
 fn map_sqlx_error(err: sqlx::Error) -> DriverError {
     use sqlx::Error::*;
     match err {

linux/crates/drivers/sqlite/src/lib.rs

@@ -8,8 +8,8 @@ use sqlx::{Column, Pool, Row, Sqlite, TypeInfo};
 use futures::stream::StreamExt;
 
 use tablepro_core::{
-    ColumnInfo, ConnectOptions, Connection, DatabaseDriver, DriverError, ExecResult, MAX_QUERY_ROWS, QueryResult,
-    TableInfo, Value,
+    ColumnInfo, ConnectOptions, Connection, DatabaseDriver, DriverError, ExecResult, ForeignKeyInfo, IndexInfo,
+    MAX_QUERY_ROWS, QueryResult, TableInfo, Value,
 };
 
 pub struct SqliteDriver;
@@ -196,6 +196,100 @@ impl Connection for SqliteConnection {
         Ok(affected)
     }
 
+    async fn fetch_indexes(&self, _schema: Option<&str>, table: &str) -> Result<Vec<IndexInfo>, DriverError> {
+        // SQLite catalog access is via PRAGMAs — they're scoped to the
+        // current database file (no schema parameter needed). For each
+        // entry from index_list we issue an index_info to get column
+        // ordering. PK index doesn't always show up in index_list (a
+        // bare INTEGER PRIMARY KEY uses the rowid alias, no real
+        // index), so we synthesise one from table_info if missing.
+        let list = sqlx::query(&format!("PRAGMA index_list({})", quote_ident(table)))
+            .fetch_all(&self.pool)
+            .await
+            .map_err(map_sqlx_error)?;
+        let mut out: Vec<IndexInfo> = Vec::with_capacity(list.len());
+        let mut saw_primary = false;
+        for r in list {
+            let name: String = r.try_get(1).map_err(map_sqlx_error)?;
+            let unique: i64 = r.try_get(2).unwrap_or(0);
+            let origin: String = r.try_get(3).unwrap_or_default();
+            let primary = origin == "pk";
+            if primary {
+                saw_primary = true;
+            }
+            let info_rows = sqlx::query(&format!("PRAGMA index_info({})", quote_ident(&name)))
+                .fetch_all(&self.pool)
+                .await
+                .map_err(map_sqlx_error)?;
+            let columns: Vec<String> = info_rows
+                .into_iter()
+                .map(|c| c.try_get::<String, _>(2).unwrap_or_default())
+                .collect();
+            out.push(IndexInfo {
+                name,
+                columns,
+                unique: unique == 1,
+                primary,
+            });
+        }
+        if !saw_primary {
+            // Synthesise the implicit PK index from PRAGMA table_info
+            // so the UI can render PK columns even when SQLite chose
+            // the rowid-alias path.
+            let table_info = sqlx::query(&format!("PRAGMA table_info({})", quote_ident(table)))
+                .fetch_all(&self.pool)
+                .await
+                .map_err(map_sqlx_error)?;
+            let pk_cols: Vec<String> = table_info
+                .into_iter()
+                .filter(|r| r.try_get::<i64, _>(5).unwrap_or(0) > 0)
+                .map(|r| r.try_get::<String, _>(1).unwrap_or_default())
+                .collect();
+            if !pk_cols.is_empty() {
+                out.push(IndexInfo {
+                    name: "PRIMARY".into(),
+                    columns: pk_cols,
+                    unique: true,
+                    primary: true,
+                });
+            }
+        }
+        Ok(out)
+    }
+
+    async fn fetch_foreign_keys(&self, _schema: Option<&str>, table: &str) -> Result<Vec<ForeignKeyInfo>, DriverError> {
+        // PRAGMA foreign_key_list returns one row per (constraint, ordinal)
+        // grouped by the synthetic `id` field. Constraint names aren't
+        // stored by SQLite, so we synthesise "fk_{table}_{id}" — stable
+        // across re-runs of the same schema. Group by id and build
+        // ForeignKeyInfo.
+        let rows = sqlx::query(&format!("PRAGMA foreign_key_list({})", quote_ident(table)))
+            .fetch_all(&self.pool)
+            .await
+            .map_err(map_sqlx_error)?;
+        let mut by_id: std::collections::BTreeMap<i64, ForeignKeyInfo> = std::collections::BTreeMap::new();
+        for r in rows {
+            let id: i64 = r.try_get(0).unwrap_or(0);
+            let ref_table: String = r.try_get(2).unwrap_or_default();
+            let from_col: String = r.try_get(3).unwrap_or_default();
+            let to_col: String = r.try_get(4).unwrap_or_default();
+            let on_update: String = r.try_get(5).unwrap_or_default();
+            let on_delete: String = r.try_get(6).unwrap_or_default();
+            let entry = by_id.entry(id).or_insert_with(|| ForeignKeyInfo {
+                name: format!("fk_{table}_{id}"),
+                columns: Vec::new(),
+                ref_schema: None,
+                ref_table,
+                ref_columns: Vec::new(),
+                on_delete: Some(on_delete.clone()).filter(|s| !s.is_empty() && s != "NO ACTION"),
+                on_update: Some(on_update.clone()).filter(|s| !s.is_empty() && s != "NO ACTION"),
+            });
+            entry.columns.push(from_col);
+            entry.ref_columns.push(to_col);
+        }
+        Ok(by_id.into_values().collect())
+    }
+
     async fn ping(&self) -> Result<(), DriverError> {
         sqlx::query("SELECT 1")
             .execute(&self.pool)