core: DDL builders + IndexInfo / ForeignKeyInfo (DDL UI #1)

Lay the core SQL-generation foundation for the upcoming Structure
workspace tab:

- crates/core/src/query.rs: IndexInfo + ForeignKeyInfo structs
  carrying secondary-index and FK metadata (with primary flag on
  the implicit PK index so the UI can render it as read-only).
- crates/core/src/connection.rs: extend the Connection trait with
  fetch_indexes() and fetch_foreign_keys() default impls returning
  empty Vec, so existing drivers compile before they're filled in.
- crates/core/src/read_only.rs: forward the two new reads to the
  inner connection (read-only blocks mutations, not introspection).
- crates/core/src/sql_ddl.rs: the full CREATE / DROP / ALTER DDL
  surface across MySQL + Postgres + SQLite — build_create_table,
  build_drop_table, build_rename_table, build_add_column,
  build_drop_column, build_rename_column, build_alter_column,
  build_reorder_column (MySQL only), build_create_index,
  build_drop_index, build_add_foreign_key, build_drop_foreign_key.

Dialect quirks captured:
- Postgres auto-increment renders as SERIAL / BIGSERIAL / SMALLSERIAL
  based on the user-typed integer width.
- MySQL ALTER COLUMN routes through MODIFY COLUMN which replaces the
  whole definition (single-call); Postgres emits per-attribute
  ALTER COLUMN ... TYPE / SET NOT NULL / SET DEFAULT.
- SQLite limits surface as BuildDdlError::SqliteNotSupported for
  alter-type / alter-nullable / alter-default / drop-FK so the UI
  can disable the affordances rather than fall through to a runtime
  driver error.
- SQLite FK constraints get a leading PRAGMA foreign_keys = ON
  emitted by build_create_table when the columns list contains FKs.

43 unit tests cover every builder × every driver × edge cases
(composite PK, schema qualification, identifier quote-doubling,
empty-name validation, default expressions, auto-increment routing).

Author: datlechin

linux/crates/core/src/connection.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use secrecy::SecretString;
 
 use crate::error::DriverError;
-use crate::query::{ColumnInfo, ExecResult, QueryResult, TableInfo, Value};
+use crate::query::{ColumnInfo, ExecResult, ForeignKeyInfo, IndexInfo, QueryResult, TableInfo, Value};
 
 #[derive(Debug, Clone)]
 pub struct ConnectOptions {
@@ -49,6 +49,22 @@ pub trait Connection: Send + Sync {
     /// changeset Save flow so all pending row inserts / updates /
     /// deletes commit atomically.
     async fn execute_in_transaction(&self, statements: &[(String, Vec<Value>)]) -> Result<Vec<u64>, DriverError>;
+    /// Indexes defined on `table`. Implementations may include the
+    /// implicit primary-key index with `primary = true` so the UI can
+    /// render it as read-only. Default returns empty so existing
+    /// drivers compile before they're filled in.
+    async fn fetch_indexes(&self, _schema: Option<&str>, _table: &str) -> Result<Vec<IndexInfo>, DriverError> {
+        Ok(Vec::new())
+    }
+    /// Foreign-key constraints declared on `table`. Default returns
+    /// empty for the same reason as `fetch_indexes`.
+    async fn fetch_foreign_keys(
+        &self,
+        _schema: Option<&str>,
+        _table: &str,
+    ) -> Result<Vec<ForeignKeyInfo>, DriverError> {
+        Ok(Vec::new())
+    }
     async fn ping(&self) -> Result<(), DriverError>;
     async fn close(self: Box<Self>) -> Result<(), DriverError>;
 }

linux/crates/core/src/lib.rs

@@ -4,11 +4,12 @@ mod error;
 mod query;
 mod read_only;
 mod registry;
+pub mod sql_ddl;
 pub mod sql_dialect;
 
 pub use connection::{ConnectOptions, Connection};
 pub use driver::DatabaseDriver;
 pub use error::DriverError;
-pub use query::{ColumnInfo, ExecResult, MAX_QUERY_ROWS, QueryResult, TableInfo, Value};
+pub use query::{ColumnInfo, ExecResult, ForeignKeyInfo, IndexInfo, MAX_QUERY_ROWS, QueryResult, TableInfo, Value};
 pub use read_only::ReadOnlyConnection;
 pub use registry::DriverRegistry;

linux/crates/core/src/query.rs

@@ -9,6 +9,35 @@ pub struct TableInfo {
     pub name: String,
 }
 
+/// Secondary-index metadata for a table. `primary` is set on the
+/// auto-PK index returned by the catalog query so the UI can render
+/// it as read-only (the PK is owned by the column definition, not
+/// by an editable index entry).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct IndexInfo {
+    pub name: String,
+    pub columns: Vec<String>,
+    pub unique: bool,
+    pub primary: bool,
+}
+
+/// Foreign-key constraint metadata. `on_delete` / `on_update` carry
+/// the referential action as a normalised SQL keyword string
+/// ("RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT", "NO ACTION").
+/// `None` means the driver returned a value we don't recognise — the
+/// UI displays it as a dim-label "—" and the DDL builder omits the
+/// clause so the database picks its default.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ForeignKeyInfo {
+    pub name: String,
+    pub columns: Vec<String>,
+    pub ref_schema: Option<String>,
+    pub ref_table: String,
+    pub ref_columns: Vec<String>,
+    pub on_delete: Option<String>,
+    pub on_update: Option<String>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct ColumnInfo {
     pub name: String,

linux/crates/core/src/read_only.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 
 use crate::connection::Connection;
 use crate::error::DriverError;
-use crate::query::{ColumnInfo, ExecResult, QueryResult, TableInfo, Value};
+use crate::query::{ColumnInfo, ExecResult, ForeignKeyInfo, IndexInfo, QueryResult, TableInfo, Value};
 
 pub struct ReadOnlyConnection {
     inner: Box<dyn Connection>,
@@ -50,6 +50,14 @@ impl Connection for ReadOnlyConnection {
         Err(DriverError::ReadOnly)
     }
 
+    async fn fetch_indexes(&self, schema: Option<&str>, table: &str) -> Result<Vec<IndexInfo>, DriverError> {
+        self.inner.fetch_indexes(schema, table).await
+    }
+
+    async fn fetch_foreign_keys(&self, schema: Option<&str>, table: &str) -> Result<Vec<ForeignKeyInfo>, DriverError> {
+        self.inner.fetch_foreign_keys(schema, table).await
+    }
+
     async fn ping(&self) -> Result<(), DriverError> {
         self.inner.ping().await
     }