version: 1.0.69

Cargo.lock

@@ -55,6 +55,15 @@ version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
 
+[[package]]
+name = "ar_archive_writer"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b"
+dependencies = [
+ "object",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.89"
@@ -874,6 +883,7 @@ dependencies = [
  "regex-syntax",
  "serde",
  "serde_json",
+ "sqlparser",
  "url",
  "uuid",
  "xxhash-rust",
@@ -1040,6 +1050,15 @@ dependencies = [
  "objc2-core-foundation",
 ]
 
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -1377,6 +1396,16 @@ dependencies = [
  "unarray",
 ]
 
+[[package]]
+name = "psm"
+version = "0.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8"
+dependencies = [
+ "ar_archive_writer",
+ "cc",
+]
+
 [[package]]
 name = "quick-error"
 version = "1.2.3"
@@ -1442,6 +1471,26 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "recursive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e"
+dependencies = [
+ "recursive-proc-macro-impl",
+ "stacker",
+]
+
+[[package]]
+name = "recursive-proc-macro-impl"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b"
+dependencies = [
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -1669,12 +1718,35 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "sqlparser"
+version = "0.61.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"
+dependencies = [
+ "log",
+ "recursive",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "stacker"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d74a23609d509411d10e2176dc2a4346e3b4aea2e7b1869f19fdedbc71c013"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "stringprep"
 version = "0.1.5"
@@ -2323,6 +2395,15 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.60.2"

Cargo.toml

@@ -23,6 +23,7 @@ indexmap = { version = "2.13.0", features = ["serde"] }
 moka = { version = "0.12.14", features = ["sync"] }
 xxhash-rust = { version = "0.8.15", features = ["xxh64"] }
 dashmap = "6.1.0"
+sqlparser = "0.61.0"
 
 [dev-dependencies]
 pgrx-tests = "0.16.1"
@@ -38,6 +39,10 @@ crate-type = ["cdylib", "lib"]
 name = "pgrx_embed_jspg"
 path = "src/bin/pgrx_embed.rs"
 
+[[bin]]
+name = "ast_explore"
+path = "src/bin/ast_explore.rs"
+
 [features]
 default = ["pg18"]
 pg18 = ["pgrx/pg18", "pgrx-tests/pg18" ]

src/bin/ast_explore.rs

@@ -0,0 +1,17 @@
+use sqlparser::dialect::PostgreSqlDialect;
+use sqlparser::parser::Parser;
+use std::env;
+
+fn main() {
+    let sql = "SELECT t1_obj_t1_addresses_t1_target_t2.archived, t1.id FROM person t1 JOIN address t1_obj_t1_addresses ON true";
+    let dialect = PostgreSqlDialect {};
+    
+    match Parser::parse_sql(&dialect, sql) {
+        Ok(ast) => {
+            println!("{:#?}", ast);
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
+    }
+}

src/database/executors/pgrx.rs

@@ -24,20 +24,28 @@ impl DatabaseExecutor for SpiExecutor {
       }
     }
 
-    Spi::connect(|client| {
-      match client.select(sql, Some(args_with_oid.len() as i64), &args_with_oid) {
-        Ok(tup_table) => {
-          let mut results = Vec::new();
-          for row in tup_table {
-            if let Ok(Some(jsonb)) = row.get::<pgrx::JsonB>(1) {
-              results.push(jsonb.0);
+    pgrx::PgTryBuilder::new(|| {
+      Spi::connect(|client| {
+        pgrx::notice!("JSPG_SQL: {}", sql);
+        match client.select(sql, Some(args_with_oid.len() as i64), &args_with_oid) {
+          Ok(tup_table) => {
+            let mut results = Vec::new();
+            for row in tup_table {
+              if let Ok(Some(jsonb)) = row.get::<pgrx::JsonB>(1) {
+                results.push(jsonb.0);
+              }
             }
+            Ok(Value::Array(results))
           }
-          Ok(Value::Array(results))
+          Err(e) => Err(format!("SPI Query Fetch Failure: {}", e)),
         }
-        Err(e) => Err(format!("SPI Query Fetch Failure: {}", e)),
-      }
+      })
     })
+    .catch_others(|cause| {
+      pgrx::warning!("JSPG Caught Native Postgres Error: {:?}", cause);
+      Err(format!("{:?}", cause))
+    })
+    .execute()
   }
 
   fn execute(&self, sql: &str, args: Option<&[Value]>) -> Result<(), String> {
@@ -52,12 +60,20 @@ impl DatabaseExecutor for SpiExecutor {
       }
     }
 
-    Spi::connect_mut(|client| {
-      match client.update(sql, Some(args_with_oid.len() as i64), &args_with_oid) {
-        Ok(_) => Ok(()),
-        Err(e) => Err(format!("SPI Execution Failure: {}", e)),
-      }
+    pgrx::PgTryBuilder::new(|| {
+      Spi::connect_mut(|client| {
+        pgrx::notice!("JSPG_SQL: {}", sql);
+        match client.update(sql, Some(args_with_oid.len() as i64), &args_with_oid) {
+          Ok(_) => Ok(()),
+          Err(e) => Err(format!("SPI Execution Failure: {}", e)),
+        }
+      })
     })
+    .catch_others(|cause| {
+      pgrx::warning!("JSPG Caught Native Postgres Error: {:?}", cause);
+      Err(format!("{:?}", cause))
+    })
+    .execute()
   }
 
   fn auth_user_id(&self) -> Result<String, String> {

src/drop.rs

@@ -67,6 +67,10 @@ pub struct Error {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ErrorDetails {
   pub path: String,
-  // Extensions can be added here (package, cause, etc)
-  // For now, validator only provides path
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub cause: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub context: Option<Vec<String>>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub schema: Option<String>,
 }

src/lib.rs

@@ -31,6 +31,9 @@ fn jspg_failure() -> JsonB {
     message: "JSPG extension has not been initialized via jspg_setup".to_string(),
     details: crate::drop::ErrorDetails {
       path: "".to_string(),
+      cause: None,
+      context: None,
+      schema: None,
     },
   };
   let drop = crate::drop::Drop::with_errors(vec![error]);
@@ -121,9 +124,10 @@ pub fn jspg_schemas() -> JsonB {
     Some(engine) => {
       let schemas_json = serde_json::to_value(&engine.database.schemas)
         .unwrap_or(serde_json::Value::Object(serde_json::Map::new()));
-      JsonB(schemas_json)
+      let drop = crate::drop::Drop::success_with_val(schemas_json);
+      JsonB(serde_json::to_value(drop).unwrap())
     }
-    None => JsonB(serde_json::Value::Object(serde_json::Map::new())),
+    None => jspg_failure(),
   }
 }
 
@@ -138,9 +142,10 @@ pub fn jspg_stems() -> JsonB {
     Some(engine) => {
       let stems_json = serde_json::to_value(&engine.database.stems)
         .unwrap_or(serde_json::Value::Object(serde_json::Map::new()));
-      JsonB(stems_json)
+      let drop = crate::drop::Drop::success_with_val(stems_json);
+      JsonB(serde_json::to_value(drop).unwrap())
     }
-    None => JsonB(serde_json::Value::Object(serde_json::Map::new())),
+    None => jspg_failure(),
   }
 }
 

src/merger/mod.rs

@@ -36,6 +36,9 @@ impl Merger {
           message: msg,
           details: crate::drop::ErrorDetails {
             path: "".to_string(),
+            cause: None,
+            context: None,
+            schema: None,
           },
         }]);
       }
@@ -49,6 +52,9 @@ impl Merger {
           message: format!("Executor Error in pre-ordered notify: {:?}", e),
           details: crate::drop::ErrorDetails {
             path: "".to_string(),
+            cause: None,
+            context: None,
+            schema: None,
           },
         }]);
       }

src/queryer/compiler.rs

@@ -113,9 +113,9 @@ impl SqlCompiler {
         // Determine if this schema represents a Database Entity
         let mut resolved_type = None;
 
-        // Target is generally a specific schema (e.g. 'base.person'), but it tells us what physical
-        // database table hierarchy it maps to via the `schema.id` prefix/suffix convention.
-        if let Some(lookup_key) = schema.obj.id.as_ref().or(schema.obj.r#ref.as_ref()) {
+        if let Some(family_target) = schema.obj.family.as_ref() {
+          resolved_type = self.db.types.get(family_target);
+        } else if let Some(lookup_key) = schema.obj.id.as_ref().or(schema.obj.r#ref.as_ref()) {
           let base_type_name = lookup_key.split('.').next_back().unwrap_or("").to_string();
           resolved_type = self.db.types.get(&base_type_name);
         }
@@ -150,6 +150,45 @@ impl SqlCompiler {
           }
           return Err(format!("Unresolved $ref: {}", ref_id));
         }
+        // Handle $family Polymorphism fallbacks for relations
+        if let Some(family_target) = &schema.obj.family {
+          let mut all_targets = vec![family_target.clone()];
+          if let Some(schema_id) = &schema.obj.id {
+            if let Some(descendants) = self.db.descendants.get(schema_id) {
+              all_targets.extend(descendants.clone());
+            }
+          }
+
+          let mut family_schemas = Vec::new();
+          for target in all_targets {
+            let mut ref_schema = crate::database::schema::Schema::default();
+            ref_schema.obj.r#ref = Some(target);
+            family_schemas.push(std::sync::Arc::new(ref_schema));
+          }
+
+          return self.compile_one_of(
+            &family_schemas,
+            parent_alias,
+            prop_name_context,
+            filter_keys,
+            is_stem_query,
+            depth,
+            current_path,
+          );
+        }
+
+        // Handle oneOf Polymorphism fallbacks for relations
+        if let Some(one_of) = &schema.obj.one_of {
+          return self.compile_one_of(
+            one_of,
+            parent_alias,
+            prop_name_context,
+            filter_keys,
+            is_stem_query,
+            depth,
+            current_path,
+          );
+        }
 
         // Just an inline object definition?
         if let Some(props) = &schema.obj.properties {
@@ -215,7 +254,7 @@ impl SqlCompiler {
     let (table_aliases, from_clauses) = self.build_hierarchy_from_clauses(type_def, &local_ctx);
 
     // 2. Map properties and build jsonb_build_object args
-    let select_args = self.map_properties_to_aliases(
+    let mut select_args = self.map_properties_to_aliases(
       schema,
       type_def,
       &table_aliases,
@@ -226,6 +265,40 @@ impl SqlCompiler {
       &current_path,
     )?;
 
+    // 2.5 Inject polymorphism directly into the query object
+    if let Some(family_target) = &schema.obj.family {
+      let mut family_schemas = Vec::new();
+      if let Some(base_type) = self.db.types.get(family_target) {
+        let mut sorted_targets: Vec<String> = base_type.variations.iter().cloned().collect();
+        // Ensure the base type is included if not listed in variations by default
+        if !sorted_targets.contains(family_target) {
+            sorted_targets.push(family_target.clone());
+        }
+        sorted_targets.sort();
+        
+        for target in sorted_targets {
+          let mut ref_schema = crate::database::schema::Schema::default();
+          ref_schema.obj.r#ref = Some(target);
+          family_schemas.push(std::sync::Arc::new(ref_schema));
+        }
+      } else {
+        // Fallback for types not strictly defined in physical DB
+        let mut ref_schema = crate::database::schema::Schema::default();
+        ref_schema.obj.r#ref = Some(family_target.clone());
+        family_schemas.push(std::sync::Arc::new(ref_schema));
+      }
+
+      let base_alias = table_aliases.get(&type_def.name).cloned().unwrap_or_else(|| parent_alias.to_string());
+      select_args.push(format!("'id', {}.id", base_alias));
+      let (case_sql, _) = self.compile_one_of(&family_schemas, &base_alias, None, filter_keys, is_stem_query, depth, current_path.clone())?;
+      select_args.push(format!("'type', {}", case_sql));
+    } else if let Some(one_of) = &schema.obj.one_of {
+      let base_alias = table_aliases.get(&type_def.name).cloned().unwrap_or_else(|| parent_alias.to_string());
+      select_args.push(format!("'id', {}.id", base_alias));
+      let (case_sql, _) = self.compile_one_of(one_of, &base_alias, None, filter_keys, is_stem_query, depth, current_path.clone())?;
+      select_args.push(format!("'type', {}", case_sql));
+    }
+
     let jsonb_obj_sql = if select_args.is_empty() {
       "jsonb_build_object()".to_string()
     } else {
@@ -326,6 +399,26 @@ impl SqlCompiler {
         }
       }
 
+      let is_object_or_array = match &prop_schema.obj.type_ {
+          Some(crate::database::schema::SchemaTypeOrArray::Single(s)) => s == "object" || s == "array",
+          Some(crate::database::schema::SchemaTypeOrArray::Multiple(v)) => v.contains(&"object".to_string()) || v.contains(&"array".to_string()),
+          _ => false
+      };
+
+      let is_primitive = prop_schema.obj.r#ref.is_none() 
+          && prop_schema.obj.items.is_none()
+          && prop_schema.obj.properties.is_none()
+          && prop_schema.obj.one_of.is_none()
+          && !is_object_or_array;
+
+      if is_primitive {
+        if let Some(ft) = type_def.field_types.as_ref().and_then(|v| v.as_object()) {
+          if !ft.contains_key(prop_key) {
+            continue; // Skip frontend virtual properties (e.g. `computer` fields, `created`) missing from physical table fields
+          }
+        }
+      }
+
       let next_path = if current_path.is_empty() {
         prop_key.clone()
       } else {
@@ -497,8 +590,12 @@ impl SqlCompiler {
       }
     }
 
-    if let Some(_prop) = prop_name {
-      where_clauses.push(format!("{}.parent_id = {}.id", base_alias, parent_alias));
+    if let Some(prop) = prop_name {
+      if prop == "target" || prop == "source" {
+        where_clauses.push(format!("{}.id = {}.{}_id", base_alias, parent_alias, prop));
+      } else {
+        where_clauses.push(format!("{}.parent_id = {}.id", base_alias, parent_alias));
+      }
     }
 
     Ok(where_clauses)
@@ -538,4 +635,56 @@ impl SqlCompiler {
     let combined = format!("jsonb_build_object({})", build_args.join(", "));
     Ok((combined, "object".to_string()))
   }
+
+  fn compile_one_of(
+    &self,
+    schemas: &[Arc<crate::database::schema::Schema>],
+    parent_alias: &str,
+    prop_name_context: Option<&str>,
+    filter_keys: &[String],
+    is_stem_query: bool,
+    depth: usize,
+    current_path: String,
+  ) -> Result<(String, String), String> {
+    let mut case_statements = Vec::new();
+    let type_col = if let Some(prop) = prop_name_context {
+      format!("{}_type", prop)
+    } else {
+      "type".to_string()
+    };
+
+    for option_schema in schemas {
+      if let Some(ref_id) = &option_schema.obj.r#ref {
+        // Find the physical type this ref maps to
+        let base_type_name = ref_id.split('.').next_back().unwrap_or("").to_string();
+        
+        // Generate the nested SQL for this specific target type
+        let (val_sql, _) = self.walk_schema(
+          option_schema,
+          parent_alias,
+          prop_name_context,
+          filter_keys,
+          is_stem_query,
+          depth,
+          current_path.clone(),
+        )?;
+
+        case_statements.push(format!(
+          "WHEN {}.{} = '{}' THEN ({})",
+          parent_alias, type_col, base_type_name, val_sql
+        ));
+      }
+    }
+
+    if case_statements.is_empty() {
+      return Ok(("NULL".to_string(), "string".to_string()));
+    }
+
+    let sql = format!(
+      "CASE {} ELSE NULL END",
+      case_statements.join(" ")
+    );
+
+    Ok((sql, "object".to_string()))
+  }
 }

src/queryer/mod.rs

@@ -32,9 +32,12 @@ impl Queryer {
       Err(msg) => {
         return crate::drop::Drop::with_errors(vec![crate::drop::Error {
           code: "FILTER_PARSE_FAILED".to_string(),
-          message: msg,
+          message: msg.clone(),
           details: crate::drop::ErrorDetails {
-            path: schema_id.to_string(),
+            path: "".to_string(), // filters apply to the root query
+            cause: Some(msg),
+            context: filters.map(|f| vec![f.to_string()]),
+            schema: Some(schema_id.to_string()),
           },
         }]);
       }
@@ -104,9 +107,12 @@ impl Queryer {
       }
       Err(e) => Err(crate::drop::Drop::with_errors(vec![crate::drop::Error {
         code: "QUERY_COMPILATION_FAILED".to_string(),
-        message: e,
+        message: e.clone(),
         details: crate::drop::ErrorDetails {
-          path: schema_id.to_string(),
+          path: "".to_string(),
+          cause: Some(e),
+          context: None,
+          schema: Some(schema_id.to_string()),
         },
       }])),
     }
@@ -130,14 +136,20 @@ impl Queryer {
         code: "QUERY_FAILED".to_string(),
         message: format!("Expected array from generic query, got: {:?}", other),
         details: crate::drop::ErrorDetails {
-          path: schema_id.to_string(),
+          path: "".to_string(),
+          cause: Some(format!("Expected array, got {}", other)),
+          context: Some(vec![sql.to_string()]),
+          schema: Some(schema_id.to_string()),
         },
       }]),
       Err(e) => crate::drop::Drop::with_errors(vec![crate::drop::Error {
         code: "QUERY_FAILED".to_string(),
         message: format!("SPI error in queryer: {}", e),
         details: crate::drop::ErrorDetails {
-          path: schema_id.to_string(),
+          path: "".to_string(),
+          cause: Some(format!("SPI error in queryer: {}", e)),
+          context: Some(vec![sql.to_string()]),
+          schema: Some(schema_id.to_string()),
         },
       }]),
     }

src/tests/fixtures.rs

@@ -1469,6 +1469,12 @@ fn test_queryer_0_9() {
     crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
 }
 
+#[test]
+fn test_queryer_0_10() {
+    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 0, 10).unwrap();
+}
+
 #[test]
 fn test_not_0_0() {
     let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));

src/tests/mod.rs

@@ -2,6 +2,7 @@ use crate::*;
 pub mod runner;
 pub mod types;
 use serde_json::json;
+pub mod sql_validator;
 
 // Database module tests moved to src/database/executors/mock.rs
 
@@ -54,13 +55,16 @@ fn test_library_api() {
   assert_eq!(
     schemas_drop.0,
     json!({
-        "test_schema": {
-            "$id": "test_schema",
-            "type": "object",
-            "properties": {
-                "name": { "type": "string" }
-            },
-            "required": ["name"]
+        "type": "drop",
+        "response": {
+            "test_schema": {
+                "$id": "test_schema",
+                "type": "object",
+                "properties": {
+                    "name": { "type": "string" }
+                },
+                "required": ["name"]
+            }
         }
     })
   );

src/tests/sql_validator.rs

@@ -0,0 +1,156 @@
+use sqlparser::ast::{
+    Expr, Join, JoinConstraint, JoinOperator, Query, Select, SelectItem, SetExpr, Statement,
+    TableFactor, TableWithJoins, Ident,
+};
+use sqlparser::dialect::PostgreSqlDialect;
+use sqlparser::parser::Parser;
+use std::collections::HashSet;
+
+pub fn validate_semantic_sql(sql: &str) -> Result<(), String> {
+    let dialect = PostgreSqlDialect {};
+    let statements = match Parser::parse_sql(&dialect, sql) {
+        Ok(s) => s,
+        Err(e) => return Err(format!("SQL Syntax Error: {}\nSQL: {}", e, sql)),
+    };
+
+    for statement in statements {
+        validate_statement(&statement, sql)?;
+    }
+
+    Ok(())
+}
+
+fn validate_statement(stmt: &Statement, original_sql: &str) -> Result<(), String> {
+    match stmt {
+        Statement::Query(query) => validate_query(query, original_sql)?,
+        Statement::Insert(insert) => {
+            if let Some(query) = &insert.source {
+                 validate_query(query, original_sql)?
+            }
+        }
+        Statement::Update(update) => {
+            if let Some(expr) = &update.selection {
+                validate_expr(expr, &HashSet::new(), original_sql)?;
+            }
+        }
+        Statement::Delete(delete) => {
+            if let Some(expr) = &delete.selection {
+                validate_expr(expr, &HashSet::new(), original_sql)?;
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+fn validate_query(query: &Query, original_sql: &str) -> Result<(), String> {
+    if let SetExpr::Select(select) = &*query.body {
+        validate_select(select, original_sql)?;
+    }
+    Ok(())
+}
+
+fn validate_select(select: &Select, original_sql: &str) -> Result<(), String> {
+    let mut available_aliases = HashSet::new();
+
+    // 1. Collect all declared table aliases in the FROM clause and JOINs
+    for table_with_joins in &select.from {
+        collect_aliases_from_table_factor(&table_with_joins.relation, &mut available_aliases);
+        for join in &table_with_joins.joins {
+            collect_aliases_from_table_factor(&join.relation, &mut available_aliases);
+        }
+    }
+
+    // 2. Validate all SELECT projection fields
+    for projection in &select.projection {
+        if let SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } = projection {
+            validate_expr(expr, &available_aliases, original_sql)?;
+        }
+    }
+
+    // 3. Validate ON conditions in joins 
+    for table_with_joins in &select.from {
+        for join in &table_with_joins.joins {
+            if let JoinOperator::Inner(JoinConstraint::On(expr))
+            | JoinOperator::LeftOuter(JoinConstraint::On(expr))
+            | JoinOperator::RightOuter(JoinConstraint::On(expr))
+            | JoinOperator::FullOuter(JoinConstraint::On(expr))
+            | JoinOperator::Join(JoinConstraint::On(expr)) = &join.join_operator
+            {
+                validate_expr(expr, &available_aliases, original_sql)?;
+            }
+        }
+    }
+
+    // 4. Validate WHERE conditions
+    if let Some(selection) = &select.selection {
+        validate_expr(selection, &available_aliases, original_sql)?;
+    }
+
+    Ok(())
+}
+
+fn collect_aliases_from_table_factor(tf: &TableFactor, aliases: &mut HashSet<String>) {
+    match tf {
+        TableFactor::Table { name, alias, .. } => {
+            if let Some(table_alias) = alias {
+                aliases.insert(table_alias.name.value.clone());
+            } else if let Some(last) = name.0.last() {
+                 match last {
+                     sqlparser::ast::ObjectNamePart::Identifier(i) => {
+                         aliases.insert(i.value.clone());
+                     }
+                     _ => {}
+                 }
+            }
+        }
+        TableFactor::Derived { alias: Some(table_alias), .. } => {
+            aliases.insert(table_alias.name.value.clone());
+        }
+        _ => {}
+    }
+}
+
+fn validate_expr(expr: &Expr, available_aliases: &HashSet<String>, sql: &str) -> Result<(), String> {
+    match expr {
+        Expr::CompoundIdentifier(idents) => {
+            if idents.len() == 2 {
+                let alias = &idents[0].value;
+                if !available_aliases.is_empty() && !available_aliases.contains(alias) {
+                    return Err(format!(
+                        "Semantic Error: Orchestrated query referenced table alias '{}' but it was not declared in the query's FROM/JOIN clauses.\nAvailable aliases: {:?}\nSQL: {}",
+                        alias, available_aliases, sql
+                    ));
+                }
+            } else if idents.len() > 2 {
+                let alias = &idents[1].value; // In form schema.table.column, 'table' is idents[1]
+                if !available_aliases.is_empty() && !available_aliases.contains(alias) {
+                    return Err(format!(
+                        "Semantic Error: Orchestrated query referenced table '{}' but it was not mapped.\nAvailable aliases: {:?}\nSQL: {}",
+                        alias, available_aliases, sql
+                    ));
+                }
+            }
+        }
+        Expr::BinaryOp { left, right, .. } => {
+            validate_expr(left, available_aliases, sql)?;
+            validate_expr(right, available_aliases, sql)?;
+        }
+        Expr::IsFalse(e) | Expr::IsNotFalse(e) | Expr::IsTrue(e) | Expr::IsNotTrue(e) 
+        | Expr::IsNull(e) | Expr::IsNotNull(e) | Expr::InList { expr: e, .. }
+        | Expr::Nested(e) | Expr::UnaryOp { expr: e, .. } | Expr::Cast { expr: e, .. }
+        | Expr::Like { expr: e, .. } | Expr::ILike { expr: e, .. } | Expr::AnyOp { left: e, .. }
+        | Expr::AllOp { left: e, .. } => {
+             validate_expr(e, available_aliases, sql)?;
+        }
+        Expr::Function(func) => {
+            if let sqlparser::ast::FunctionArguments::List(args) = &func.args {
+                if let Some(sqlparser::ast::FunctionArg::Unnamed(sqlparser::ast::FunctionArgExpr::Expr(e))) = args.args.get(0) {
+                    validate_expr(e, available_aliases, sql)?;
+                }
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}

src/tests/types/expect.rs

@@ -39,6 +39,12 @@ impl ExpectBlock {
       ));
     }
 
+    for query in actual {
+      if let Err(e) = crate::tests::sql_validator::validate_semantic_sql(query) {
+        return Err(e);
+      }
+    }
+
     let ws_re = Regex::new(r"\s+").unwrap();
 
     let types = HashMap::from([

src/validator/mod.rs

@@ -67,7 +67,12 @@ impl Validator {
               .map(|e| crate::drop::Error {
                 code: e.code,
                 message: e.message,
-                details: crate::drop::ErrorDetails { path: e.path },
+                details: crate::drop::ErrorDetails {
+            path: e.path,
+            cause: None,
+            context: None,
+            schema: None,
+          },
               })
               .collect();
             crate::drop::Drop::with_errors(errors)
@@ -76,7 +81,12 @@ impl Validator {
         Err(e) => crate::drop::Drop::with_errors(vec![crate::drop::Error {
           code: e.code,
           message: e.message,
-          details: crate::drop::ErrorDetails { path: e.path },
+          details: crate::drop::ErrorDetails {
+            path: e.path,
+            cause: None,
+            context: None,
+            schema: None,
+          },
         }]),
       }
     } else {
@@ -84,7 +94,10 @@ impl Validator {
         code: "SCHEMA_NOT_FOUND".to_string(),
         message: format!("Schema {} not found", schema_id),
         details: crate::drop::ErrorDetails {
-          path: "".to_string(),
+          path: "/".to_string(),
+          cause: None,
+          context: None,
+          schema: None,
         },
       }])
     }

version

@@ -1 +1 @@
-1.0.63
+1.0.69