version: 1.0.151

fixtures/queryer.json

@@ -2432,7 +2432,7 @@
               "  JOIN agreego.entity entity_2 ON entity_2.id = order_1.id",
               "  WHERE",
               "    NOT entity_2.archived",
-              "    AND order_1.counterparty_type = 'organization'",
+              "    AND order_1.counterparty_type IN ('bot', 'organization', 'person')",
               "))))"
             ]
           ]

src/queryer/compiler.rs

@@ -603,7 +603,7 @@ impl<'a> Compiler<'a> {
 
             if let Some(type_name) = bound_type_name {
               // Ensure this type actually exists
-              if self.db.types.contains_key(&type_name) {
+              if let Some(type_def) = self.db.types.get(&type_name) {
                 if let Some(relation) = self.db.relations.get(&edge.constraint) {
                   let mut poly_col = None;
                   let mut table_to_alias = "";
@@ -621,7 +621,23 @@ impl<'a> Compiler<'a> {
                       .get(table_to_alias)
                       .or_else(|| type_aliases.get(&node.parent_alias))
                     {
-                      where_clauses.push(format!("{}.{} = '{}'", alias, col, type_name));
+                      // DEBUG: See what variations we have for this type
+                      #[cfg(not(test))]
+                      pgrx::notice!("JSPG_POLY_BOUNDS: type={}, col={}, variations_len={}, variations={:?}", type_name, col, type_def.variations.len(), type_def.variations);
+
+                      // Use IN clause with all variations to support inherited types.
+                      // e.g., "asset" has variations ["asset", "property", "unit", ...]
+                      // so target_type IN ('asset','property','unit') instead of = 'asset'
+                      if type_def.variations.len() > 1 {
+                        let quoted: Vec<String> = type_def.variations.iter()
+                          .map(|v| format!("'{}'", v))
+                          .collect();
+                        where_clauses.push(format!(
+                          "{}.{} IN ({})", alias, col, quoted.join(", ")
+                        ));
+                      } else {
+                        where_clauses.push(format!("{}.{} = '{}'", alias, col, type_name));
+                      }
                     }
                   }
                 }

src/queryer/mod.rs

@@ -50,6 +50,10 @@ impl Queryer {
       Err(drop) => return drop,
     };
 
+    // DEBUG: Emit compiled SQL as a NOTICE for inspection
+    #[cfg(not(test))]
+    pgrx::notice!("JSPG_SQL[{}]: {}", schema_id, sql);
+
     // 3. Execute via Database Executor
     self.execute_sql(schema_id, &sql, args)
   }

src/validator/mod.rs

@@ -42,62 +42,83 @@ impl Validator {
   }
 
   pub fn validate(&self, schema_id: &str, instance: &Value) -> crate::drop::Drop {
-    let schema_opt = self.db.schemas.get(schema_id);
+    let schema_arc = if schema_id.trim().starts_with('{') {
-
+      match serde_json::from_str::<crate::database::schema::Schema>(schema_id) {
-    if let Some(schema) = schema_opt {
+        Ok(schema) => {
-      let ctx = ValidationContext::new(
+          let mut errors = Vec::new();
-        &self.db,
+          schema.compile(&self.db, "inline", "inline".to_string(), &mut errors);
-        &schema,
+          if !errors.is_empty() {
-        &schema,
+            return crate::drop::Drop::with_errors(errors);
-        instance,
-        HashSet::new(),
-        false,
-        false,
-      );
-      match ctx.validate_scoped() {
-        Ok(result) => {
-          if result.is_valid() {
-            crate::drop::Drop::success()
-          } else {
-            let errors: Vec<crate::drop::Error> = result
-              .errors
-              .into_iter()
-              .map(|e| crate::drop::Error {
-                code: e.code,
-                message: e.message,
-                details: crate::drop::ErrorDetails {
-                  path: Some(e.path),
-                  cause: None,
-                  context: None,
-                  schema: None,
-                },
-              })
-              .collect();
-            crate::drop::Drop::with_errors(errors)
           }
+          Arc::new(schema)
+        }
+        Err(e) => {
+          return crate::drop::Drop::with_errors(vec![crate::drop::Error {
+            code: "SCHEMA_PARSE_FAILED".to_string(),
+            message: format!("Failed to parse inline schema: {}", e),
+            details: crate::drop::ErrorDetails::default(),
+          }]);
         }
-        Err(e) => crate::drop::Drop::with_errors(vec![crate::drop::Error {
-          code: e.code,
-          message: e.message,
-          details: crate::drop::ErrorDetails {
-            path: Some(e.path),
-            cause: None,
-            context: None,
-            schema: None,
-          },
-        }]),
       }
     } else {
-      crate::drop::Drop::with_errors(vec![crate::drop::Error {
+      match self.db.schemas.get(schema_id) {
-        code: "SCHEMA_NOT_FOUND".to_string(),
+        Some(schema) => Arc::clone(schema),
-        message: format!("Schema {} not found", schema_id),
+        None => {
+          return crate::drop::Drop::with_errors(vec![crate::drop::Error {
+            code: "SCHEMA_NOT_FOUND".to_string(),
+            message: format!("Schema {} not found", schema_id),
+            details: crate::drop::ErrorDetails {
+              path: Some("/".to_string()),
+              cause: None,
+              context: None,
+              schema: None,
+            },
+          }]);
+        }
+      }
+    };
+
+    let ctx = ValidationContext::new(
+      &self.db,
+      &schema_arc,
+      &schema_arc,
+      instance,
+      HashSet::new(),
+      false,
+      false,
+    );
+    match ctx.validate_scoped() {
+      Ok(result) => {
+        if result.is_valid() {
+          crate::drop::Drop::success()
+        } else {
+          let errors: Vec<crate::drop::Error> = result
+            .errors
+            .into_iter()
+            .map(|e| crate::drop::Error {
+              code: e.code,
+              message: e.message,
+              details: crate::drop::ErrorDetails {
+                path: Some(e.path),
+                cause: None,
+                context: None,
+                schema: None,
+              },
+            })
+            .collect();
+          crate::drop::Drop::with_errors(errors)
+        }
+      }
+      Err(e) => crate::drop::Drop::with_errors(vec![crate::drop::Error {
+        code: e.code,
+        message: e.message,
         details: crate::drop::ErrorDetails {
-          path: Some("/".to_string()),
+          path: Some(e.path),
           cause: None,
           context: None,
           schema: None,
         },
-      }])
+      }]),
     }
   }
 }

version

@@ -1 +1 @@
-1.0.149
+1.0.151