Skip to content

Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.

feat: add SQL schema import — postgres introspection to OWL Turtle

FABIOTESS3b3d78f4b889
diff --git a/Cargo.toml b/Cargo.toml
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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");
+}