version: 1.0.73

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "rust-lang.rust-analyzer"
+    ]
+}

GEMINI.md

@@ -43,7 +43,7 @@ JSPG implements specific extensions to the Draft 2020-12 standard to support the
 #### A. Polymorphism & Referencing (`$ref`, `$family`, and Native Types)
 *   **Native Type Discrimination (`variations`)**: Schemas defined inside a Postgres `type` are Entities. The validator securely and implicitly manages their `"type"` property. If an entity inherits from `user`, incoming JSON can safely define `{"type": "person"}` without errors, thanks to `compiled_variations` inheritance.
 *   **Structural Inheritance & Viral Infection (`$ref`)**: `$ref` is used exclusively for structural inheritance, *never* for union creation. A Punc request schema that `$ref`s an Entity virally inherits all physical database polymorphism rules for that target.
-*   **Shape Polymorphism (`$family`)**: Auto-expands polymorphic API lists based on an abstract Descendants Graph. If `{"$family": "widget"}` is used, JSPG evaluates the JSON against every schema that `$ref`s widget.
+*   **Shape Polymorphism (`$family`)**: Auto-expands polymorphic API lists based on an abstract **Descendants Graph**. If `{"$family": "widget"}` is used, the Validator dynamically identifies *every* schema in the registry that `$ref`s `widget` (e.g., `stock.widget`, `task.widget`) and evaluates the JSON against all of them.
 *   **Strict Matches & Depth Heuristic**: Polymorphic structures MUST match exactly **one** schema permutation. If multiple inherited struct permutations pass, JSPG applies the **Depth Heuristic Tie-Breaker**, selecting the candidate deepest in the inheritance tree. 
 
 #### B. Dot-Notation Schema Resolution & Database Mapping
@@ -103,6 +103,10 @@ The Queryer transforms Postgres into a pre-compiled Semantic Query Engine via th
     *   **Array Inclusion**: `{"$in": [values]}`, `{"$nin": [values]}` use native `jsonb_array_elements_text()` bindings to enforce `IN` and `NOT IN` logic without runtime SQL injection risks.
     *   **Text Matching (ILIKE)**: Evaluates `$eq` or `$ne` against string fields containing the `%` character natively into Postgres `ILIKE` and `NOT ILIKE` partial substring matches.
     *   **Type Casting**: Safely resolves dynamic combinations by casting values instantly into the physical database types mapped in the schema (e.g. parsing `uuid` bindings to `::uuid`, formatting DateTimes to `::timestamptz`, and numbers to `::numeric`).
+*   **Polymorphic SQL Generation (`$family`)**: Compiles `$family` properties by analyzing the **Physical Database Variations**, *not* the schema descendants.
+    *   **The Dot Convention**: When a schema requests `$family: "target.schema"`, the compiler extracts the base type (e.g. `schema`) and looks up its Physical Table definition.
+    *   **Multi-Table Branching**: If the Physical Table is a parent to other tables (e.g. `organization` has variations `["organization", "bot", "person"]`), the compiler generates a dynamic `CASE WHEN type = '...' THEN ...` query, expanding into `JOIN`s for each variation.
+    *   **Single-Table Bypass**: If the Physical Table is a leaf node with only one variation (e.g. `person` has variations `["person"]`), the compiler cleanly bypasses `CASE` generation and compiles a simple `SELECT` across the base table, as all schema extensions (e.g. `light.person`, `full.person`) are guaranteed to reside in the exact same physical row.
 
 ### The Stem Engine
 

src/database/mod.rs

@@ -32,7 +32,7 @@ pub struct Database {
   pub enums: HashMap<String, Enum>,
   pub types: HashMap<String, Type>,
   pub puncs: HashMap<String, Punc>,
-  pub relations: HashMap<String, Relation>,
+  pub relations: HashMap<(String, String), Vec<Relation>>,
   pub schemas: HashMap<String, Schema>,
   // Map of Schema ID -> { Entity Type -> Target Subschema Arc }
   pub stems: HashMap<String, HashMap<String, Arc<Stem>>>,
@@ -74,11 +74,12 @@ impl Database {
       }
     }
 
+    let mut raw_relations = Vec::new();
     if let Some(arr) = val.get("relations").and_then(|v| v.as_array()) {
       for item in arr {
         match serde_json::from_value::<Relation>(item.clone()) {
           Ok(def) => {
-            db.relations.insert(def.constraint.clone(), def);
+            raw_relations.push(def);
           }
           Err(e) => println!("DATABASE RELATION PARSE FAILED: {:?}", e),
         }
@@ -107,7 +108,7 @@ impl Database {
       }
     }
 
-    db.compile()?;
+    db.compile(raw_relations)?;
     Ok(db)
   }
 
@@ -138,10 +139,11 @@ impl Database {
   }
 
   /// Organizes the graph of the database, compiling regex, format functions, and caching relationships.
-  pub fn compile(&mut self) -> Result<(), crate::drop::Drop> {
+  pub fn compile(&mut self, raw_relations: Vec<Relation>) -> Result<(), crate::drop::Drop> {
     self.collect_schemas();
     self.collect_depths();
     self.collect_descendants();
+    self.collect_relations(raw_relations);
     self.compile_schemas();
     self.collect_stems()?;
 
@@ -226,6 +228,95 @@ impl Database {
     self.descendants = descendants;
   }
 
+  fn collect_relations(&mut self, raw_relations: Vec<Relation>) {
+    let mut edges: HashMap<(String, String), Vec<Relation>> = HashMap::new();
+
+    // For every relation, map it across all polymorphic inheritance permutations
+    for relation in raw_relations {
+      if let Some(_source_type_def) = self.types.get(&relation.source_type) {
+        if let Some(_dest_type_def) = self.types.get(&relation.destination_type) {
+          let mut src_descendants = Vec::new();
+          let mut dest_descendants = Vec::new();
+
+          for (t_name, t_def) in &self.types {
+            if t_def.hierarchy.contains(&relation.source_type) {
+              src_descendants.push(t_name.clone());
+            }
+            if t_def.hierarchy.contains(&relation.destination_type) {
+              dest_descendants.push(t_name.clone());
+            }
+          }
+
+          for p_type in &src_descendants {
+            for c_type in &dest_descendants {
+              // Ignore entity <-> entity generic fallbacks, they aren't useful edges
+              if p_type == "entity" && c_type == "entity" {
+                continue;
+              }
+
+              // Forward edge
+              edges
+                .entry((p_type.clone(), c_type.clone()))
+                .or_default()
+                .push(relation.clone());
+
+              // Reverse edge (only if types are different to avoid duplicating self-referential edges like activity parent_id)
+              if p_type != c_type {
+                edges
+                  .entry((c_type.clone(), p_type.clone()))
+                  .or_default()
+                  .push(relation.clone());
+              }
+            }
+          }
+        }
+      }
+    }
+    self.relations = edges;
+  }
+
+  pub fn get_relation(
+    &self,
+    parent_type: &str,
+    child_type: &str,
+    prop_name: &str,
+    relative_keys: Option<&Vec<String>>,
+  ) -> Option<&Relation> {
+    if let Some(relations) = self
+      .relations
+      .get(&(parent_type.to_string(), child_type.to_string()))
+    {
+      if relations.len() == 1 {
+        return Some(&relations[0]);
+      }
+
+      // Reduce ambiguity with prefix
+      for rel in relations {
+        if let Some(prefix) = &rel.prefix {
+          if prefix == prop_name {
+            return Some(rel);
+          }
+        }
+      }
+
+      // Reduce ambiguity by checking if relative payload OMITS the prefix (M:M heuristic)
+      if let Some(keys) = relative_keys {
+        let mut missing_prefix_rels = Vec::new();
+        for rel in relations {
+          if let Some(prefix) = &rel.prefix {
+            if !keys.contains(prefix) {
+              missing_prefix_rels.push(rel);
+            }
+          }
+        }
+        if missing_prefix_rels.len() == 1 {
+          return Some(missing_prefix_rels[0]);
+        }
+      }
+    }
+    None
+  }
+
   fn collect_descendants_recursively(
     target: &str,
     direct_refs: &HashMap<String, Vec<String>>,
@@ -335,17 +426,14 @@ impl Database {
       if let (Some(pt), Some(prop)) = (&parent_type, &property_name) {
         let expected_col = format!("{}_id", prop);
         let mut found = false;
-        for rel in db.relations.values() {
-          if (rel.source_type == *pt && rel.destination_type == entity_type)
-            || (rel.source_type == entity_type && rel.destination_type == *pt)
-          {
-            if rel.source_columns.contains(&expected_col) {
-              relation_col = Some(expected_col.clone());
-              found = true;
-              break;
-            }
+
+        if let Some(rel) = db.get_relation(pt, &entity_type, prop, None) {
+          if rel.source_columns.contains(&expected_col) {
+            relation_col = Some(expected_col.clone());
+            found = true;
           }
         }
+
         if !found {
           relation_col = Some(expected_col);
         }

src/merger/mod.rs

@@ -21,15 +21,12 @@ impl Merger {
   }
 
   pub fn merge(&self, data: Value) -> crate::drop::Drop {
-    let mut val_resolved = Value::Null;
     let mut notifications_queue = Vec::new();
-    
+
     let result = self.merge_internal(data, &mut notifications_queue);
 
-    match result {
-      Ok(val) => {
-        val_resolved = val;
-      }
+    let val_resolved = match result {
+      Ok(val) => val,
       Err(msg) => {
         return crate::drop::Drop::with_errors(vec![crate::drop::Error {
           code: "MERGE_FAILED".to_string(),
@@ -44,7 +41,7 @@ impl Merger {
       }
     };
 
-    // Execute the globally collected, pre-ordered notifications last! 
+    // Execute the globally collected, pre-ordered notifications last!
     for notify_sql in notifications_queue {
       if let Err(e) = self.db.execute(&notify_sql, None) {
         return crate::drop::Drop::with_errors(vec![crate::drop::Error {
@@ -88,7 +85,11 @@ impl Merger {
     crate::drop::Drop::success_with_val(stripped_val)
   }
 
-  pub(crate) fn merge_internal(&self, data: Value, notifications: &mut Vec<String>) -> Result<Value, String> {
+  pub(crate) fn merge_internal(
+    &self,
+    data: Value,
+    notifications: &mut Vec<String>,
+  ) -> Result<Value, String> {
     match data {
       Value::Array(items) => self.merge_array(items, notifications),
       Value::Object(map) => self.merge_object(map, notifications),
@@ -96,7 +97,11 @@ impl Merger {
     }
   }
 
-  fn merge_array(&self, items: Vec<Value>, notifications: &mut Vec<String>) -> Result<Value, String> {
+  fn merge_array(
+    &self,
+    items: Vec<Value>,
+    notifications: &mut Vec<String>,
+  ) -> Result<Value, String> {
     let mut resolved_items = Vec::new();
     for item in items {
       let resolved = self.merge_internal(item, notifications)?;
@@ -105,7 +110,11 @@ impl Merger {
     Ok(Value::Array(resolved_items))
   }
 
-  fn merge_object(&self, obj: serde_json::Map<String, Value>, notifications: &mut Vec<String>) -> Result<Value, String> {
+  fn merge_object(
+    &self,
+    obj: serde_json::Map<String, Value>,
+    notifications: &mut Vec<String>,
+  ) -> Result<Value, String> {
     let queue_start = notifications.len();
 
     let type_name = match obj.get("type").and_then(|v| v.as_str()) {
@@ -164,7 +173,21 @@ impl Merger {
         _ => continue,
       };
 
-      let relative_relation = self.get_entity_relation(type_def, &relative, &relation_name)?;
+      // Attempt to extract relative object type name
+      let relative_type_name = match relative.get("type").and_then(|v| v.as_str()) {
+        Some(t) => t,
+        None => continue,
+      };
+
+      let relative_keys: Vec<String> = relative.keys().cloned().collect();
+
+      // Call central Database O(1) graph logic
+      let relative_relation = self.db.get_relation(
+        &type_def.name,
+        relative_type_name,
+        &relation_name,
+        Some(&relative_keys),
+      );
 
       if let Some(relation) = relative_relation {
         let parent_is_source = type_def.hierarchy.contains(&relation.source_type);
@@ -253,7 +276,21 @@ impl Merger {
         _ => continue,
       };
 
-      let relative_relation = self.get_entity_relation(type_def, first_relative, &relation_name)?;
+      // Attempt to extract relative object type name
+      let relative_type_name = match first_relative.get("type").and_then(|v| v.as_str()) {
+        Some(t) => t,
+        None => continue,
+      };
+
+      let relative_keys: Vec<String> = first_relative.keys().cloned().collect();
+
+      // Call central Database O(1) graph logic
+      let relative_relation = self.db.get_relation(
+        &type_def.name,
+        relative_type_name,
+        &relation_name,
+        Some(&relative_keys),
+      );
 
       if let Some(relation) = relative_relation {
         let mut relative_responses = Vec::new();
@@ -272,10 +309,11 @@ impl Merger {
               &entity_fields,
             );
 
-            let merged_relative = match self.merge_internal(Value::Object(relative_item), notifications)? {
-              Value::Object(m) => m,
-              _ => continue,
-            };
+            let merged_relative =
+              match self.merge_internal(Value::Object(relative_item), notifications)? {
+                Value::Object(m) => m,
+                _ => continue,
+              };
 
             relative_responses.push(Value::Object(merged_relative));
           }
@@ -766,101 +804,7 @@ impl Merger {
     changes
   }
 
-  fn reduce_entity_relations(
-    &self,
-    mut matching_relations: Vec<crate::database::relation::Relation>,
-    relative: &serde_json::Map<String, Value>,
-    relation_name: &str,
-  ) -> Result<Option<crate::database::relation::Relation>, String> {
-    if matching_relations.is_empty() {
-      return Ok(None);
-    }
-    if matching_relations.len() == 1 {
-      return Ok(Some(matching_relations.pop().unwrap()));
-    }
-
-    let exact_match: Vec<_> = matching_relations
-      .iter()
-      .filter(|r| r.prefix.as_deref() == Some(relation_name))
-      .cloned()
-      .collect();
-    if exact_match.len() == 1 {
-      return Ok(Some(exact_match.into_iter().next().unwrap()));
-    }
-
-    matching_relations.retain(|r| {
-      if let Some(prefix) = &r.prefix {
-        !relative.contains_key(prefix)
-      } else {
-        true
-      }
-    });
-
-    if matching_relations.len() == 1 {
-      Ok(Some(matching_relations.pop().unwrap()))
-    } else {
-      let constraints: Vec<_> = matching_relations
-        .iter()
-        .map(|r| r.constraint.clone())
-        .collect();
-      Err(format!(
-        "AMBIGUOUS_TYPE_RELATIONS: Could not reduce ambiguous type relations: {}",
-        constraints.join(", ")
-      ))
-    }
-  }
-
-  fn get_entity_relation(
-    &self,
-    entity_type: &crate::database::r#type::Type,
-    relative: &serde_json::Map<String, Value>,
-    relation_name: &str,
-  ) -> Result<Option<crate::database::relation::Relation>, String> {
-    let relative_type_name = match relative.get("type").and_then(|v| v.as_str()) {
-      Some(t) => t,
-      None => return Ok(None),
-    };
-
-    let relative_type = match self.db.types.get(relative_type_name) {
-      Some(t) => t,
-      None => return Ok(None),
-    };
-
-    let mut relative_relations: Vec<crate::database::relation::Relation> = Vec::new();
-
-    for r in self.db.relations.values() {
-      if r.source_type != "entity" && r.destination_type != "entity" {
-        let condition1 = relative_type.hierarchy.contains(&r.source_type)
-          && entity_type.hierarchy.contains(&r.destination_type);
-        let condition2 = entity_type.hierarchy.contains(&r.source_type)
-          && relative_type.hierarchy.contains(&r.destination_type);
-
-        if condition1 || condition2 {
-          relative_relations.push(r.clone());
-        }
-      }
-    }
-
-    let mut relative_relation =
-      self.reduce_entity_relations(relative_relations, relative, relation_name)?;
-
-    if relative_relation.is_none() {
-      let mut poly_relations: Vec<crate::database::relation::Relation> = Vec::new();
-      for r in self.db.relations.values() {
-        if r.destination_type == "entity" {
-          let condition1 = relative_type.hierarchy.contains(&r.source_type);
-          let condition2 = entity_type.hierarchy.contains(&r.source_type);
-
-          if condition1 || condition2 {
-            poly_relations.push(r.clone());
-          }
-        }
-      }
-      relative_relation = self.reduce_entity_relations(poly_relations, relative, relation_name)?;
-    }
-
-    Ok(relative_relation)
-  }
+  // Helper Functions
 
   fn apply_entity_relation(
     source_entity: &mut serde_json::Map<String, Value>,

src/queryer/mod.rs

@@ -97,7 +97,13 @@ impl Queryer {
       return Ok(cached_sql.value().clone());
     }
 
-    let compiler = compiler::SqlCompiler::new(self.db.clone());
+    let compiler = compiler::Compiler {
+      db: &self.db,
+      filter_keys: filter_keys,
+      is_stem_query: stem_opt.is_some(),
+      alias_counter: 0,
+    };
+
     match compiler.compile(schema_id, stem_opt, filter_keys) {
       Ok(compiled_sql) => {
         self

src/tests/mod.rs

@@ -2,7 +2,6 @@ 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
 

src/tests/runner.rs

@@ -1,19 +1,10 @@
+use crate::tests::types::Suite;
 use serde::Deserialize;
+use serde_json::Value;
 use std::collections::HashMap;
 use std::fs;
 use std::sync::{Arc, OnceLock, RwLock};
 
-#[derive(Debug, Deserialize)]
-pub struct TestSuite {
-  #[allow(dead_code)]
-  pub description: String,
-  pub database: serde_json::Value,
-  pub tests: Vec<TestCase>,
-}
-
-use crate::tests::types::TestCase;
-use serde_json::Value;
-
 pub fn deserialize_some<'de, D>(deserializer: D) -> Result<Option<Value>, D::Error>
 where
   D: serde::Deserializer<'de>,
@@ -23,7 +14,7 @@ where
 }
 
 // Type alias for easier reading
-type CompiledSuite = Arc<Vec<(TestSuite, Arc<crate::database::Database>)>>;
+type CompiledSuite = Arc<Vec<(Suite, Arc<crate::database::Database>)>>;
 
 // Global cache mapping filename -> Vector of (Parsed JSON suite, Compiled Database)
 static CACHE: OnceLock<RwLock<HashMap<String, CompiledSuite>>> = OnceLock::new();
@@ -46,7 +37,7 @@ fn get_cached_file(path: &str) -> CompiledSuite {
       } else {
         let content =
           fs::read_to_string(path).unwrap_or_else(|_| panic!("Failed to read file: {}", path));
-        let suites: Vec<TestSuite> = serde_json::from_str(&content)
+        let suites: Vec<Suite> = serde_json::from_str(&content)
           .unwrap_or_else(|e| panic!("Failed to parse JSON in {}: {}", path, e));
 
         let mut compiled_suites = Vec::new();

src/tests/sql_validator.rs

@@ -1,156 +0,0 @@
-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/case.rs

@@ -1,11 +1,11 @@
-use super::expect::ExpectBlock;
+use super::expect::Expect;
 use crate::database::Database;
 use serde::Deserialize;
 use serde_json::Value;
 use std::sync::Arc;
 
 #[derive(Debug, Deserialize)]
-pub struct TestCase {
+pub struct Case {
   pub description: String,
 
   #[serde(default = "default_action")]
@@ -30,14 +30,14 @@ pub struct TestCase {
   #[serde(default)]
   pub mocks: Option<serde_json::Value>,
 
-  pub expect: Option<ExpectBlock>,
+  pub expect: Option<Expect>,
 }
 
 fn default_action() -> String {
   "validate".to_string()
 }
 
-impl TestCase {
+impl Case {
   pub fn run_compile(&self, db: Arc<Database>) -> Result<(), String> {
     let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
 
@@ -138,6 +138,7 @@ impl TestCase {
       ))
     } else if let Some(expect) = &self.expect {
       let queries = db.executor.get_queries();
+      expect.assert_pattern(&queries)?;
       expect.assert_sql(&queries)
     } else {
       Ok(())
@@ -176,6 +177,7 @@ impl TestCase {
       ))
     } else if let Some(expect) = &self.expect {
       let queries = db.executor.get_queries();
+      expect.assert_pattern(&queries)?;
       expect.assert_sql(&queries)
     } else {
       Ok(())

src/tests/types/expect/mod.rs

@@ -0,0 +1,22 @@
+pub mod pattern;
+pub mod sql;
+
+use serde::Deserialize;
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+pub enum SqlExpectation {
+  Single(String),
+  Multi(Vec<String>),
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Expect {
+  pub success: bool,
+  pub result: Option<serde_json::Value>,
+  pub errors: Option<Vec<serde_json::Value>>,
+  pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
+  #[serde(default)]
+  pub sql: Option<Vec<SqlExpectation>>,
+}

src/tests/types/expect/pattern.rs

@@ -1,30 +1,13 @@
+use super::Expect;
 use regex::Regex;
-use serde::Deserialize;
 use std::collections::HashMap;
 
-#[derive(Debug, Deserialize)]
-#[serde(untagged)]
-pub enum SqlExpectation {
-  Single(String),
-  Multi(Vec<String>),
-}
-
-#[derive(Debug, Deserialize)]
-pub struct ExpectBlock {
-  pub success: bool,
-  pub result: Option<serde_json::Value>,
-  pub errors: Option<Vec<serde_json::Value>>,
-  pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
-  #[serde(default)]
-  pub sql: Option<Vec<SqlExpectation>>,
-}
-
-impl ExpectBlock {
+impl Expect {
   /// Advanced SQL execution assertion algorithm ported from `assert.go`.
   /// This compares two arrays of strings, one containing {{uuid:name}} or {{timestamp}} placeholders,
   /// and the other containing actual executed database queries. It ensures that placeholder UUIDs
   /// are consistently mapped to the same actual UUIDs across all lines, and strictly validates line-by-line sequences.
-  pub fn assert_sql(&self, actual: &[String]) -> Result<(), String> {
+  pub fn assert_pattern(&self, actual: &[String]) -> Result<(), String> {
     let patterns = match &self.sql {
       Some(s) => s,
       None => return Ok(()),
@@ -39,12 +22,6 @@ 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([
@@ -82,8 +59,8 @@ impl ExpectBlock {
       let aline = clean_str(aline_raw);
 
       let pattern_str_raw = match pattern_expect {
-        SqlExpectation::Single(s) => s.clone(),
-        SqlExpectation::Multi(m) => m.join(" "),
+        super::SqlExpectation::Single(s) => s.clone(),
+        super::SqlExpectation::Multi(m) => m.join(" "),
       };
 
       let pattern_str = clean_str(&pattern_str_raw);

src/tests/types/expect/sql.rs

@@ -0,0 +1,206 @@
+use super::Expect;
+use sqlparser::ast::{Expr, Query, SelectItem, Statement, TableFactor};
+use sqlparser::dialect::PostgreSqlDialect;
+use sqlparser::parser::Parser;
+use std::collections::HashSet;
+
+impl Expect {
+  pub fn assert_sql(&self, actual: &[String]) -> Result<(), String> {
+    for query in actual {
+      if let Err(e) = Self::validate_semantic_sql(query) {
+        return Err(e);
+      }
+    }
+    Ok(())
+  }
+
+  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 {
+      Self::validate_statement(&statement, sql)?;
+    }
+
+    Ok(())
+  }
+
+  fn validate_statement(stmt: &Statement, original_sql: &str) -> Result<(), String> {
+    match stmt {
+      Statement::Query(query) => Self::validate_query(query, &HashSet::new(), original_sql)?,
+      Statement::Insert(insert) => {
+        if let Some(query) = &insert.source {
+          Self::validate_query(query, &HashSet::new(), original_sql)?
+        }
+      }
+      Statement::Update(update) => {
+        if let Some(expr) = &update.selection {
+          Self::validate_expr(expr, &HashSet::new(), original_sql)?;
+        }
+      }
+      Statement::Delete(delete) => {
+        if let Some(expr) = &delete.selection {
+          Self::validate_expr(expr, &HashSet::new(), original_sql)?;
+        }
+      }
+      _ => {}
+    }
+    Ok(())
+  }
+
+  fn validate_query(
+    query: &Query,
+    available_aliases: &HashSet<String>,
+    original_sql: &str,
+  ) -> Result<(), String> {
+    if let sqlparser::ast::SetExpr::Select(select) = &*query.body {
+      Self::validate_select(&select, available_aliases, original_sql)?;
+    }
+    Ok(())
+  }
+
+  fn validate_select(
+    select: &sqlparser::ast::Select,
+    parent_aliases: &HashSet<String>,
+    original_sql: &str,
+  ) -> Result<(), String> {
+    let mut available_aliases = parent_aliases.clone();
+
+    // 1. Collect all declared table aliases in the FROM clause and JOINs
+    for table_with_joins in &select.from {
+      Self::collect_aliases_from_table_factor(&table_with_joins.relation, &mut available_aliases);
+      for join in &table_with_joins.joins {
+        Self::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 {
+        Self::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 sqlparser::ast::JoinOperator::Inner(sqlparser::ast::JoinConstraint::On(expr))
+        | sqlparser::ast::JoinOperator::LeftOuter(sqlparser::ast::JoinConstraint::On(expr))
+        | sqlparser::ast::JoinOperator::RightOuter(sqlparser::ast::JoinConstraint::On(expr))
+        | sqlparser::ast::JoinOperator::FullOuter(sqlparser::ast::JoinConstraint::On(expr))
+        | sqlparser::ast::JoinOperator::Join(sqlparser::ast::JoinConstraint::On(expr)) =
+          &join.join_operator
+        {
+          Self::validate_expr(expr, &available_aliases, original_sql)?;
+        }
+      }
+    }
+
+    // 4. Validate WHERE conditions
+    if let Some(selection) = &select.selection {
+      Self::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 {
+        subquery,
+        alias: Some(table_alias),
+        ..
+      } => {
+        aliases.insert(table_alias.name.value.clone());
+        // A derived table is technically a nested scope which is opaque outside, but for pure semantic checks
+        // its internal contents should be validated purely within its own scope (not leaking external aliases in, usually)
+        // but Postgres allows lateral correlation. We will validate its interior with an empty scope.
+        let _ = Self::validate_query(subquery, &HashSet::new(), "");
+      }
+      _ => {}
+    }
+  }
+
+  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::Subquery(subquery) => Self::validate_query(subquery, available_aliases, sql)?,
+      Expr::Exists { subquery, .. } => Self::validate_query(subquery, available_aliases, sql)?,
+      Expr::InSubquery {
+        expr: e, subquery, ..
+      } => {
+        Self::validate_expr(e, available_aliases, sql)?;
+        Self::validate_query(subquery, available_aliases, sql)?;
+      }
+      Expr::BinaryOp { left, right, .. } => {
+        Self::validate_expr(left, available_aliases, sql)?;
+        Self::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, .. } => {
+        Self::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)
+          {
+            Self::validate_expr(e, available_aliases, sql)?;
+          }
+        }
+      }
+      _ => {}
+    }
+    Ok(())
+  }
+}

src/tests/types/mod.rs

@@ -2,6 +2,6 @@ pub mod case;
 pub mod expect;
 pub mod suite;
 
-pub use case::TestCase;
-pub use expect::ExpectBlock;
-pub use suite::TestSuite;
+pub use case::Case;
+pub use expect::Expect;
+pub use suite::Suite;

src/tests/types/suite.rs

@@ -1,10 +1,10 @@
-use super::case::TestCase;
+use super::case::Case;
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
-pub struct TestSuite {
+pub struct Suite {
   #[allow(dead_code)]
   pub description: String,
   pub database: serde_json::Value,
-  pub tests: Vec<TestCase>,
+  pub tests: Vec<Case>,
 }

src/validator/mod.rs

@@ -68,11 +68,11 @@ impl Validator {
                 code: e.code,
                 message: e.message,
                 details: crate::drop::ErrorDetails {
-            path: e.path,
-            cause: None,
-            context: None,
-            schema: None,
-          },
+                  path: e.path,
+                  cause: None,
+                  context: None,
+                  schema: None,
+                },
               })
               .collect();
             crate::drop::Drop::with_errors(errors)

version

@@ -1 +1 @@
-1.0.70
+1.0.73