Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
feat: add SQL schema import — postgres introspection to OWL Turtle
FABIOTESS3b3d78f4b889
diff --git a/Cargo.toml b/Cargo.tomlindex 8abd9c98..abd5549b 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -32,7 +32,11 @@ serde_yaml = "0.9"calamine = "0.26"arrow = { version = "54", default-features = false, features = ["csv", "json"] }parquet = { version = "54", default-features = false, features = ["arrow"] }+sqlx = { version = "0.8", features = ["runtime-tokio", "postgres"], optional = true }+[features]+default = ["postgres"]+postgres = ["sqlx"][dev-dependencies]tempfile = "3"diff --git a/src/lib.rs b/src/lib.rsindex 159a9a95..7832f811 100644--- a/src/lib.rs+++ b/src/lib.rs@@ -13,4 +13,5 @@ pub mod reason;pub mod server;pub mod shacl;pub mod state;+pub mod schema;pub mod tableaux;diff --git a/src/main.rs b/src/main.rsindex 35f96845..6d839f8f 100644--- a/src/main.rs+++ b/src/main.rs@@ -816,9 +816,28 @@ async fn main() -> anyhow::Result<()> {}}- // ─── Schema import (stub until Task 6) ────────────────────+ // ─── Schema import ─────────────────────────────────────────+ #[cfg(feature = "postgres")]+ Commands::ImportSchema { connection, base_iri } => {+ let (_db, graph) = setup(&cli.data_dir)?;+ let tables = open_ontologies::schema::SchemaIntrospector::introspect_postgres(&connection).await?;+ let turtle = open_ontologies::schema::SchemaIntrospector::generate_turtle(&tables, &base_iri);++ // Validate + load+ GraphStore::validate_turtle(&turtle)?;+ let count = graph.load_turtle(&turtle, Some(&base_iri))?;++ output_json(&serde_json::json!({+ "ok": true,+ "tables": tables.len(),+ "classes": tables.len(),+ "triples": count,+ "base_iri": base_iri,+ }), cli.pretty);+ }+ #[cfg(not(feature = "postgres"))]Commands::ImportSchema { .. } => {- output_json(&serde_json::json!({"error": "not implemented — requires postgres feature"}), cli.pretty);+ output_json(&serde_json::json!({"error": "import-schema requires the 'postgres' feature (compile with --features postgres)"}), cli.pretty);std::process::exit(1);}}diff --git a/src/schema.rs b/src/schema.rsnew file mode 100644index 00000000..9636364c--- /dev/null+++ b/src/schema.rs@@ -0,0 +1,167 @@+/// Database schema introspection and OWL generation.++pub struct TableInfo {+ pub name: String,+ pub columns: Vec<ColumnInfo>,+ pub foreign_keys: Vec<ForeignKey>,+}++pub struct ColumnInfo {+ pub name: String,+ pub data_type: String,+ pub is_nullable: bool,+ pub is_primary_key: bool,+}++pub struct ForeignKey {+ pub column: String,+ pub parent_table: String,+ pub parent_column: String,+}++pub struct SchemaIntrospector;++impl SchemaIntrospector {+ /// Convert SQL type name to XSD datatype.+ pub fn sql_to_xsd(sql_type: &str) -> &'static str {+ match sql_type.to_lowercase().as_str() {+ "integer" | "int" | "bigint" | "smallint" | "int4" | "int8" | "int2" | "serial" | "bigserial" => "xsd:integer",+ "numeric" | "decimal" | "real" | "double precision" | "float4" | "float8" => "xsd:decimal",+ "boolean" | "bool" => "xsd:boolean",+ "date" => "xsd:date",+ "timestamp" | "timestamptz" | "timestamp without time zone" | "timestamp with time zone" => "xsd:dateTime",+ "bytea" | "blob" => "xsd:hexBinary",+ _ => "xsd:string",+ }+ }++ /// Convert snake_case table name to PascalCase class name.+ pub fn table_to_class(name: &str) -> String {+ name.split('_')+ .map(|part| {+ let mut chars = part.chars();+ match chars.next() {+ None => String::new(),+ Some(c) => c.to_uppercase().to_string() + &chars.collect::<String>(),+ }+ })+ .collect()+ }++ /// Generate OWL Turtle from introspected schema.+ pub fn generate_turtle(tables: &[TableInfo], base_iri: &str) -> String {+ let mut ttl = String::new();+ ttl.push_str("@prefix owl: <http://www.w3.org/2002/07/owl#> .\n");+ ttl.push_str("@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n");+ ttl.push_str("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n");+ ttl.push_str(&format!("@prefix db: <{}> .\n\n", base_iri));++ // Build FK lookup: (table, column) → parent_table+ let fk_map: std::collections::HashMap<(String, String), &ForeignKey> = tables.iter()+ .flat_map(|t| t.foreign_keys.iter().map(move |fk| ((t.name.clone(), fk.column.clone()), fk)))+ .collect();++ for table in tables {+ let class = Self::table_to_class(&table.name);+ ttl.push_str(&format!("db:{} a owl:Class ;\n rdfs:label \"{}\" .\n\n", class, class));++ for col in &table.columns {+ let prop_name = format!("{}_{}", table.name, col.name);++ if let Some(fk) = fk_map.get(&(table.name.clone(), col.name.clone())) {+ // Foreign key → ObjectProperty+ let parent_class = Self::table_to_class(&fk.parent_table);+ ttl.push_str(&format!("db:{} a owl:ObjectProperty ;\n", prop_name));+ ttl.push_str(&format!(" rdfs:domain db:{} ;\n", class));+ ttl.push_str(&format!(" rdfs:range db:{} ;\n", parent_class));+ ttl.push_str(&format!(" rdfs:label \"{}\" .\n\n", col.name));+ } else {+ // Regular column → DatatypeProperty+ let xsd = Self::sql_to_xsd(&col.data_type);+ if col.is_primary_key {+ ttl.push_str(&format!("db:{} a owl:DatatypeProperty , owl:FunctionalProperty ;\n", prop_name));+ } else {+ ttl.push_str(&format!("db:{} a owl:DatatypeProperty ;\n", prop_name));+ }+ ttl.push_str(&format!(" rdfs:domain db:{} ;\n", class));+ ttl.push_str(&format!(" rdfs:range {} ;\n", xsd));+ ttl.push_str(&format!(" rdfs:label \"{}\" .\n\n", col.name));+ }++ // NOT NULL → cardinality restriction+ if !col.is_nullable {+ ttl.push_str(&format!("db:{} rdfs:subClassOf [\n", class));+ ttl.push_str(" a owl:Restriction ;\n");+ ttl.push_str(&format!(" owl:onProperty db:{} ;\n", prop_name));+ ttl.push_str(" owl:minCardinality 1\n");+ ttl.push_str("] .\n\n");+ }+ }+ }++ ttl+ }++ /// Connect to postgres, introspect schema, return TableInfo vec.+ #[cfg(feature = "postgres")]+ pub async fn introspect_postgres(connection_string: &str) -> anyhow::Result<Vec<TableInfo>> {+ use sqlx::postgres::PgPoolOptions;+ use sqlx::Row;++ let pool = PgPoolOptions::new()+ .max_connections(1)+ .connect(connection_string)+ .await?;++ // Get tables+ let table_rows = sqlx::query(+ "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'"+ ).fetch_all(&pool).await?;++ let mut tables = Vec::new();++ for trow in &table_rows {+ let table_name: String = trow.get("table_name");++ // Get columns+ let col_rows = sqlx::query(+ "SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1 ORDER BY ordinal_position"+ ).bind(&table_name).fetch_all(&pool).await?;++ // Get primary keys+ let pk_rows = sqlx::query(+ "SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_name = $1"+ ).bind(&table_name).fetch_all(&pool).await?;++ let pk_cols: Vec<String> = pk_rows.iter().map(|r| r.get("column_name")).collect();++ let columns: Vec<ColumnInfo> = col_rows.iter().map(|r| {+ let name: String = r.get("column_name");+ let data_type: String = r.get("data_type");+ let nullable: String = r.get("is_nullable");+ ColumnInfo {+ is_primary_key: pk_cols.contains(&name),+ name,+ data_type,+ is_nullable: nullable == "YES",+ }+ }).collect();++ // Get foreign keys+ let fk_rows = sqlx::query(+ "SELECT kcu.column_name AS child_column, ccu.table_name AS parent_table, ccu.column_name AS parent_column FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema JOIN information_schema.constraint_column_usage ccu ON tc.constraint_name = ccu.constraint_name WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = $1"+ ).bind(&table_name).fetch_all(&pool).await?;++ let foreign_keys: Vec<ForeignKey> = fk_rows.iter().map(|r| ForeignKey {+ column: r.get("child_column"),+ parent_table: r.get("parent_table"),+ parent_column: r.get("parent_column"),+ }).collect();++ tables.push(TableInfo { name: table_name, columns, foreign_keys });+ }++ pool.close().await;+ Ok(tables)+ }+}diff --git a/tests/schema_test.rs b/tests/schema_test.rsnew file mode 100644index 00000000..afd0da0f--- /dev/null+++ b/tests/schema_test.rs@@ -0,0 +1,84 @@+use open_ontologies::schema::{TableInfo, ColumnInfo, ForeignKey, SchemaIntrospector};++#[test]+fn test_generate_turtle_single_table() {+ let tables = vec![TableInfo {+ name: "users".into(),+ columns: vec![+ ColumnInfo { name: "id".into(), data_type: "integer".into(), is_nullable: false, is_primary_key: true },+ ColumnInfo { name: "name".into(), data_type: "varchar".into(), is_nullable: false, is_primary_key: false },+ ColumnInfo { name: "email".into(), data_type: "varchar".into(), is_nullable: true, is_primary_key: false },+ ],+ foreign_keys: vec![],+ }];++ let turtle = SchemaIntrospector::generate_turtle(&tables, "http://example.org/db/");+ assert!(turtle.contains("db:Users a owl:Class"));+ assert!(turtle.contains("db:users_name a owl:DatatypeProperty"));+ assert!(turtle.contains("xsd:string"));+ assert!(turtle.contains("owl:minCardinality")); // NOT NULL → minCard 1+ assert!(turtle.contains("owl:FunctionalProperty")); // PK+}++#[test]+fn test_generate_turtle_foreign_key() {+ let tables = vec![+ TableInfo {+ name: "users".into(),+ columns: vec![+ ColumnInfo { name: "id".into(), data_type: "integer".into(), is_nullable: false, is_primary_key: true },+ ],+ foreign_keys: vec![],+ },+ TableInfo {+ name: "orders".into(),+ columns: vec![+ ColumnInfo { name: "id".into(), data_type: "integer".into(), is_nullable: false, is_primary_key: true },+ ColumnInfo { name: "user_id".into(), data_type: "integer".into(), is_nullable: false, is_primary_key: false },+ ],+ foreign_keys: vec![ForeignKey {+ column: "user_id".into(),+ parent_table: "users".into(),+ parent_column: "id".into(),+ }],+ },+ ];++ let turtle = SchemaIntrospector::generate_turtle(&tables, "http://example.org/db/");+ assert!(turtle.contains("db:orders_user_id a owl:ObjectProperty"));+ assert!(turtle.contains("rdfs:range db:Users"));+}++#[test]+fn test_sql_type_to_xsd() {+ assert_eq!(SchemaIntrospector::sql_to_xsd("integer"), "xsd:integer");+ assert_eq!(SchemaIntrospector::sql_to_xsd("varchar"), "xsd:string");+ assert_eq!(SchemaIntrospector::sql_to_xsd("boolean"), "xsd:boolean");+ assert_eq!(SchemaIntrospector::sql_to_xsd("timestamp"), "xsd:dateTime");+ assert_eq!(SchemaIntrospector::sql_to_xsd("numeric"), "xsd:decimal");+ assert_eq!(SchemaIntrospector::sql_to_xsd("date"), "xsd:date");+ assert_eq!(SchemaIntrospector::sql_to_xsd("bytea"), "xsd:hexBinary");+ assert_eq!(SchemaIntrospector::sql_to_xsd("unknown_type"), "xsd:string");+}++#[test]+fn test_generate_turtle_not_null_cardinality() {+ let tables = vec![TableInfo {+ name: "users".into(),+ columns: vec![+ ColumnInfo { name: "id".into(), data_type: "integer".into(), is_nullable: false, is_primary_key: true },+ ColumnInfo { name: "email".into(), data_type: "varchar".into(), is_nullable: false, is_primary_key: false },+ ],+ foreign_keys: vec![],+ }];++ let turtle = SchemaIntrospector::generate_turtle(&tables, "http://example.org/db/");+ assert!(turtle.contains("owl:minCardinality"));+}++#[test]+fn test_table_name_to_class() {+ assert_eq!(SchemaIntrospector::table_to_class("users"), "Users");+ assert_eq!(SchemaIntrospector::table_to_class("order_items"), "OrderItems");+ assert_eq!(SchemaIntrospector::table_to_class("product"), "Product");+}